@plasmicapp/host 1.0.136 → 1.0.138

package/registerToken/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/registerToken/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/registerToken/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/registerToken/dist/useForceUpdate.d.ts

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

package/registerToken/dist/version.d.ts

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

package/registerTrait/dist/canvas-host.d.ts

@@ -0,0 +1,41 @@
+import * as React from "react";
+declare global {
+    interface Window {
+        __PlasmicHostVersion: string;
+    }
+}
+export declare function setPlasmicRootNode(node: React.ReactElement | null): void;
+export interface PlasmicCanvasContextValue {
+    componentName: string | null;
+    globalVariants: Record<string, string>;
+    interactive?: boolean;
+}
+/**
+ * React context to detect whether the component is rendered on Plasmic editor.
+ * If not, return false.
+ * If so, return an object with more information about the component
+ */
+export declare const PlasmicCanvasContext: React.Context<false | PlasmicCanvasContextValue>;
+export declare const usePlasmicCanvasContext: () => false | PlasmicCanvasContextValue;
+interface PlasmicCanvasHostProps {
+    /**
+     * Webpack hmr uses EventSource to	listen to hot reloads, but that
+     * resultsin a persistent	connection from	each window.  In Plasmic
+     * Studio, if a project is configured to use app-hosting with a
+     * nextjs or gatsby server running in dev mode, each artboard will
+     * be holding a persistent connection to the dev server.
+     * Because browsers	have a limit to	how many connections can
+     * be held	at a time by domain, this means	after X	artboards, new
+     * artboards will freeze and not load.
+     *
+     * By default, <PlasmicCanvasHost /> will globally mutate
+     * window.EventSource to avoid using EventSource for HMR, which you
+     * typically don't need for your custom host page.  If you do still
+     * want to retain HRM, then youc an pass enableWebpackHmr={true}.
+     */
+    enableWebpackHmr?: boolean;
+}
+export declare const PlasmicCanvasHost: React.FunctionComponent<PlasmicCanvasHostProps>;
+type RenderErrorListener = (err: Error) => void;
+export declare function registerRenderErrorListener(listener: RenderErrorListener): () => void;
+export {};

package/registerTrait/dist/common.d.ts

@@ -0,0 +1 @@
+export declare const tuple: <T extends any[]>(...args: T) => T;

package/registerTrait/dist/data.d.ts

@@ -0,0 +1,43 @@
+import React, { ReactNode } from "react";
+export type DataDict = Record<string, any>;
+export declare const DataContext: React.Context<DataDict | undefined>;
+export type DataMeta = {
+    hidden?: boolean;
+    label?: string;
+};
+export declare function mkMetaName(name: string): string;
+export declare function mkMetaValue(meta: Partial<DataMeta>): DataMeta;
+export declare function applySelector(rawData: DataDict | undefined, selector: string | undefined): any;
+export type SelectorDict = Record<string, string | undefined>;
+export declare function useSelector(selector: string | undefined): any;
+export declare function useSelectors(selectors?: SelectorDict): any;
+export declare function useDataEnv(): DataDict | undefined;
+export interface DataProviderProps {
+    /**
+     * Key to set in data context.
+     */
+    name?: string;
+    /**
+     * Value to set for `name` in data context.
+     */
+    data?: any;
+    /**
+     * If true, hide this entry in studio (data binding).
+     */
+    hidden?: boolean;
+    /**
+     * Label to be shown in the studio data picker for easier navigation (data binding).
+     */
+    label?: string;
+    children?: ReactNode;
+}
+export declare function DataProvider({ name, data, hidden, label, children, }: DataProviderProps): JSX.Element;
+export interface PageParamsProviderProps {
+    params?: Record<string, string | string[] | undefined>;
+    query?: Record<string, string | string[] | undefined>;
+    children?: ReactNode;
+}
+export declare function PageParamsProvider({ children, params, query, }: PageParamsProviderProps): JSX.Element;
+export declare function DataCtxReader({ children, }: {
+    children: ($ctx: DataDict | undefined) => ReactNode;
+}): React.ReactElement<any, string | React.JSXElementConstructor<any>> | null;

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

@@ -0,0 +1,115 @@
+import type { Properties } from "csstype";
+export type CSSProperties = Properties<string | number> & {
+    layout?: "vbox" | "hbox" | "box" | "page-section";
+};
+type ContainerTags = "a" | "address" | "article" | "aside" | "blockquote" | "button" | "code" | "dd" | "div" | "dl" | "dt" | "form" | "footer" | "h1" | "h2" | "h3" | "h4" | "h5" | "h6" | "header" | "hgroup" | "label" | "li" | "main" | "nav" | "ol" | "p" | "pre" | "section" | "span" | "ul";
+type CommonAttrKeys = "title" | "tabIndex" | "className" | "id" | "aria-label" | "aria-hidden" | "aria-labelledby" | "aria-describedby" | "role";
+type PictureAttrKeys = "alt" | "loading" | CommonAttrKeys;
+type LinkAttrKeys = "href" | "target" | CommonAttrKeys;
+type TextAreaAttrKeys = "disabled" | "value" | "cols" | "rows" | "placeholder" | CommonAttrKeys;
+type InputAttrKeys = "disabled" | "value" | "defaultValue" | "name" | "autoComplete" | "checked" | "placeholder" | CommonAttrKeys;
+type ButtonAttrKeys = "disabled" | CommonAttrKeys;
+type Attrs<Keys extends string> = Partial<Record<Keys, string>>;
+export interface PictureElement {
+    type: "img";
+    src: string;
+    styles?: CSSProperties;
+    attrs?: Attrs<PictureAttrKeys>;
+}
+export type ImageElement = PictureElement;
+interface LinkTextElement {
+    type: "text";
+    tag: "a";
+    value: string;
+    styles?: CSSProperties;
+    attrs?: Attrs<LinkAttrKeys>;
+}
+interface ButtonTextElement {
+    type: "text";
+    tag: "button";
+    value: string;
+    styles?: CSSProperties;
+    attrs?: Attrs<ButtonAttrKeys>;
+}
+interface GenericTextElement {
+    type: "text";
+    /**
+     * Default: "div"
+     */
+    tag?: Exclude<ContainerTags, "a" | "button">;
+    value: string;
+    styles?: CSSProperties;
+    attrs?: Attrs<CommonAttrKeys>;
+}
+export type TextElement = string | LinkTextElement | ButtonTextElement | GenericTextElement;
+interface LinkContainerElement {
+    type: "box" | "vbox" | "hbox";
+    tag: "a";
+    children?: PlasmicElement | PlasmicElement[];
+    styles?: CSSProperties;
+    attrs?: Attrs<LinkAttrKeys>;
+}
+interface ButtonContainerElement {
+    type: "box" | "vbox" | "hbox";
+    tag: "button";
+    children?: PlasmicElement | PlasmicElement[];
+    styles?: CSSProperties;
+    attrs?: Attrs<ButtonAttrKeys>;
+}
+interface GenericContainerElement {
+    type: "box" | "vbox" | "hbox" | "page-section";
+    /**
+     * Default: "div"
+     */
+    tag?: Exclude<ContainerTags, "a" | "button">;
+    children?: PlasmicElement | PlasmicElement[];
+    styles?: CSSProperties;
+    attrs?: Attrs<CommonAttrKeys>;
+}
+export type ContainerElement = LinkContainerElement | ButtonContainerElement | GenericContainerElement;
+export interface ButtonElement {
+    type: "button";
+    value: string;
+    styles?: CSSProperties;
+    attrs?: Attrs<ButtonAttrKeys>;
+}
+interface InputElement {
+    type: "input" | "password";
+    styles?: CSSProperties;
+    attrs?: Attrs<InputAttrKeys>;
+}
+interface TextAreaElement {
+    type: "textarea";
+    styles?: CSSProperties;
+    attrs?: Attrs<TextAreaAttrKeys>;
+}
+export type TextInputElement = InputElement | TextAreaElement;
+interface JsonElement {
+    type: "json";
+    value: any;
+}
+export interface DefaultComponentElement<P> {
+    type: "default-component";
+    kind: "button" | "text-input";
+    props?: {
+        [prop in keyof Partial<P>]: number | string | boolean | null | undefined | JsonElement | PlasmicElement | PlasmicElement[];
+    } & {
+        [prop: string]: number | string | boolean | null | undefined | JsonElement | PlasmicElement | PlasmicElement[];
+    };
+    styles?: CSSProperties;
+}
+export interface CodeComponentElement<P> {
+    type: "component";
+    /**
+     * The registered component name
+     */
+    name: string;
+    styles?: CSSProperties;
+    props?: {
+        [prop in keyof Partial<P>]: number | string | boolean | null | undefined | JsonElement | PlasmicElement | PlasmicElement[];
+    } & {
+        [prop: string]: number | string | boolean | null | undefined | JsonElement | PlasmicElement | PlasmicElement[];
+    };
+}
+export type PlasmicElement = ImageElement | TextElement | ContainerElement | ButtonElement | TextInputElement | CodeComponentElement<{}> | DefaultComponentElement<{}>;
+export {};

package/registerTrait/dist/exports.d.ts

@@ -0,0 +1,11 @@
+export { PlasmicCanvasContext, PlasmicCanvasHost, usePlasmicCanvasContext, } from "./canvas-host";
+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, StateHelpers, StateSpec, CodeComponentMode, } from "./registerComponent";
+export { PropType, ContextDependentConfig } from "./prop-types";
+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";

package/registerTrait/dist/fetcher.d.ts

@@ -0,0 +1,40 @@
+import { PrimitiveType } from "./prop-types";
+export type Fetcher = (...args: any[]) => Promise<any>;
+export interface FetcherMeta {
+    /**
+     * Any unique identifying string for this fetcher.
+     */
+    name: string;
+    /**
+     * The Studio-user-friendly display name.
+     */
+    displayName?: string;
+    /**
+     * The symbol to import from the importPath.
+     */
+    importName?: string;
+    args: {
+        name: string;
+        type: PrimitiveType;
+    }[];
+    returns: PrimitiveType;
+    /**
+     * Either the path to the fetcher relative to `rootDir` or the npm
+     * package name
+     */
+    importPath: string;
+    /**
+     * Whether it's a default export or named export
+     */
+    isDefaultExport?: boolean;
+}
+export interface FetcherRegistration {
+    fetcher: Fetcher;
+    meta: FetcherMeta;
+}
+declare global {
+    interface Window {
+        __PlasmicFetcherRegistry: FetcherRegistration[];
+    }
+}
+export declare function registerFetcher(fetcher: Fetcher, meta: FetcherMeta): void;

package/registerTrait/dist/global-actions.d.ts

@@ -0,0 +1,9 @@
+import React from "react";
+export type GlobalActionDict = Record<string, Function>;
+export declare const GlobalActionsContext: React.Context<GlobalActionDict | undefined>;
+export declare function GlobalActionsProvider(props: {
+    contextName: string;
+    children?: React.ReactNode;
+    actions: GlobalActionDict;
+}): JSX.Element;
+export declare function useGlobalActions(): GlobalActionDict;

package/registerTrait/dist/index.d.ts

@@ -0,0 +1 @@
+export * from "./exports";

package/registerTrait/dist/lang-utils.d.ts

@@ -0,0 +1,3 @@
+type StringGen = string | (() => string);
+export declare function ensure<T>(x: T | null | undefined, msg?: StringGen): T;
+export {};