@plasmicapp/host 2.0.0-alpha.0 → 2.0.0-alpha.1

package/registerComponent/dist/types/choice-type.d.ts

@@ -0,0 +1,16 @@
+import { MaybeContextDependentConfig } from "./shared-controls";
+export type ChoiceValue = string | number | boolean;
+export type ChoiceObject<T = ChoiceValue> = {
+    label: string;
+    value: T;
+};
+export type ChoiceOption<T extends ChoiceValue = ChoiceValue> = T | ChoiceObject<T>;
+export type ChoiceOptions<T extends ChoiceValue = ChoiceValue> = T[] | ChoiceObject<T>[];
+export interface ChoiceCore<Ctx extends any[], T extends ChoiceValue> {
+    type: "choice";
+    options: MaybeContextDependentConfig<Ctx, ChoiceOptions<T>>;
+    multiSelect?: MaybeContextDependentConfig<Ctx, boolean>;
+    allowSearch?: boolean;
+    filterOption?: boolean;
+    onSearch?: MaybeContextDependentConfig<Ctx, ((v: string) => void) | undefined>;
+}

package/registerComponent/dist/types/component-types.d.ts

@@ -0,0 +1,251 @@
+/// <reference types="react" />
+import { CSSProperties, PlasmicElement } from "../element-types";
+import { ChoiceCore, ChoiceValue } from "./choice-type";
+import { ArrayTypeBaseCore, ObjectTypeBaseCore } from "./container-types";
+import { DataPickerValueType, DataSourceCore, DynamicCore, GraphQLCore, GraphQLValue, RichDataPickerCore, RichExprEditorCore } from "./misc-types";
+import { CardPickerCore, ClassCore, CodeStringCore, ColorCore, DateRangeStringsCore, DateStringCore, HrefCore, NumberTypeBaseCore, PlainNumberCore, PlainStringCore, RichBooleanCore, RichTextCore, SliderNumberCore, ThemeResetClassCore } from "./primitive-types";
+import { CommonTypeBase, ContextDependentConfig, ControlExtras, Defaultable, GenericContext, InferDataType } from "./shared-controls";
+export type ComponentControlContext<P> = GenericContext<P, // Full component props
+// Full component props
+InferDataType<P> | null, // Canvas data
+ControlExtras>;
+export type ComponentContextConfig<Props, R> = ContextDependentConfig<ComponentControlContext<Props>, R>;
+export interface PropTypeBase<Ctx extends any[]> extends CommonTypeBase {
+    displayName?: string;
+    required?: boolean;
+    readOnly?: boolean | ContextDependentConfig<Ctx, boolean>;
+    /**
+     * If set to true, the component will be remounted when the prop value is updated.
+     * (This behavior only applies to canvas)
+     */
+    forceRemount?: boolean;
+    /**
+     * If true, the prop can't be overriden in different variants.
+     */
+    invariantable?: boolean;
+    /**
+     * Function for whether this prop should be hidden in the right panel,
+     * given the current props for this component
+     */
+    hidden?: ContextDependentConfig<Ctx, boolean>;
+}
+interface ExtendedDefaultable<Ctx extends any[], T> extends Defaultable<Ctx, T> {
+    /**
+     * Use a dynamic value expression as the default instead
+     */
+    defaultExpr?: string;
+    defaultExprHint?: string;
+    /**
+     * This function validates whether the prop value is valid.
+     * If the value is invalid, it returns an error message. Otherwise, it returns true.
+     */
+    validator?: (value: T, ...args: Ctx) => (string | true) | Promise<string | true>;
+}
+export interface Controllable {
+    /**
+     * If true, this is a prop that should only be used inside Plasmic
+     * Studio for rendering artboards; will not be actually used in
+     * generated code.
+     */
+    editOnly?: boolean;
+    /**
+     * If specified, the value used for this prop will instead be
+     * mapped to the uncontrolledProp when generating code. This is
+     * useful if, for example, in the artboard, you want to use `value`
+     * prop to control the component, but in generated code, you want to
+     * map it to `defaultValue`.
+     */
+    uncontrolledProp?: string;
+}
+export type PropTypeBaseDefault<P, T> = PropTypeBase<ComponentControlContext<P>> & ExtendedDefaultable<ComponentControlContext<P>, T> & Controllable;
+export type PlainStringType<P> = PropTypeBaseDefault<P, string> & PlainStringCore;
+export type CodeStringType<P> = PropTypeBaseDefault<P, string> & CodeStringCore;
+export type RichTextType<P> = PropTypeBaseDefault<P, string> & RichTextCore;
+export type HrefType<P> = PropTypeBaseDefault<P, string> & HrefCore;
+export type ColorType<P> = PropTypeBaseDefault<P, string> & ColorCore;
+export type DateStringType<P> = PropTypeBaseDefault<P, string> & DateStringCore;
+export type DateRangeStringsType<P> = PropTypeBaseDefault<P, [string, string]> & DateRangeStringsCore;
+export type ClassType<P> = PropTypeBase<ComponentControlContext<P>> & ClassCore;
+export type ThemeResetClassType<P> = PropTypeBase<ComponentControlContext<P>> & ThemeResetClassCore;
+export type CardPickerType<P> = PropTypeBaseDefault<P, string> & CardPickerCore<ComponentControlContext<P>>;
+export type RichStringType<P> = PlainStringType<P> | CodeStringType<P> | RichTextType<P> | ColorType<P> | ClassType<P> | ThemeResetClassType<P> | CardPickerType<P> | HrefType<P>;
+export type StringType<P> = "string" | "href" | RichStringType<P>;
+export type RichBooleanType<P> = PropTypeBaseDefault<P, boolean> & RichBooleanCore;
+export type BooleanType<P> = "boolean" | RichBooleanType<P>;
+export type GraphQLType<P> = PropTypeBaseDefault<P, GraphQLValue> & GraphQLCore<ComponentControlContext<P>>;
+export type NumberTypeBase<P> = PropTypeBaseDefault<P, number> & NumberTypeBaseCore<ComponentControlContext<P>>;
+export type PlainNumberType<P> = NumberTypeBase<P> & PlainNumberCore<ComponentControlContext<P>>;
+export type SliderNumberType<P> = NumberTypeBase<P> & SliderNumberCore<ComponentControlContext<P>>;
+export type RichNumberType<P> = PlainNumberType<P> | SliderNumberType<P>;
+export type NumberType<P> = "number" | RichNumberType<P>;
+export type ObjectType<P> = PropTypeBaseDefault<P, Record<string, any>> & ObjectTypeBaseCore<ComponentControlContext<P>, PropType<P>>;
+export type ArrayType<P> = PropTypeBaseDefault<P, any[]> & ArrayTypeBaseCore<ComponentControlContext<P>, PropType<P>>;
+export type JSONLikeType<P> = "object" | ObjectType<P> | ArrayType<P>;
+export type DataSourceType<P> = PropTypeBase<ComponentControlContext<P>> & DataSourceCore;
+export type RichDataPickerType<P> = PropTypeBaseDefault<P, DataPickerValueType> & RichDataPickerCore<ComponentControlContext<P>>;
+export type DataPickerType<P> = "dataPicker" | RichDataPickerType<P>;
+export type RichExprEditorType<P> = PropTypeBaseDefault<P, DataPickerValueType> & RichExprEditorCore<ComponentControlContext<P>>;
+export type ExprEditorType<P> = "exprEditor" | RichExprEditorType<P>;
+export type ComponentChoiceType<P, Opt extends ChoiceValue = ChoiceValue, Val = Opt | Opt[]> = PropTypeBaseDefault<P, Val> & ChoiceCore<ComponentControlContext<P>, Opt>;
+export interface SingleChoiceType<P, Opt extends ChoiceValue = ChoiceValue> extends ComponentChoiceType<P, Opt, Opt> {
+    multiSelect?: false;
+}
+export interface MultiChoiceType<P, Opt extends ChoiceValue = ChoiceValue> extends ComponentChoiceType<P, Opt, Opt[]> {
+    multiSelect: true;
+}
+export interface CustomChoiceType<P> extends ComponentChoiceType<P, ChoiceValue, ChoiceValue | ChoiceValue[]> {
+    multiSelect: ComponentContextConfig<P, boolean>;
+}
+export type ChoiceType<P> = SingleChoiceType<P> | MultiChoiceType<P> | CustomChoiceType<P>;
+export interface FormValidationRulesType<P> extends PropTypeBaseDefault<P, any> {
+    type: "formValidationRules";
+}
+export interface EventHandlerType<P> extends PropTypeBase<ComponentControlContext<P>> {
+    type: "eventHandler";
+    argTypes: {
+        name: string;
+        type: ArgType<any>;
+    }[];
+}
+export interface RichSlotType<P> {
+    type: "slot";
+    description?: string;
+    /**
+     * The unique names of all code components that can be placed in the slot
+     */
+    allowedComponents?: string[];
+    /**
+     * Wheter Plasmic Components with a root component included in the
+     * "allowedComponents" list are valid or not.
+     * Only used if the "allowedComponents" list is set.
+     */
+    allowRootWrapper?: boolean;
+    /**
+     * Whether the "empty slot" placeholder should be hidden in the canvas.
+     */
+    hidePlaceholder?: boolean;
+    /**
+     * Whether the slot is repeated, i.e., is rendered multiple times using
+     * repeatedElement().
+     */
+    isRepeated?: boolean;
+    /**
+     * A nicer, human-readable display name for your slot prop
+     */
+    displayName?: string;
+    /**
+     * Function for whether this slot should be hidden from the left tree,
+     * given the current props for this component
+     */
+    hidden?: ComponentContextConfig<P, boolean>;
+    /**
+     * If slot is a render prop (accepts a function that takes in some
+     * arguments and returns some JSX), then specify the names of the
+     * arguments expected by the render prop function.
+     */
+    renderPropParams?: string[];
+    /**
+     * When inserting top-level "page sections", should this slot be the default target?
+     */
+    unstable__isMainContentSlot?: boolean;
+    defaultValue?: PlasmicElement | PlasmicElement[];
+    /**
+     * When true, when you click for the first time in this slot and the component was not selected, the component itself
+     * is selected, making it easier to select the component instead of slot contents. So for
+     * instance, setting this on a Button slot ensures that clicking on the Button’s text will still select the Button and not
+     * the text element in its slot. Clicking again will deep-select the slot content. Similar in this regard to trapsFocus on components.
+     *
+     * Furthermore, the component further shows the props of whatever is in the slot on
+     *  the parent component for the user's convenience. Handy for various “wrapper" components, form fields, and so on.
+     */
+    mergeWithParent?: boolean | ComponentContextConfig<P, boolean>;
+    /**
+     * A function that returns true to hide the merged props conditionally.
+     */
+    hiddenMergedProps?: ComponentContextConfig<P, boolean>;
+}
+export type SlotType<P> = "slot" | RichSlotType<P>;
+export interface RichImageUrlType<P> extends PropTypeBaseDefault<P, string> {
+    type: "imageUrl";
+}
+export type ImageUrlType<P> = "imageUrl" | RichImageUrlType<P>;
+export interface ModalProps {
+    show?: boolean;
+    children?: React.ReactNode;
+    onClose: () => void;
+    style?: CSSProperties;
+}
+export interface StudioOps {
+    showModal: (modalProps: Omit<ModalProps, "onClose"> & {
+        onClose?: () => void;
+    }) => void;
+    refreshQueryData: () => void;
+    appendToSlot: (element: PlasmicElement, slotName: string) => void;
+    removeFromSlotAt: (pos: number, slotName: string) => void;
+    updateProps: (newValues: any) => void;
+    updateStates: (newValues: any) => void;
+}
+export interface ProjectData {
+    components: {
+        name: string;
+    }[];
+    pages: {
+        name: string;
+        pageMeta: {
+            path: string;
+        };
+    }[];
+}
+export interface CustomControlProps<P> {
+    componentProps: P;
+    /**
+     * `contextData` can be `null` if the prop controls are rendering before
+     * the component instance itself (it will re-render once the component
+     * calls `setControlContextData`)
+     */
+    contextData: InferDataType<P> | null;
+    /**
+     * Operations available to the editor that allow modifying the entire component.
+     * Can be null if the custom prop is used in a global context.
+     */
+    studioOps: StudioOps | null;
+    /**
+     * Metadata from the studio project.
+     */
+    projectData: ProjectData;
+    value: any;
+    /**
+     * Sets the value to be passed to the prop. Expects a JSON-compatible value.
+     */
+    updateValue: (newVal: any) => void;
+    /**
+     * Full screen modal component
+     */
+    FullscreenModal: React.ComponentType<ModalProps>;
+    /**
+     * Modal component for the side pane
+     */
+    SideModal: React.ComponentType<ModalProps>;
+    /**
+     * The document that the component will be rendered into; instead of using
+     * `document` directly (for, say, `document.querySelector()` etc.), you
+     * should use this instead.
+     */
+    studioDocument: typeof document;
+}
+export type CustomControl<P> = React.ComponentType<CustomControlProps<P>>;
+export interface RichCustomType<P> extends PropTypeBaseDefault<P, any> {
+    type: "custom";
+    control: CustomControl<P>;
+}
+export type CustomType<P> = RichCustomType<P> | CustomControl<P>;
+export interface DynamicType<P> extends PropTypeBase<ComponentControlContext<P>>, DynamicCore<ComponentControlContext<P>, PropType<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> | DynamicType<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>;
+export type RestrictPropType<T, P> = T extends string ? StringCompatType<P> : T extends boolean ? BoolCompatType<P> : T extends number ? NumberCompatType<P> : PropType<P>;
+export {};

package/registerComponent/dist/types/container-types.d.ts

@@ -0,0 +1,42 @@
+import { ContextDependentConfig } from "./shared-controls";
+export interface ObjectTypeBaseCore<Ctx extends any[], Values, Keys extends string = string> {
+    type: "object";
+    fields?: Record<Keys, Values>;
+    nameFunc?: (item: any, ...args: Ctx) => string | undefined;
+    /**
+     * Controls how the object editor is displayed in the UI. If not specified, Plasmic will choose the appropriate display mode.
+     * - "popup":  Displays the object in a popup
+     * - "inline": Displays the object fields inline
+     * - "flatten": Displays the object fields inline at the parent level. The parent label is not displayed.
+     */
+    display?: "inline" | "popup" | "flatten";
+}
+export interface ArrayTypeBaseCore<Ctx extends any[], Fields> {
+    type: "array";
+    itemType?: ObjectTypeBaseCore<Ctx, Fields>;
+    /**
+     * Optional function that determines whether the user can delete a given item.
+     */
+    unstable__canDelete?: (item: any, ...args: Ctx) => boolean;
+    /**
+     * Specify how to let Plasmic know how to update its own internal representation of the data when the value has
+     * changed, or when issuing a minimalValue or shownValue that is different.
+     *
+     * Important to specify this if you are expecting any nested expression values in this data type!
+     */
+    unstable__keyFunc?: (item: any) => any;
+    /**
+     * Specify what would be the tentative new value that is set if the user makes any changes.
+     *
+     * Useful for field mappings.
+     *
+     * For instance, consider a Table where we have a `fields` prop:
+     *
+     * - Initially, the value is undefined. But if the user makes any changes, we would want to save an array of at
+     *   least three items (corresponding to, say, three columns inferred from a schema).
+     *
+     * - Let's say there are 5 columns in the value. The data schema changes, removing a column and adding two new
+     *   ones. Now we would want a different minimal value, containing 6 items.
+     */
+    unstable__minimalValue?: ContextDependentConfig<Ctx, any>;
+}

package/registerComponent/dist/types/function-types.d.ts

@@ -0,0 +1,101 @@
+import { ChoiceCore, ChoiceValue } from "./choice-type";
+import { ArrayTypeBaseCore, ObjectTypeBaseCore } from "./container-types";
+import { DynamicCore, GraphQLCore, GraphQLValue } from "./misc-types";
+import { DateRangeStringsCore, DateStringCore, NumberTypeBaseCore, RichBooleanCore } from "./primitive-types";
+import { QueryBuilderCore } from "./query-builder-types";
+import { CommonTypeBase, ContextDependentConfig, Defaultable, GenericContext } from "./shared-controls";
+import { Nullish } from "./type-utils";
+export type FunctionControlContext<P> = GenericContext<Partial<P>, // Partial function props
+any>;
+export type FunctionContextConfig<Args extends any[], R> = ContextDependentConfig<FunctionControlContext<Args>, R>;
+export type TypeBaseDefault<Ctx extends any[], T> = CommonTypeBase & Defaultable<Ctx, T>;
+export interface PlainStringType<T extends Nullish<string> = string> extends TypeBaseDefault<any[], T> {
+    type: "string" | `'${T}'`;
+}
+export type StringType<P, T extends string = string> = "string" | PlainStringType<T> | ChoiceType<P, T> | DateStringType | DateRangeStringsType | AnyType;
+export interface PlainNumberType<T extends Nullish<number> = number> extends TypeBaseDefault<any[], T> {
+    type: "number" | `${number extends T ? number : T}`;
+}
+export type NumberType<P, T extends number = number> = PlainNumberType<T> | (TypeBaseDefault<FunctionControlContext<P>, T> & NumberTypeBaseCore<FunctionControlContext<P>>) | ChoiceType<P, T> | AnyType;
+export interface PlainBooleanType<T extends Nullish<boolean> = boolean> extends TypeBaseDefault<any[], T> {
+    type: "boolean" | `${boolean extends T ? boolean : T}`;
+}
+export type BooleanType<P, T extends boolean = boolean> = PlainBooleanType<T> | (TypeBaseDefault<FunctionControlContext<P>, T> & RichBooleanCore) | ChoiceType<P, T> | AnyType;
+export type GraphQLType<P> = TypeBaseDefault<FunctionControlContext<P>, any> & GraphQLCore<FunctionControlContext<P>>;
+export interface PlainNullType extends TypeBaseDefault<any[], null> {
+    type: "null";
+}
+export type NullType = PlainNullType | AnyType;
+export interface PlainUndefinedType extends TypeBaseDefault<any[], undefined> {
+    type: "undefined";
+}
+export type UndefinedType = PlainUndefinedType | AnyType;
+export type ExtractObjectKeys<T extends object> = keyof T & string;
+export type ObjectType<P, T extends object> = TypeBaseDefault<FunctionControlContext<P>, T> & ObjectTypeBaseCore<FunctionControlContext<P>, GenericType<P, any>, ExtractObjectKeys<T>>;
+export type ArrayType<P> = TypeBaseDefault<FunctionControlContext<P>, any[]> & ArrayTypeBaseCore<FunctionControlContext<P>, GenericType<P, any>>;
+export type QueryBuilderType<P> = TypeBaseDefault<FunctionControlContext<P>, any> & QueryBuilderCore<FunctionControlContext<P>>;
+export interface PlainAnyType extends TypeBaseDefault<FunctionControlContext<any>, any> {
+    type: "any";
+}
+export type AnyType = PlainAnyType;
+export interface PlainVoidType extends CommonTypeBase {
+    type: "void";
+}
+export type VoidType = PlainVoidType | AnyType;
+type IsAny<T> = 0 extends 1 & T ? true : false;
+type CommonType<P, T> = T extends GraphQLValue ? GraphQLType<P> : T extends null ? NullType : T extends undefined ? UndefinedType : T extends Array<any> ? ArrayType<P> : T extends object ? ObjectType<P, T> : AnyType;
+type AnyTyping<P, T> = T extends string ? StringType<P, T> : T extends number ? NumberType<P, T> : T extends boolean ? BooleanType<P, T> : CommonType<P, T>;
+export type ToTuple<T> = T extends any[] ? T : never;
+export type ChoiceTypeBase<Args, Opt extends ChoiceValue = ChoiceValue> = TypeBaseDefault<FunctionControlContext<ToTuple<Args>>, Opt | Opt[]> & ChoiceCore<FunctionControlContext<ToTuple<Args>>, Opt>;
+export interface SingleChoiceType<P, Opt extends ChoiceValue = ChoiceValue> extends ChoiceTypeBase<P, Opt> {
+    multiSelect?: false;
+}
+export interface MultiChoiceType<P, Opt extends ChoiceValue = ChoiceValue> extends ChoiceTypeBase<P, Opt> {
+    multiSelect: true;
+}
+export interface CustomChoiceType<P, Opt extends ChoiceValue = ChoiceValue> extends ChoiceTypeBase<P, Opt> {
+    multiSelect: FunctionContextConfig<ToTuple<P>, boolean>;
+}
+export type ChoiceType<P, T extends ChoiceValue = ChoiceValue> = SingleChoiceType<P, T> | MultiChoiceType<P, T> | CustomChoiceType<P, T>;
+export type DateStringType = TypeBaseDefault<FunctionControlContext<string>, string> & DateStringCore;
+export type DateRangeStringsType = TypeBaseDefault<FunctionControlContext<[string, string]>, [
+    string,
+    string
+]> & DateRangeStringsCore;
+export interface DynamicType<P> extends CommonTypeBase, DynamicCore<FunctionControlContext<ToTuple<P>>, GenericType<P, any>> {
+}
+export type RestrictedType<P, T> = IsAny<T> extends true ? AnyTyping<P, T> : [
+    T
+] extends [string] ? StringType<P, T> : [T] extends [number] ? NumberType<P, T> : [T] extends [boolean] ? BooleanType<P, T> : T extends string | null | undefined ? Exclude<T, null | undefined> extends string ? StringType<P, T extends string ? T : string> : CommonType<P, T> : T extends number | null | undefined ? Exclude<T, null | undefined> extends number ? NumberType<P, T extends number ? T : number> : CommonType<P, T> : T extends boolean | null | undefined ? Exclude<T, null | undefined> extends boolean ? BooleanType<P, T extends boolean ? T : boolean> : CommonType<P, T> : CommonType<P, T>;
+export type GenericType<P, T> = RestrictedType<P, T> | DynamicType<P> | QueryBuilderType<P>;
+export interface ParamTypeBase {
+    name: string;
+}
+export type ParamType<P, T> = ParamTypeBase & GenericType<P, T>;
+export type RequiredParam<P, T> = ParamTypeBase & ParamType<P, T> & {
+    isOptional?: false;
+    isRestParameter?: false;
+};
+export type OptionalParam<P, T> = ParamTypeBase & ParamType<P, T> & {
+    isRestParameter?: false;
+};
+export type RestParam<P, T> = ParamTypeBase & ParamType<P, 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, R extends any[]> = R extends [infer H, ...infer T] ? [string | RequiredParam<P, H>, ...HandleRequiredParams<P, T>] : [];
+type HandleOptionalParams<P, R extends any[]> = R extends [infer H, ...infer T] ? [] | [
+    string | OptionalParam<P, H | undefined>,
+    ...HandleOptionalParams<P, T>
+] : R extends [] ? [] : R extends Array<infer T> ? [] | [RestParam<P, T[]>] : [];
+export type HandleParams<P extends any[]> = [
+    ...HandleRequiredParams<P, RequiredParams<P>>,
+    ...HandleOptionalParams<P, Required<OptionalParams<P>>>
+];
+export type HandleReturnType<P, T> = VoidType | ParamType<P, T>;
+export {};

package/registerComponent/dist/types/misc-types.d.ts

@@ -0,0 +1,38 @@
+import { ContextDependentConfig } from "./shared-controls";
+export interface RichExprEditorCore<Ctx extends any[]> {
+    type: "exprEditor";
+    data?: Record<string, any> | ContextDependentConfig<Ctx, Record<string, any>>;
+    isolateEnv?: boolean;
+}
+export interface DataSourceCore {
+    type: "dataSource";
+    dataSource: "airtable" | "cms";
+}
+export type DataPickerValueType = string | number | (string | number)[];
+export interface RichDataPickerCore<Ctx extends any[]> {
+    type: "dataSelector";
+    data?: Record<string, any> | ContextDependentConfig<Ctx, Record<string, any>>;
+    alwaysShowValuePathAsLabel?: boolean;
+    isolateEnv?: boolean;
+}
+export type GraphQLValue = {
+    query: string;
+    variables?: Record<string, any>;
+};
+export interface GraphQLCore<Ctx extends any[]> {
+    type: "code";
+    lang: "graphql";
+    endpoint: string | ContextDependentConfig<Ctx, string>;
+    method?: string | ContextDependentConfig<Ctx, string>;
+    headers?: object | ContextDependentConfig<Ctx, object>;
+}
+/**
+ * Dynamic prop/param type that returns different control types based on context
+ */
+export interface DynamicCore<Ctx extends any[], ControlType> {
+    type: "dynamic";
+    /**
+     * Function that takes the context and returns a control type
+     */
+    control: ContextDependentConfig<Ctx, ControlType>;
+}

package/registerComponent/dist/types/primitive-types.d.ts

@@ -0,0 +1,123 @@
+/// <reference types="react" />
+import { CSSProperties } from "../element-types";
+import { StyleSection } from "../registerComponent";
+import { ContextDependentConfig } from "./shared-controls";
+export interface RichBooleanCore {
+    type: "boolean";
+}
+export interface NumberTypeBaseCore<Ctx extends any[]> {
+    type: "number";
+    min?: number | ContextDependentConfig<Ctx, number>;
+    max?: number | ContextDependentConfig<Ctx, number>;
+}
+export interface PlainNumberCore<Ctx extends any[]> extends NumberTypeBaseCore<Ctx> {
+    control?: "default";
+}
+export interface SliderNumberCore<Ctx extends any[]> extends NumberTypeBaseCore<Ctx> {
+    control: "slider";
+    step?: number | ContextDependentConfig<Ctx, number>;
+}
+export interface PlainStringCore {
+    type: "string";
+    control?: "default" | "large" | "multiLine";
+    isLocalizable?: boolean;
+}
+export interface CodeStringCore {
+    type: "code";
+    lang: "css" | "html" | "javascript" | "json";
+}
+export interface RichTextCore {
+    type: "richText";
+}
+export interface HrefCore {
+    type: "href";
+}
+export interface ColorCore {
+    type: "color";
+    /**
+     * If specified, and the user picks a color token in the Studio, then
+     * the value passed in as prop is a css variable reference, like
+     * `var(--TOKEN_ID)`, instead of the resolved hex value of the token.
+     * You should take care in using this in the proper css context --
+     * the css token is only defined if you are rendering under some
+     * Plasmic component in the DOM tree, which is usually the case,
+     * unless you are using a React portal.
+     */
+    keepCssVar?: boolean;
+    /**
+     * Prevent tokens from being selected.
+     */
+    disableTokens?: boolean;
+}
+export interface DateStringCore {
+    type: "dateString";
+}
+export interface DateRangeStringsCore {
+    type: "dateRangeStrings";
+}
+export interface ClassCore {
+    type: "class";
+    /**
+     * Additional css selectors that can change how this style should look.
+     * Some examples:
+     *
+     * * `:hover` -- on hover
+     * * `[data-something="blah"] -- when the element with this class has
+     *   an html attribute "data-something=blah"
+     * * :component[data-something="blah"] :self -- when the root of the
+     *   component has an html attribute "data-something=blah". Note that
+     *   the non-standard `:component` selector is used to select the
+     *   component root, and the non-standard `:self` selector is used
+     *   to select the element that this class is attached to.
+     */
+    selectors?: {
+        /**
+         * A css selector, like `:hover` or `[data-something="blah"]`.
+         */
+        selector: string;
+        /**
+         * An optional human-friendly label for the selector, so the studio user
+         * knows what this selector means.
+         */
+        label?: string;
+        /**
+         * Initial styles to be applied for this selector
+         */
+        defaultStyles?: CSSProperties;
+    }[];
+    /**
+     * If specified, then only shows these style sections for styling this class
+     */
+    styleSections?: StyleSection[];
+    /**
+     * Initial styles to be applied for this class
+     */
+    defaultStyles?: CSSProperties;
+}
+export interface ThemeResetClassCore {
+    type: "themeResetClass";
+    /**
+     * Normally, theme reset class will only target Plasmic-generated tags
+     * with the default tag styles. If you also want to target non-Plasmic-generated
+     * tags (say, rendered by your code components, or fetched as an HTML blob
+     * from somewhere), then specify `true` here.
+     */
+    targetAllTags?: boolean;
+}
+export interface CardPickerCore<Ctx extends any[]> {
+    type: "cardPicker";
+    modalTitle?: React.ReactNode | ContextDependentConfig<Ctx, React.ReactNode>;
+    options: {
+        value: string;
+        label?: string;
+        imgUrl: string;
+        footer?: React.ReactNode;
+    }[] | ContextDependentConfig<Ctx, {
+        value: string;
+        label?: string;
+        imgUrl: string;
+        footer?: React.ReactNode;
+    }[]>;
+    showInput?: boolean | ContextDependentConfig<Ctx, boolean>;
+    onSearch?: ContextDependentConfig<Ctx, ((value: string) => void) | undefined>;
+}

package/registerComponent/dist/types/query-builder-types.d.ts

@@ -0,0 +1,51 @@
+import { ContextDependentConfig } from "./shared-controls";
+/**
+ * Control type for building a custom query format.
+ *
+ * This control is based on react-awesome-query-builder
+ * and returns data in JsonLogic format.
+ *
+ * If using this control type, it's recommended to install
+ * @react-awesome-query-builder/core and json-logic-js as devDependencies
+ * so that you can reference their types.
+ *
+ * References:
+ * - https://github.com/ukrbublik/react-awesome-query-builder
+ * - https://github.com/jwadhams/json-logic-js
+ * - https://jsonlogic.com/
+ */
+export interface QueryBuilderCore<Ctx extends any[]> {
+    type: "queryBuilder";
+    /**
+     * Return a @react-awesome-query-builder/core `Config` that will be merged
+     * with Plasmic's built-in config.
+     *
+     * https://github.com/plasmicapp/plasmic/blob/master/platform/wab/src/wab/client/components/QueryBuilder/QueryBuilderConfig.tsx
+     *
+     * At a minimum, this should return fields and their types.
+     * For configuration options, see react-awesome-query-builder docs.
+     */
+    config: ContextDependentConfig<Ctx, SimplifiedConfig>;
+}
+/**
+ * A simplified subset of @react-awesome-query-builder/core `Config`.
+ */
+interface SimplifiedConfig {
+    fields: SimplifiedFields;
+}
+/**
+ * A simplified subset of @react-awesome-query-builder/core `Fields`.
+ */
+interface SimplifiedFields {
+    [key: string]: SimplifiedField;
+}
+/**
+ * A simplified subset of @react-awesome-query-builder/core `FieldOrGroup`.
+ */
+interface SimplifiedField {
+    type: "text" | "number" | "boolean" | "date" | "time" | "datetime" | "select" | "multiselect" | "treeselect" | "treemultiselect" | string;
+    label?: string;
+    defaultValue?: unknown;
+    fieldSettings?: {};
+}
+export {};