@plasmicapp/host 1.0.166 → 1.0.168

package/registerFunction/dist/registerFunction.d.ts

@@ -0,0 +1,105 @@
+export type StringType<T extends string = string> = "string" | `'${T}'`;
+export type NumberType<T extends number = number> = "number" | `${number extends T ? number : T}`;
+export type BooleanType<T extends boolean = boolean> = "boolean" | `${boolean extends T ? boolean : T}`;
+export type NullType = "null";
+export type UndefinedType = "undefined";
+export type ArrayType = "array";
+export type ObjectType = "object";
+export type AnyType = "any";
+export type VoidType = "void";
+export type RestrictedType<T> = T extends string ? StringType<T> : T extends number ? NumberType<T> : T extends boolean ? BooleanType<T> : T extends null ? NullType : T extends undefined ? UndefinedType : T extends Array<any> ? ArrayType : T extends object ? ObjectType : AnyType;
+export type OrType<T> = RestrictedType<T>[];
+export type ParamType<T> = AnyType | RestrictedType<T> | OrType<T>;
+export interface BaseParam<T> {
+    name: string;
+    type?: ParamType<T>;
+    description?: string;
+    isOptional?: boolean;
+    isRestParam?: boolean;
+}
+export interface RequiredParam<T> extends BaseParam<T> {
+    isOptional?: false;
+    isRestParameter?: false;
+}
+export interface OptionalParam<T> extends BaseParam<T | undefined> {
+    isRestParameter?: false;
+}
+export interface RestParam<T> extends BaseParam<T> {
+    isOptional?: false;
+    isRestParameter: true;
+}
+type RequiredParams<T extends any[], U extends any[] = []> = Partial<T> extends T ? U : T extends [infer F, ...infer R] ? RequiredParams<R, [...U, F]> : U;
+type OptionalParams<T extends any[]> = T extends [
+    ...RequiredParams<T>,
+    ...infer R
+] ? [...R] : [];
+type HandleRequiredParams<P extends any[]> = P extends [infer H, ...infer T] ? [string | RequiredParam<H>, ...HandleRequiredParams<T>] : [];
+type HandleOptionalParams<P extends any[]> = P extends [infer H, ...infer T] ? [] | [string | OptionalParam<H | undefined>, ...HandleOptionalParams<T>] : P extends [] ? [] : P extends Array<infer T> ? [] | [RestParam<T[]>] : [];
+export type HandleParams<P extends any[]> = [
+    ...HandleRequiredParams<RequiredParams<P>>,
+    ...HandleOptionalParams<Required<OptionalParams<P>>>
+];
+export type HandleReturnType<T> = VoidType | ParamType<T>;
+export interface CustomFunctionMeta<F extends (...args: any[]) => any> {
+    /**
+     * The javascript name of the function. Notice it must be unique across all
+     * other functions and function namespaces. If two functions have the same
+     * name, they should be registered with different `meta.namespace`.
+     */
+    name: string;
+    /**
+     * A namespace for organizing groups of functions. It's also used to handle
+     * function name collisions. If a function has a namespace, it will be used
+     * whenever accessing the function.
+     */
+    namespace?: string;
+    /**
+     * Documentation for the registered function.
+     */
+    description?: string;
+    /**
+     * An array containing the list of parameters names the function takes.
+     * Optionally they can also be registered with the expected param types.
+     */
+    params?: HandleParams<Parameters<F>>;
+    /**
+     * Return value information.
+     */
+    returnValue?: {
+        /**
+         * The function return type.
+         */
+        type?: HandleReturnType<ReturnType<F>>;
+        /**
+         * The function return value description.
+         */
+        description?: string;
+    };
+    /**
+     * Typescript function declaration. If specified, it ignores the types
+     * provided by `params` and `returnValue`.
+     */
+    typescriptDeclaration?: string;
+    /**
+     * The path to be used when importing the function in the generated code.
+     * It can be the name of the package that contains the function, or the path
+     * to the file in the project (relative to the root directory).
+     */
+    importPath: string;
+    /**
+     * Whether the function is the default export from that path. Optional: if
+     * not specified, it's considered `false`.
+     */
+    isDefaultExport?: boolean;
+}
+export interface CustomFunctionRegistration {
+    function: (...args: any[]) => any;
+    meta: CustomFunctionMeta<any>;
+}
+declare global {
+    interface Window {
+        __PlasmicFunctionsRegistry: CustomFunctionRegistration[];
+    }
+}
+export default function unstable_registerFunction<F extends (...args: any[]) => any>(fn: F, meta: CustomFunctionMeta<F>): void;
+export {};

package/registerFunction/dist/registerGlobalContext.d.ts

@@ -0,0 +1,76 @@
+/// <reference types="react" />
+import { BooleanType, ChoiceType, CustomType, JSONLikeType, NumberType, StringType, DataSourceType } from "./prop-types";
+import { FunctionParam } from "./registerComponent";
+export type PropType<P> = StringType<P> | BooleanType<P> | NumberType<P> | JSONLikeType<P> | ChoiceType<P> | CustomType<P> | DataSourceType<P>;
+type RestrictPropType<T, P> = T extends string ? StringType<P> | ChoiceType<P> | JSONLikeType<P> | CustomType<P> : T extends boolean ? BooleanType<P> | JSONLikeType<P> | CustomType<P> : T extends number ? NumberType<P> | JSONLikeType<P> | CustomType<P> : PropType<P>;
+type DistributedKeyOf<T> = T extends any ? keyof T : never;
+export interface GlobalContextMeta<P> {
+    /**
+     * Any unique string name used to identify that context. Each context
+     * should be registered with a different `meta.name`, even if they have the
+     * same name in the code.
+     */
+    name: string;
+    /**
+     * The name to be displayed for the context in Studio. Optional: if not
+     * specified, `meta.name` is used.
+     */
+    displayName?: string;
+    /**
+     * The description of the context to be shown in Studio.
+     */
+    description?: string;
+    /**
+     * The javascript name to be used when generating code. Optional: if not
+     * provided, `meta.name` is used.
+     */
+    importName?: string;
+    /**
+     * An object describing the context properties to be used in Studio.
+     * For each `prop`, there should be an entry `meta.props[prop]` describing
+     * its type.
+     */
+    props: {
+        [prop in DistributedKeyOf<P>]?: RestrictPropType<P[prop], P>;
+    } & {
+        [prop: string]: PropType<P>;
+    };
+    /**
+     * The path to be used when importing the context in the generated code.
+     * It can be the name of the package that contains the context, or the path
+     * to the file in the project (relative to the root directory).
+     */
+    importPath: string;
+    /**
+     *  Whether the context is the default export from that path. Optional: if
+     * not specified, it's considered `false`.
+     */
+    isDefaultExport?: boolean;
+    /**
+     * The prop that receives and forwards a React `ref`. Plasmic only uses `ref`
+     * to interact with components, so it's not used in the generated code.
+     * Optional: If not provided, the usual `ref` is used.
+     */
+    refProp?: string;
+    /**
+     * Whether the global context provides data to its children using DataProvider.
+     */
+    providesData?: boolean;
+    unstable__globalActions?: Record<string, GlobalActionRegistration<P>>;
+}
+export interface GlobalContextRegistration {
+    component: React.ComponentType<any>;
+    meta: GlobalContextMeta<any>;
+}
+export interface GlobalActionRegistration<P> {
+    displayName?: string;
+    description?: string;
+    parameters: FunctionParam<P>[];
+}
+declare global {
+    interface Window {
+        __PlasmicContextRegistry: GlobalContextRegistration[];
+    }
+}
+export default function registerGlobalContext<T extends React.ComponentType<any>>(component: T, meta: GlobalContextMeta<React.ComponentProps<T>>): void;
+export {};

package/registerFunction/dist/registerToken.d.ts

@@ -0,0 +1,34 @@
+export type TokenType = "color" | "spacing" | "font-family" | "font-size" | "line-height" | "opacity";
+export interface TokenRegistration {
+    /**
+     * Name for this token; should be stable across updates
+     */
+    name: string;
+    /**
+     * Value for the token, which can either be a valid css value or a css reference
+     * to a css variable provided by your host app, like `var(--my-token)`
+     */
+    value: string;
+    /**
+     * Type of token
+     */
+    type: TokenType;
+    /**
+     * Optional display name to use for this token, if you'd like to use a friendlier
+     * name to display to Studio users
+     */
+    displayName?: string;
+    /**
+     * By default, if this token is a css variable reference like `var(--my-token)`,
+     * then it is assumed that `--my-token` is defined on `:root`.  If it is defined
+     * in another element, then you can pass in a selector for that element,
+     * like `.themeRoot`.
+     */
+    selector?: string;
+}
+declare global {
+    interface Window {
+        __PlasmicTokenRegistry: TokenRegistration[];
+    }
+}
+export default function registerToken(token: TokenRegistration): void;

package/registerFunction/dist/registerTrait.d.ts

@@ -0,0 +1,20 @@
+export interface BasicTrait {
+    label?: string;
+    type: "text" | "number" | "boolean";
+}
+export interface ChoiceTrait {
+    label?: string;
+    type: "choice";
+    options: string[];
+}
+export type TraitMeta = BasicTrait | ChoiceTrait;
+export interface TraitRegistration {
+    trait: string;
+    meta: TraitMeta;
+}
+declare global {
+    interface Window {
+        __PlasmicTraitRegistry: TraitRegistration[];
+    }
+}
+export default function registerTrait(trait: string, meta: TraitMeta): void;

package/registerFunction/dist/repeatedElement.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Allows elements to be repeated in Plasmic Studio.
+ * @param index The index of the copy (starting at 0).
+ * @param elt the React element to be repeated (or an array of such).
+ */
+export default function repeatedElement<T>(index: number, elt: T): T;
+/**
+ * Allows elements to be repeated in Plasmic Studio.
+ * @param isPrimary should be true for at most one instance of the element, and
+ * indicates which copy of the element will be highlighted when the element is
+ * selected in Studio.
+ * @param elt the React element to be repeated (or an array of such).
+ */
+export default function repeatedElement<T>(isPrimary: boolean, elt: T): T;
+export declare const setRepeatedElementFn: (fn: typeof repeatedElement) => void;

package/registerFunction/dist/type-utils.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Converts a union type to a tuple type of the same members
+ */
+export type TupleUnion<U extends string, R extends string[] = []> = {
+    [S in U]: Exclude<U, S> extends never ? [...R, S] : TupleUnion<Exclude<U, S>, [...R, S]>;
+}[U] & string[];

package/registerFunction/dist/useForceUpdate.d.ts

@@ -0,0 +1 @@
+export default function useForceUpdate(): () => void;

package/registerFunction/dist/version.d.ts

@@ -0,0 +1 @@
+export declare const hostVersion = "1.0.168";

package/registerFunction/package.json

@@ -0,0 +1,5 @@
+{
+  "main": "dist/index.cjs.js",
+  "types": "dist/registerFunction.d.ts",
+  "module": "dist/index.esm.js"
+}

package/registerGlobalContext/dist/exports.d.ts

@@ -3,10 +3,11 @@ export * from "./data";
 export { PlasmicElement } from "./element-types";
 export { registerFetcher as unstable_registerFetcher } from "./fetcher";
 export * from "./global-actions";
-export { Action, ActionProps, CodeComponentMeta, ComponentHelpers, ComponentMeta, ComponentRegistration, ComponentTemplates, default as registerComponent, stateHelpersKeys, StateHelpers, StateSpec, CodeComponentMode, } from "./registerComponent";
-export { PropType, ContextDependentConfig } from "./prop-types";
+export * from "./link";
+export { ContextDependentConfig, PropType } from "./prop-types";
+export { Action, ActionProps, CodeComponentMeta, CodeComponentMode, ComponentHelpers, ComponentMeta, ComponentRegistration, ComponentTemplates, default as registerComponent, StateHelpers, stateHelpersKeys, StateSpec, } from "./registerComponent";
+export { CustomFunctionMeta, CustomFunctionRegistration, default as unstable_registerFunction, ParamType, } from "./registerFunction";
 export { default as registerGlobalContext, GlobalContextMeta, GlobalContextRegistration, PropType as GlobalContextPropType, } from "./registerGlobalContext";
 export { default as registerToken, TokenRegistration, TokenType, } from "./registerToken";
 export { BasicTrait, ChoiceTrait, default as registerTrait, TraitMeta, TraitRegistration, } from "./registerTrait";
 export { default as repeatedElement } from "./repeatedElement";
-export * from "./link";

package/registerGlobalContext/dist/prop-types.d.ts

@@ -296,7 +296,7 @@ export interface EventHandlerType<P> extends PropTypeBase<P> {
     type: "eventHandler";
     argTypes: {
         name: string;
-        type: PropType<any>;
+        type: ArgType<any>;
     }[];
 }
 export interface ChoiceTypeBase<P, T> extends PropTypeBaseDefault<P, T> {
@@ -419,6 +419,7 @@ export interface RichCustomType<P> extends PropTypeBaseDefault<P, any> {
 export type CustomType<P> = RichCustomType<P> | CustomControl<P>;
 export type PrimitiveType<P = any> = Extract<StringType<P> | BooleanType<P> | NumberType<P> | JSONLikeType<P>, string>;
 export type PropType<P> = StringType<P> | BooleanType<P> | GraphQLType<P> | NumberType<P> | JSONLikeType<P> | DataSourceType<P> | DataPickerType<P> | ExprEditorType<P> | FormValidationRulesType<P> | EventHandlerType<P> | ChoiceType<P> | CustomType<P> | ImageUrlType<P> | SlotType<P> | DateStringType<P> | DateRangeStringsType<P>;
+export type ArgType<P> = Exclude<PropType<P>, SlotType<P> | EventHandlerType<P>>;
 export type StringCompatType<P> = DateStringType<P> | StringType<P> | ChoiceType<P> | JSONLikeType<P> | ImageUrlType<P> | CustomType<P> | DataPickerType<P>;
 export type BoolCompatType<P> = BooleanType<P> | CustomType<P> | DataPickerType<P>;
 export type NumberCompatType<P> = NumberType<P> | CustomType<P> | DataPickerType<P>;

package/registerGlobalContext/dist/registerFunction.d.ts

@@ -0,0 +1,105 @@
+export type StringType<T extends string = string> = "string" | `'${T}'`;
+export type NumberType<T extends number = number> = "number" | `${number extends T ? number : T}`;
+export type BooleanType<T extends boolean = boolean> = "boolean" | `${boolean extends T ? boolean : T}`;
+export type NullType = "null";
+export type UndefinedType = "undefined";
+export type ArrayType = "array";
+export type ObjectType = "object";
+export type AnyType = "any";
+export type VoidType = "void";
+export type RestrictedType<T> = T extends string ? StringType<T> : T extends number ? NumberType<T> : T extends boolean ? BooleanType<T> : T extends null ? NullType : T extends undefined ? UndefinedType : T extends Array<any> ? ArrayType : T extends object ? ObjectType : AnyType;
+export type OrType<T> = RestrictedType<T>[];
+export type ParamType<T> = AnyType | RestrictedType<T> | OrType<T>;
+export interface BaseParam<T> {
+    name: string;
+    type?: ParamType<T>;
+    description?: string;
+    isOptional?: boolean;
+    isRestParam?: boolean;
+}
+export interface RequiredParam<T> extends BaseParam<T> {
+    isOptional?: false;
+    isRestParameter?: false;
+}
+export interface OptionalParam<T> extends BaseParam<T | undefined> {
+    isRestParameter?: false;
+}
+export interface RestParam<T> extends BaseParam<T> {
+    isOptional?: false;
+    isRestParameter: true;
+}
+type RequiredParams<T extends any[], U extends any[] = []> = Partial<T> extends T ? U : T extends [infer F, ...infer R] ? RequiredParams<R, [...U, F]> : U;
+type OptionalParams<T extends any[]> = T extends [
+    ...RequiredParams<T>,
+    ...infer R
+] ? [...R] : [];
+type HandleRequiredParams<P extends any[]> = P extends [infer H, ...infer T] ? [string | RequiredParam<H>, ...HandleRequiredParams<T>] : [];
+type HandleOptionalParams<P extends any[]> = P extends [infer H, ...infer T] ? [] | [string | OptionalParam<H | undefined>, ...HandleOptionalParams<T>] : P extends [] ? [] : P extends Array<infer T> ? [] | [RestParam<T[]>] : [];
+export type HandleParams<P extends any[]> = [
+    ...HandleRequiredParams<RequiredParams<P>>,
+    ...HandleOptionalParams<Required<OptionalParams<P>>>
+];
+export type HandleReturnType<T> = VoidType | ParamType<T>;
+export interface CustomFunctionMeta<F extends (...args: any[]) => any> {
+    /**
+     * The javascript name of the function. Notice it must be unique across all
+     * other functions and function namespaces. If two functions have the same
+     * name, they should be registered with different `meta.namespace`.
+     */
+    name: string;
+    /**
+     * A namespace for organizing groups of functions. It's also used to handle
+     * function name collisions. If a function has a namespace, it will be used
+     * whenever accessing the function.
+     */
+    namespace?: string;
+    /**
+     * Documentation for the registered function.
+     */
+    description?: string;
+    /**
+     * An array containing the list of parameters names the function takes.
+     * Optionally they can also be registered with the expected param types.
+     */
+    params?: HandleParams<Parameters<F>>;
+    /**
+     * Return value information.
+     */
+    returnValue?: {
+        /**
+         * The function return type.
+         */
+        type?: HandleReturnType<ReturnType<F>>;
+        /**
+         * The function return value description.
+         */
+        description?: string;
+    };
+    /**
+     * Typescript function declaration. If specified, it ignores the types
+     * provided by `params` and `returnValue`.
+     */
+    typescriptDeclaration?: string;
+    /**
+     * The path to be used when importing the function in the generated code.
+     * It can be the name of the package that contains the function, or the path
+     * to the file in the project (relative to the root directory).
+     */
+    importPath: string;
+    /**
+     * Whether the function is the default export from that path. Optional: if
+     * not specified, it's considered `false`.
+     */
+    isDefaultExport?: boolean;
+}
+export interface CustomFunctionRegistration {
+    function: (...args: any[]) => any;
+    meta: CustomFunctionMeta<any>;
+}
+declare global {
+    interface Window {
+        __PlasmicFunctionsRegistry: CustomFunctionRegistration[];
+    }
+}
+export default function unstable_registerFunction<F extends (...args: any[]) => any>(fn: F, meta: CustomFunctionMeta<F>): void;
+export {};

package/registerGlobalContext/dist/version.d.ts

@@ -1 +1 @@
-export declare const hostVersion = "1.0.166";
+export declare const hostVersion = "1.0.168";

package/registerToken/dist/exports.d.ts

@@ -3,10 +3,11 @@ export * from "./data";
 export { PlasmicElement } from "./element-types";
 export { registerFetcher as unstable_registerFetcher } from "./fetcher";
 export * from "./global-actions";
-export { Action, ActionProps, CodeComponentMeta, ComponentHelpers, ComponentMeta, ComponentRegistration, ComponentTemplates, default as registerComponent, stateHelpersKeys, StateHelpers, StateSpec, CodeComponentMode, } from "./registerComponent";
-export { PropType, ContextDependentConfig } from "./prop-types";
+export * from "./link";
+export { ContextDependentConfig, PropType } from "./prop-types";
+export { Action, ActionProps, CodeComponentMeta, CodeComponentMode, ComponentHelpers, ComponentMeta, ComponentRegistration, ComponentTemplates, default as registerComponent, StateHelpers, stateHelpersKeys, StateSpec, } from "./registerComponent";
+export { CustomFunctionMeta, CustomFunctionRegistration, default as unstable_registerFunction, ParamType, } from "./registerFunction";
 export { default as registerGlobalContext, GlobalContextMeta, GlobalContextRegistration, PropType as GlobalContextPropType, } from "./registerGlobalContext";
 export { default as registerToken, TokenRegistration, TokenType, } from "./registerToken";
 export { BasicTrait, ChoiceTrait, default as registerTrait, TraitMeta, TraitRegistration, } from "./registerTrait";
 export { default as repeatedElement } from "./repeatedElement";
-export * from "./link";

package/registerToken/dist/prop-types.d.ts

@@ -296,7 +296,7 @@ export interface EventHandlerType<P> extends PropTypeBase<P> {
     type: "eventHandler";
     argTypes: {
         name: string;
-        type: PropType<any>;
+        type: ArgType<any>;
     }[];
 }
 export interface ChoiceTypeBase<P, T> extends PropTypeBaseDefault<P, T> {
@@ -419,6 +419,7 @@ export interface RichCustomType<P> extends PropTypeBaseDefault<P, any> {
 export type CustomType<P> = RichCustomType<P> | CustomControl<P>;
 export type PrimitiveType<P = any> = Extract<StringType<P> | BooleanType<P> | NumberType<P> | JSONLikeType<P>, string>;
 export type PropType<P> = StringType<P> | BooleanType<P> | GraphQLType<P> | NumberType<P> | JSONLikeType<P> | DataSourceType<P> | DataPickerType<P> | ExprEditorType<P> | FormValidationRulesType<P> | EventHandlerType<P> | ChoiceType<P> | CustomType<P> | ImageUrlType<P> | SlotType<P> | DateStringType<P> | DateRangeStringsType<P>;
+export type ArgType<P> = Exclude<PropType<P>, SlotType<P> | EventHandlerType<P>>;
 export type StringCompatType<P> = DateStringType<P> | StringType<P> | ChoiceType<P> | JSONLikeType<P> | ImageUrlType<P> | CustomType<P> | DataPickerType<P>;
 export type BoolCompatType<P> = BooleanType<P> | CustomType<P> | DataPickerType<P>;
 export type NumberCompatType<P> = NumberType<P> | CustomType<P> | DataPickerType<P>;

package/registerToken/dist/registerFunction.d.ts

@@ -0,0 +1,105 @@
+export type StringType<T extends string = string> = "string" | `'${T}'`;
+export type NumberType<T extends number = number> = "number" | `${number extends T ? number : T}`;
+export type BooleanType<T extends boolean = boolean> = "boolean" | `${boolean extends T ? boolean : T}`;
+export type NullType = "null";
+export type UndefinedType = "undefined";
+export type ArrayType = "array";
+export type ObjectType = "object";
+export type AnyType = "any";
+export type VoidType = "void";
+export type RestrictedType<T> = T extends string ? StringType<T> : T extends number ? NumberType<T> : T extends boolean ? BooleanType<T> : T extends null ? NullType : T extends undefined ? UndefinedType : T extends Array<any> ? ArrayType : T extends object ? ObjectType : AnyType;
+export type OrType<T> = RestrictedType<T>[];
+export type ParamType<T> = AnyType | RestrictedType<T> | OrType<T>;
+export interface BaseParam<T> {
+    name: string;
+    type?: ParamType<T>;
+    description?: string;
+    isOptional?: boolean;
+    isRestParam?: boolean;
+}
+export interface RequiredParam<T> extends BaseParam<T> {
+    isOptional?: false;
+    isRestParameter?: false;
+}
+export interface OptionalParam<T> extends BaseParam<T | undefined> {
+    isRestParameter?: false;
+}
+export interface RestParam<T> extends BaseParam<T> {
+    isOptional?: false;
+    isRestParameter: true;
+}
+type RequiredParams<T extends any[], U extends any[] = []> = Partial<T> extends T ? U : T extends [infer F, ...infer R] ? RequiredParams<R, [...U, F]> : U;
+type OptionalParams<T extends any[]> = T extends [
+    ...RequiredParams<T>,
+    ...infer R
+] ? [...R] : [];
+type HandleRequiredParams<P extends any[]> = P extends [infer H, ...infer T] ? [string | RequiredParam<H>, ...HandleRequiredParams<T>] : [];
+type HandleOptionalParams<P extends any[]> = P extends [infer H, ...infer T] ? [] | [string | OptionalParam<H | undefined>, ...HandleOptionalParams<T>] : P extends [] ? [] : P extends Array<infer T> ? [] | [RestParam<T[]>] : [];
+export type HandleParams<P extends any[]> = [
+    ...HandleRequiredParams<RequiredParams<P>>,
+    ...HandleOptionalParams<Required<OptionalParams<P>>>
+];
+export type HandleReturnType<T> = VoidType | ParamType<T>;
+export interface CustomFunctionMeta<F extends (...args: any[]) => any> {
+    /**
+     * The javascript name of the function. Notice it must be unique across all
+     * other functions and function namespaces. If two functions have the same
+     * name, they should be registered with different `meta.namespace`.
+     */
+    name: string;
+    /**
+     * A namespace for organizing groups of functions. It's also used to handle
+     * function name collisions. If a function has a namespace, it will be used
+     * whenever accessing the function.
+     */
+    namespace?: string;
+    /**
+     * Documentation for the registered function.
+     */
+    description?: string;
+    /**
+     * An array containing the list of parameters names the function takes.
+     * Optionally they can also be registered with the expected param types.
+     */
+    params?: HandleParams<Parameters<F>>;
+    /**
+     * Return value information.
+     */
+    returnValue?: {
+        /**
+         * The function return type.
+         */
+        type?: HandleReturnType<ReturnType<F>>;
+        /**
+         * The function return value description.
+         */
+        description?: string;
+    };
+    /**
+     * Typescript function declaration. If specified, it ignores the types
+     * provided by `params` and `returnValue`.
+     */
+    typescriptDeclaration?: string;
+    /**
+     * The path to be used when importing the function in the generated code.
+     * It can be the name of the package that contains the function, or the path
+     * to the file in the project (relative to the root directory).
+     */
+    importPath: string;
+    /**
+     * Whether the function is the default export from that path. Optional: if
+     * not specified, it's considered `false`.
+     */
+    isDefaultExport?: boolean;
+}
+export interface CustomFunctionRegistration {
+    function: (...args: any[]) => any;
+    meta: CustomFunctionMeta<any>;
+}
+declare global {
+    interface Window {
+        __PlasmicFunctionsRegistry: CustomFunctionRegistration[];
+    }
+}
+export default function unstable_registerFunction<F extends (...args: any[]) => any>(fn: F, meta: CustomFunctionMeta<F>): void;
+export {};

package/registerToken/dist/version.d.ts

@@ -1 +1 @@
-export declare const hostVersion = "1.0.166";
+export declare const hostVersion = "1.0.168";

package/registerTrait/dist/exports.d.ts

@@ -3,10 +3,11 @@ export * from "./data";
 export { PlasmicElement } from "./element-types";
 export { registerFetcher as unstable_registerFetcher } from "./fetcher";
 export * from "./global-actions";
-export { Action, ActionProps, CodeComponentMeta, ComponentHelpers, ComponentMeta, ComponentRegistration, ComponentTemplates, default as registerComponent, stateHelpersKeys, StateHelpers, StateSpec, CodeComponentMode, } from "./registerComponent";
-export { PropType, ContextDependentConfig } from "./prop-types";
+export * from "./link";
+export { ContextDependentConfig, PropType } from "./prop-types";
+export { Action, ActionProps, CodeComponentMeta, CodeComponentMode, ComponentHelpers, ComponentMeta, ComponentRegistration, ComponentTemplates, default as registerComponent, StateHelpers, stateHelpersKeys, StateSpec, } from "./registerComponent";
+export { CustomFunctionMeta, CustomFunctionRegistration, default as unstable_registerFunction, ParamType, } from "./registerFunction";
 export { default as registerGlobalContext, GlobalContextMeta, GlobalContextRegistration, PropType as GlobalContextPropType, } from "./registerGlobalContext";
 export { default as registerToken, TokenRegistration, TokenType, } from "./registerToken";
 export { BasicTrait, ChoiceTrait, default as registerTrait, TraitMeta, TraitRegistration, } from "./registerTrait";
 export { default as repeatedElement } from "./repeatedElement";
-export * from "./link";

package/registerTrait/dist/prop-types.d.ts

@@ -296,7 +296,7 @@ export interface EventHandlerType<P> extends PropTypeBase<P> {
     type: "eventHandler";
     argTypes: {
         name: string;
-        type: PropType<any>;
+        type: ArgType<any>;
     }[];
 }
 export interface ChoiceTypeBase<P, T> extends PropTypeBaseDefault<P, T> {
@@ -419,6 +419,7 @@ export interface RichCustomType<P> extends PropTypeBaseDefault<P, any> {
 export type CustomType<P> = RichCustomType<P> | CustomControl<P>;
 export type PrimitiveType<P = any> = Extract<StringType<P> | BooleanType<P> | NumberType<P> | JSONLikeType<P>, string>;
 export type PropType<P> = StringType<P> | BooleanType<P> | GraphQLType<P> | NumberType<P> | JSONLikeType<P> | DataSourceType<P> | DataPickerType<P> | ExprEditorType<P> | FormValidationRulesType<P> | EventHandlerType<P> | ChoiceType<P> | CustomType<P> | ImageUrlType<P> | SlotType<P> | DateStringType<P> | DateRangeStringsType<P>;
+export type ArgType<P> = Exclude<PropType<P>, SlotType<P> | EventHandlerType<P>>;
 export type StringCompatType<P> = DateStringType<P> | StringType<P> | ChoiceType<P> | JSONLikeType<P> | ImageUrlType<P> | CustomType<P> | DataPickerType<P>;
 export type BoolCompatType<P> = BooleanType<P> | CustomType<P> | DataPickerType<P>;
 export type NumberCompatType<P> = NumberType<P> | CustomType<P> | DataPickerType<P>;