Exported functions are detected as props about sveld

[aabounegm]

On the other hand, I just found out that renamed exports are not documented. If I have

let _class = null;
export { _class as class };

for example (which I do have in many components), neither _class nor class make it to the generated declaration file.

[TorstenDittmann]

This is a blocker for me as well right now 👍🏻

But for me it is exporting an object containing functions.

  /** @type {AccountCreateActions} */
  export const actions = {
    create: async (email, password, name = "") => {
      try {
        const response = await Appwrite.sdk.account.create(
          email,
          password,
          name
        );
        dispatch("success", response);
        return response;
      } catch (error) {
        dispatch("failure", error);
      }
    },
  };

is generated into:

    export interface CreateProps  {
      
      /**
* @constant
* @default { create: async (email, password, name = "") => { try { const response = await Appwrite.sdk.account.create( email, password, name ); dispatch("success", response); return response; } catch (error) { dispatch("failure", error); } }, }
*/
      actions?: {     create: async (email, password, name = "") => {       try {         const response = await Appwrite.sdk.account.create(           email,           password,           name         );         dispatch("success", response);         return response;       } catch (error) {         dispatch("failure", error);       }     },   };
    }

Using export let actions makes it generate valid definitions und uses my @typedef at least, but still sets the wrong @default notation.

export interface AccountCreateActions {
  actions: {
    create: (email: string, password: string, name?: string) => Promise<object>;
  };
}

export interface CreateProps {
  /**
   * @default { create: async (email, password, name = "") => { try { const response = await Appwrite.sdk.account.create( email, password, name ); dispatch("success", response); return response; } catch (error) { dispatch("failure", error); } }, }
   */
  actions?: AccountCreateActions;
}

[metonym]

in v0.8.1, function declarations are now typed as accessors on the SvelteComponentTyped interface.

Input

<script>
  export let fnA = () => {};

  export const fnB = () => {};

  export function add(a, b) {
    return a + b;
  }

  /** 
   * Multiplies two numbers
   * @type {(a: number, b: number) => number}
   */
  export function multiply(a, b) {
    return a * b;
  }
</script>

<h1 on:click={fnA}>Heading</h1>

Output

/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";

export interface InputProps {
  /**
   * @default () => {}
   */
  fnA?: () => {};

  /**
   * @constant
   * @default () => {}
   */
  fnB?: () => {};
}

export default class Input extends SvelteComponentTyped<InputProps, {}, {}> {
  add: () => any;

  /**
   * Multiplies two numbers
   */
  multiply: (a: number, b: number) => number;
}

[aabounegm]

Great! I can confirm that the exported function is now treated as an accessor, but for some reason it still emits a @default annotation for it that contains the full implementation of the function, as outlined in the original comment on this issue.

[metonym]

@aabounegm The @default comment notation is omitted in v0.9.0