@plasmicapp/react-web 0.2.201 → 0.2.202

package/dist/plume/menu/menu-item.d.ts

@@ -1,23 +1,23 @@
-import { ItemLikeProps } from "../collection-utils";
-import { AnyPlasmicClass, PlasmicClassArgs, PlasmicClassOverrides, PlasmicClassVariants, VariantDef } from "../plume-utils";
-export interface BaseMenuItemProps extends ItemLikeProps {
-    /**
-     * Called when this item is selected
-     */
-    onAction?: (key: string) => void;
-}
-interface MenuItemConfig<C extends AnyPlasmicClass> {
-    isDisabledVariant?: VariantDef<PlasmicClassVariants<C>>;
-    isHighlightedVariant?: VariantDef<PlasmicClassVariants<C>>;
-    labelSlot: keyof PlasmicClassArgs<C>;
-    root: keyof PlasmicClassOverrides<C>;
-    labelContainer: keyof PlasmicClassOverrides<C>;
-}
-export declare function useMenuItem<P extends BaseMenuItemProps, C extends AnyPlasmicClass>(plasmicClass: C, props: P, config: MenuItemConfig<C>): {
-    plasmicProps: {
-        variants: PlasmicClassVariants<C>;
-        args: PlasmicClassArgs<C>;
-        overrides: PlasmicClassOverrides<C>;
-    };
-};
-export {};
+import { ItemLikeProps } from "../collection-utils";
+import { AnyPlasmicClass, PlasmicClassArgs, PlasmicClassOverrides, PlasmicClassVariants, VariantDef } from "../plume-utils";
+export interface BaseMenuItemProps extends ItemLikeProps {
+    /**
+     * Called when this item is selected
+     */
+    onAction?: (key: string) => void;
+}
+interface MenuItemConfig<C extends AnyPlasmicClass> {
+    isDisabledVariant?: VariantDef<PlasmicClassVariants<C>>;
+    isHighlightedVariant?: VariantDef<PlasmicClassVariants<C>>;
+    labelSlot: keyof PlasmicClassArgs<C>;
+    root: keyof PlasmicClassOverrides<C>;
+    labelContainer: keyof PlasmicClassOverrides<C>;
+}
+export declare function useMenuItem<P extends BaseMenuItemProps, C extends AnyPlasmicClass>(plasmicClass: C, props: P, config: MenuItemConfig<C>): {
+    plasmicProps: {
+        variants: PlasmicClassVariants<C>;
+        args: PlasmicClassArgs<C>;
+        overrides: PlasmicClassOverrides<C>;
+    };
+};
+export {};

package/dist/plume/menu/menu.d.ts

@@ -1,39 +1,39 @@
-import { AriaLabelingProps, DOMProps } from "@react-types/shared";
-import * as React from "react";
-import { AnyPlasmicClass, PlasmicClassArgs, PlasmicClassOverrides, PlasmicClassVariants, VariantDef } from "../plume-utils";
-import { StyleProps } from "../props-utils";
-export interface BaseMenuProps extends DOMProps, AriaLabelingProps, StyleProps {
-    /**
-     * List of `Menu.Item`s or `Menu.Group`s that make up the menu
-     */
-    children?: React.ReactNode;
-    /**
-     * Called with the value of a `Menu.Item` when it is selected.
-     */
-    onAction?: (value: string) => void;
-}
-export type MenuRef = React.Ref<MenuRefValue>;
-export interface MenuRefValue extends MenuState {
-    getRoot: () => HTMLElement | null;
-}
-export interface MenuConfig<C extends AnyPlasmicClass> {
-    isPlacedTopVariant?: VariantDef<PlasmicClassVariants<C>>;
-    isPlacedBottomVariant?: VariantDef<PlasmicClassVariants<C>>;
-    isPlacedLeftVariant?: VariantDef<PlasmicClassVariants<C>>;
-    isPlacedRightVariant?: VariantDef<PlasmicClassVariants<C>>;
-    itemsSlot: keyof PlasmicClassArgs<C>;
-    itemsContainer: keyof PlasmicClassOverrides<C>;
-    root: keyof PlasmicClassOverrides<C>;
-}
-export interface MenuState {
-    getFocusedValue: () => string | null;
-    setFocusedValue: (value: string) => void;
-}
-export declare function useMenu<P extends BaseMenuProps, C extends AnyPlasmicClass>(plasmicClass: C, props: P, config: MenuConfig<C>, ref?: MenuRef): {
-    plasmicProps: {
-        variants: PlasmicClassVariants<C>;
-        args: PlasmicClassArgs<C>;
-        overrides: PlasmicClassOverrides<C>;
-    };
-    state: MenuState;
-};
+import { AriaLabelingProps, DOMProps } from "@react-types/shared";
+import * as React from "react";
+import { AnyPlasmicClass, PlasmicClassArgs, PlasmicClassOverrides, PlasmicClassVariants, VariantDef } from "../plume-utils";
+import { StyleProps } from "../props-utils";
+export interface BaseMenuProps extends DOMProps, AriaLabelingProps, StyleProps {
+    /**
+     * List of `Menu.Item`s or `Menu.Group`s that make up the menu
+     */
+    children?: React.ReactNode;
+    /**
+     * Called with the value of a `Menu.Item` when it is selected.
+     */
+    onAction?: (value: string) => void;
+}
+export type MenuRef = React.Ref<MenuRefValue>;
+export interface MenuRefValue extends MenuState {
+    getRoot: () => HTMLElement | null;
+}
+export interface MenuConfig<C extends AnyPlasmicClass> {
+    isPlacedTopVariant?: VariantDef<PlasmicClassVariants<C>>;
+    isPlacedBottomVariant?: VariantDef<PlasmicClassVariants<C>>;
+    isPlacedLeftVariant?: VariantDef<PlasmicClassVariants<C>>;
+    isPlacedRightVariant?: VariantDef<PlasmicClassVariants<C>>;
+    itemsSlot: keyof PlasmicClassArgs<C>;
+    itemsContainer: keyof PlasmicClassOverrides<C>;
+    root: keyof PlasmicClassOverrides<C>;
+}
+export interface MenuState {
+    getFocusedValue: () => string | null;
+    setFocusedValue: (value: string) => void;
+}
+export declare function useMenu<P extends BaseMenuProps, C extends AnyPlasmicClass>(plasmicClass: C, props: P, config: MenuConfig<C>, ref?: MenuRef): {
+    plasmicProps: {
+        variants: PlasmicClassVariants<C>;
+        args: PlasmicClassArgs<C>;
+        overrides: PlasmicClassOverrides<C>;
+    };
+    state: MenuState;
+};

package/dist/plume/menu-button/DropdownMenu.d.ts

@@ -1,34 +1,34 @@
-import { Placement } from "@react-types/overlays";
-import * as React from "react";
-import { BaseMenuProps } from "../menu/menu";
-export interface DropdownMenuProps {
-    /**
-     * A ReactElement that takes in a `ref` as well as the usual mouse and
-     * pointer events. The dropdown menu will be positioned relative to this
-     * trigger.
-     */
-    children: React.ReactElement;
-    /**
-     * The menu to show; must be either a ReactElement of Menu type, or
-     * a function that creates one if you prefer to delay creating it until
-     * the menu has been triggered.
-     */
-    menu: React.ReactElement<BaseMenuProps> | (() => React.ReactElement<BaseMenuProps>);
-    /**
-     * Where to place the menu relative to the trigger.
-     */
-    placement?: Placement;
-    /**
-     * Whether the menu is currently shown.
-     */
-    isOpen?: boolean;
-    /**
-     * Uncontrolled open state.
-     */
-    defaultOpen?: boolean;
-    /**
-     * Event handler fired when Menu's open state changes
-     */
-    onOpenChange?: (isOpen: boolean) => void;
-}
-export declare function DropdownMenu(props: DropdownMenuProps): JSX.Element;
+import { Placement } from "@react-types/overlays";
+import * as React from "react";
+import { BaseMenuProps } from "../menu/menu";
+export interface DropdownMenuProps {
+    /**
+     * A ReactElement that takes in a `ref` as well as the usual mouse and
+     * pointer events. The dropdown menu will be positioned relative to this
+     * trigger.
+     */
+    children: React.ReactElement;
+    /**
+     * The menu to show; must be either a ReactElement of Menu type, or
+     * a function that creates one if you prefer to delay creating it until
+     * the menu has been triggered.
+     */
+    menu: React.ReactElement<BaseMenuProps> | (() => React.ReactElement<BaseMenuProps>);
+    /**
+     * Where to place the menu relative to the trigger.
+     */
+    placement?: Placement;
+    /**
+     * Whether the menu is currently shown.
+     */
+    isOpen?: boolean;
+    /**
+     * Uncontrolled open state.
+     */
+    defaultOpen?: boolean;
+    /**
+     * Event handler fired when Menu's open state changes
+     */
+    onOpenChange?: (isOpen: boolean) => void;
+}
+export declare function DropdownMenu(props: DropdownMenuProps): JSX.Element;

package/dist/plume/menu-button/index.d.ts

@@ -1,2 +1,2 @@
-export { DropdownMenu } from "./DropdownMenu";
-export { BaseMenuButtonProps, MenuButtonRef, MenuButtonRefValue, useMenuButton, } from "./menu-button";
+export { DropdownMenu } from "./DropdownMenu";
+export { BaseMenuButtonProps, MenuButtonRef, MenuButtonRefValue, useMenuButton, } from "./menu-button";

package/dist/plume/menu-button/menu-button.d.ts

@@ -1,72 +1,72 @@
-import { Placement } from "@react-types/overlays";
-import { DOMProps, FocusableProps } from "@react-types/shared";
-import * as React from "react";
-import { BaseMenuProps } from "../menu/menu";
-import { AnyPlasmicClass, PlasmicClassArgs, PlasmicClassOverrides, PlasmicClassVariants, VariantDef } from "../plume-utils";
-import { StyleProps } from "../props-utils";
-export interface BaseMenuButtonProps extends DOMProps, FocusableProps, StyleProps, Pick<React.ComponentProps<"button">, "title"> {
-    /**
-     * The menu to show; can either be a Menu instance, or a function that returns a Menu
-     * instance if you want to defer creating the instance till when it's opened.
-     */
-    menu: React.ReactElement<BaseMenuProps> | (() => React.ReactElement<BaseMenuProps>);
-    /**
-     * Whether the button is disabled
-     */
-    isDisabled?: boolean;
-    /**
-     * Whether the menu is currently shown.
-     */
-    isOpen?: boolean;
-    /**
-     * Uncontrolled open state
-     */
-    defaultOpen?: boolean;
-    /**
-     * Event handler fired when Menu's open state changes
-     */
-    onOpenChange?: (isOpen: boolean) => void;
-    /**
-     * Desired placement location of the Select dropdown
-     */
-    placement?: Placement;
-    /**
-     * If true, menu width will always match the trigger button width.
-     * If false, then menu width will have min-width matching the
-     * trigger button width.
-     */
-    menuMatchTriggerWidth?: boolean;
-    /**
-     * If set, menu width will be exactly this width, overriding
-     * menuMatchTriggerWidth.
-     */
-    menuWidth?: number;
-}
-export interface MenuButtonConfig<C extends AnyPlasmicClass> {
-    isOpenVariant: VariantDef<PlasmicClassVariants<C>>;
-    isDisabledVariant?: VariantDef<PlasmicClassVariants<C>>;
-    menuSlot: keyof PlasmicClassArgs<C>;
-    root: keyof PlasmicClassOverrides<C>;
-    trigger: keyof PlasmicClassOverrides<C>;
-}
-interface MenuButtonState {
-    open: () => void;
-    close: () => void;
-    isOpen: () => boolean;
-}
-export type MenuButtonRef = React.Ref<MenuButtonRefValue>;
-export interface MenuButtonRefValue extends MenuButtonState {
-    getRoot: () => HTMLElement | null;
-    getTrigger: () => HTMLElement | null;
-    focus: () => void;
-    blur: () => void;
-}
-export declare function useMenuButton<P extends BaseMenuButtonProps, C extends AnyPlasmicClass>(plasmicClass: C, props: P, config: MenuButtonConfig<C>, outerRef?: MenuButtonRef): {
-    plasmicProps: {
-        variants: PlasmicClassVariants<C>;
-        args: PlasmicClassArgs<C>;
-        overrides: PlasmicClassOverrides<C>;
-    };
-    state: MenuButtonState;
-};
-export {};
+import { Placement } from "@react-types/overlays";
+import { DOMProps, FocusableProps } from "@react-types/shared";
+import * as React from "react";
+import { BaseMenuProps } from "../menu/menu";
+import { AnyPlasmicClass, PlasmicClassArgs, PlasmicClassOverrides, PlasmicClassVariants, VariantDef } from "../plume-utils";
+import { StyleProps } from "../props-utils";
+export interface BaseMenuButtonProps extends DOMProps, FocusableProps, StyleProps, Pick<React.ComponentProps<"button">, "title"> {
+    /**
+     * The menu to show; can either be a Menu instance, or a function that returns a Menu
+     * instance if you want to defer creating the instance till when it's opened.
+     */
+    menu: React.ReactElement<BaseMenuProps> | (() => React.ReactElement<BaseMenuProps>);
+    /**
+     * Whether the button is disabled
+     */
+    isDisabled?: boolean;
+    /**
+     * Whether the menu is currently shown.
+     */
+    isOpen?: boolean;
+    /**
+     * Uncontrolled open state
+     */
+    defaultOpen?: boolean;
+    /**
+     * Event handler fired when Menu's open state changes
+     */
+    onOpenChange?: (isOpen: boolean) => void;
+    /**
+     * Desired placement location of the Select dropdown
+     */
+    placement?: Placement;
+    /**
+     * If true, menu width will always match the trigger button width.
+     * If false, then menu width will have min-width matching the
+     * trigger button width.
+     */
+    menuMatchTriggerWidth?: boolean;
+    /**
+     * If set, menu width will be exactly this width, overriding
+     * menuMatchTriggerWidth.
+     */
+    menuWidth?: number;
+}
+export interface MenuButtonConfig<C extends AnyPlasmicClass> {
+    isOpenVariant: VariantDef<PlasmicClassVariants<C>>;
+    isDisabledVariant?: VariantDef<PlasmicClassVariants<C>>;
+    menuSlot: keyof PlasmicClassArgs<C>;
+    root: keyof PlasmicClassOverrides<C>;
+    trigger: keyof PlasmicClassOverrides<C>;
+}
+interface MenuButtonState {
+    open: () => void;
+    close: () => void;
+    isOpen: () => boolean;
+}
+export type MenuButtonRef = React.Ref<MenuButtonRefValue>;
+export interface MenuButtonRefValue extends MenuButtonState {
+    getRoot: () => HTMLElement | null;
+    getTrigger: () => HTMLElement | null;
+    focus: () => void;
+    blur: () => void;
+}
+export declare function useMenuButton<P extends BaseMenuButtonProps, C extends AnyPlasmicClass>(plasmicClass: C, props: P, config: MenuButtonConfig<C>, outerRef?: MenuButtonRef): {
+    plasmicProps: {
+        variants: PlasmicClassVariants<C>;
+        args: PlasmicClassArgs<C>;
+        overrides: PlasmicClassOverrides<C>;
+    };
+    state: MenuButtonState;
+};
+export {};

package/dist/plume/menu-button/menu-trigger.d.ts

@@ -1,21 +1,21 @@
-import { Placement } from "@react-types/overlays";
-import * as React from "react";
-import { MenuTriggerState } from "@react-stately/menu";
-import { BaseMenuProps } from "../menu/menu";
-import { TriggeredOverlayContextValue } from "../triggered-overlay/context";
-/**
- * A menu trigger hook that combines react-aria's useMenuTrigger, useAriaMenuTrigger,
- * useOverlayPosition, useOverlay, and usePress
- */
-export declare function useMenuTrigger(opts: {
-    isDisabled?: boolean;
-    triggerRef: React.RefObject<HTMLElement>;
-    placement?: Placement;
-    menuMatchTriggerWidth?: boolean;
-    menuWidth?: number;
-    menu: React.ReactElement<BaseMenuProps> | (() => React.ReactElement<BaseMenuProps>);
-}, state: MenuTriggerState): {
-    triggerProps: import("@react-types/shared").DOMAttributes<import("@react-types/shared").FocusableElement>;
-    makeMenu: () => React.ReactElement<BaseMenuProps, string | React.JSXElementConstructor<any>> | null;
-    triggerContext: TriggeredOverlayContextValue;
-};
+import { Placement } from "@react-types/overlays";
+import * as React from "react";
+import { MenuTriggerState } from "@react-stately/menu";
+import { BaseMenuProps } from "../menu/menu";
+import { TriggeredOverlayContextValue } from "../triggered-overlay/context";
+/**
+ * A menu trigger hook that combines react-aria's useMenuTrigger, useAriaMenuTrigger,
+ * useOverlayPosition, useOverlay, and usePress
+ */
+export declare function useMenuTrigger(opts: {
+    isDisabled?: boolean;
+    triggerRef: React.RefObject<HTMLElement>;
+    placement?: Placement;
+    menuMatchTriggerWidth?: boolean;
+    menuWidth?: number;
+    menu: React.ReactElement<BaseMenuProps> | (() => React.ReactElement<BaseMenuProps>);
+}, state: MenuTriggerState): {
+    triggerProps: import("@react-types/shared").DOMAttributes<import("@react-types/shared").FocusableElement>;
+    makeMenu: () => React.ReactElement<BaseMenuProps, string | React.JSXElementConstructor<any>> | null;
+    triggerContext: TriggeredOverlayContextValue;
+};

package/dist/plume/plume-utils.d.ts

@@ -1,41 +1,41 @@
-import * as React from "react";
-import { SingleChoiceArg } from "../render/elements";
-export declare let PLUME_STRICT_MODE: boolean;
-export declare function setPlumeStrictMode(mode: boolean): void;
-type VariantArgChoices<T> = T extends (infer M)[] ? M : T extends SingleChoiceArg<infer M> ? M : never;
-type VariantArgsChoices<V> = {
-    [k in keyof V]-?: VariantArgChoices<V[k]>;
-};
-type DictValues<V extends Record<string, any>> = V[keyof V];
-type DictTuples<V extends Record<string, any>> = DictValues<{
-    [K in keyof V]: [K, V[K]];
-}>;
-export type VariantDefTuple<V> = DictTuples<VariantArgsChoices<V>>;
-type DistributeTuple<T> = T extends [infer T1, infer T2] ? {
-    group: T1;
-    variant: T2;
-} : never;
-export type VariantDef<V> = DistributeTuple<VariantDefTuple<V>>;
-export type PlasmicClass<V extends Record<string, any>, A extends Record<string, any>, O extends Record<string, any>> = {
-    (props: {
-        variants?: V;
-        args?: A;
-        overrides?: O;
-    }): React.ReactElement | null;
-    internalVariantProps: (keyof V)[];
-    internalArgProps: (keyof A)[];
-};
-export type AnyPlasmicClass = PlasmicClass<any, any, any>;
-export type PlasmicClassVariants<C extends AnyPlasmicClass> = C extends PlasmicClass<infer V, any, any> ? V : unknown;
-export type PlasmicClassArgs<C extends AnyPlasmicClass> = C extends PlasmicClass<any, infer A, any> ? A : unknown;
-export type PlasmicClassOverrides<C extends AnyPlasmicClass> = C extends PlasmicClass<any, any, infer O> ? O : unknown;
-type BooleanLike = boolean | undefined | null;
-export declare function mergeVariantToggles<V>(...toggles: {
-    def?: VariantDef<V>;
-    active: BooleanLike;
-}[]): Record<string, any>;
-export declare function noOutline(): {
-    outline: string;
-};
-export declare function getPlumeType(child: React.ReactChild): string | undefined;
-export {};
+import * as React from "react";
+import { SingleChoiceArg } from "../render/elements";
+export declare let PLUME_STRICT_MODE: boolean;
+export declare function setPlumeStrictMode(mode: boolean): void;
+type VariantArgChoices<T> = T extends (infer M)[] ? M : T extends SingleChoiceArg<infer M> ? M : never;
+type VariantArgsChoices<V> = {
+    [k in keyof V]-?: VariantArgChoices<V[k]>;
+};
+type DictValues<V extends Record<string, any>> = V[keyof V];
+type DictTuples<V extends Record<string, any>> = DictValues<{
+    [K in keyof V]: [K, V[K]];
+}>;
+export type VariantDefTuple<V> = DictTuples<VariantArgsChoices<V>>;
+type DistributeTuple<T> = T extends [infer T1, infer T2] ? {
+    group: T1;
+    variant: T2;
+} : never;
+export type VariantDef<V> = DistributeTuple<VariantDefTuple<V>>;
+export type PlasmicClass<V extends Record<string, any>, A extends Record<string, any>, O extends Record<string, any>> = {
+    (props: {
+        variants?: V;
+        args?: A;
+        overrides?: O;
+    }): React.ReactElement | null;
+    internalVariantProps: (keyof V)[];
+    internalArgProps: (keyof A)[];
+};
+export type AnyPlasmicClass = PlasmicClass<any, any, any>;
+export type PlasmicClassVariants<C extends AnyPlasmicClass> = C extends PlasmicClass<infer V, any, any> ? V : unknown;
+export type PlasmicClassArgs<C extends AnyPlasmicClass> = C extends PlasmicClass<any, infer A, any> ? A : unknown;
+export type PlasmicClassOverrides<C extends AnyPlasmicClass> = C extends PlasmicClass<any, any, infer O> ? O : unknown;
+type BooleanLike = boolean | undefined | null;
+export declare function mergeVariantToggles<V>(...toggles: {
+    def?: VariantDef<V>;
+    active: BooleanLike;
+}[]): Record<string, any>;
+export declare function noOutline(): {
+    outline: string;
+};
+export declare function getPlumeType(child: React.ReactChild): string | undefined;
+export {};

package/dist/plume/props-utils.d.ts

@@ -1,15 +1,15 @@
-import * as React from "react";
-import { AnyPlasmicClass, PlasmicClassArgs, PlasmicClassOverrides, PlasmicClassVariants } from "./plume-utils";
-export interface StyleProps {
-    className?: string;
-    style?: React.CSSProperties;
-}
-export declare function getStyleProps<P extends StyleProps>(props: P): StyleProps;
-export declare function getDefaultPlasmicProps<C extends AnyPlasmicClass>(plasmicClass: C, props: Record<string, any>): {
-    plasmicProps: {
-        variants: PlasmicClassVariants<C>;
-        args: PlasmicClassArgs<C>;
-        overrides: PlasmicClassOverrides<C>;
-    };
-};
-export declare function getDataProps(props: Record<string, any>): Partial<Record<string, any>>;
+import * as React from "react";
+import { AnyPlasmicClass, PlasmicClassArgs, PlasmicClassOverrides, PlasmicClassVariants } from "./plume-utils";
+export interface StyleProps {
+    className?: string;
+    style?: React.CSSProperties;
+}
+export declare function getStyleProps<P extends StyleProps>(props: P): StyleProps;
+export declare function getDefaultPlasmicProps<C extends AnyPlasmicClass>(plasmicClass: C, props: Record<string, any>): {
+    plasmicProps: {
+        variants: PlasmicClassVariants<C>;
+        args: PlasmicClassArgs<C>;
+        overrides: PlasmicClassOverrides<C>;
+    };
+};
+export declare function getDataProps(props: Record<string, any>): Partial<Record<string, any>>;

package/dist/plume/select/context.d.ts

@@ -1,3 +1,3 @@
-import * as React from "react";
-import type { ListState } from "@react-stately/list";
-export declare const SelectContext: React.Context<ListState<any> | undefined>;
+import * as React from "react";
+import type { ListState } from "@react-stately/list";
+export declare const SelectContext: React.Context<ListState<any> | undefined>;

package/dist/plume/select/index.d.ts

@@ -1,4 +1,4 @@
-export { BaseSelectProps, SelectRef, SelectRefValue, useSelect, } from "./select";
-export { BaseSelectOptionProps, SelectOptionRef, useSelectOption, } from "./select-option";
-export { BaseSelectOptionGroupProps, useSelectOptionGroup, } from "./select-option-group";
-export { SelectContext } from "./context";
+export { BaseSelectProps, SelectRef, SelectRefValue, useSelect, } from "./select";
+export { BaseSelectOptionProps, SelectOptionRef, useSelectOption, } from "./select-option";
+export { BaseSelectOptionGroupProps, useSelectOptionGroup, } from "./select-option-group";
+export { SelectContext } from "./context";

package/dist/plume/select/select-option-group.d.ts

@@ -1,23 +1,23 @@
-import { SectionLikeProps } from "../collection-utils";
-import { AnyPlasmicClass, PlasmicClassArgs, PlasmicClassOverrides, PlasmicClassVariants } from "../plume-utils";
-import { StyleProps } from "../props-utils";
-export interface BaseSelectOptionGroupProps extends SectionLikeProps, StyleProps {
-}
-interface SelectOptionGroupConfig<C extends AnyPlasmicClass> {
-    noTitleVariant: PlasmicClassVariants<C>;
-    isFirstVariant: PlasmicClassVariants<C>;
-    optionsSlot: keyof PlasmicClassArgs<C>;
-    titleSlot: keyof PlasmicClassArgs<C>;
-    root: keyof PlasmicClassOverrides<C>;
-    separator: keyof PlasmicClassOverrides<C>;
-    titleContainer: keyof PlasmicClassOverrides<C>;
-    optionsContainer: keyof PlasmicClassOverrides<C>;
-}
-export declare function useSelectOptionGroup<P extends BaseSelectOptionGroupProps, C extends AnyPlasmicClass>(plasmicClass: C, props: P, config: SelectOptionGroupConfig<C>): {
-    plasmicProps: {
-        variants: PlasmicClassVariants<C>;
-        args: PlasmicClassArgs<C>;
-        overrides: PlasmicClassOverrides<C>;
-    };
-};
-export {};
+import { SectionLikeProps } from "../collection-utils";
+import { AnyPlasmicClass, PlasmicClassArgs, PlasmicClassOverrides, PlasmicClassVariants } from "../plume-utils";
+import { StyleProps } from "../props-utils";
+export interface BaseSelectOptionGroupProps extends SectionLikeProps, StyleProps {
+}
+interface SelectOptionGroupConfig<C extends AnyPlasmicClass> {
+    noTitleVariant: PlasmicClassVariants<C>;
+    isFirstVariant: PlasmicClassVariants<C>;
+    optionsSlot: keyof PlasmicClassArgs<C>;
+    titleSlot: keyof PlasmicClassArgs<C>;
+    root: keyof PlasmicClassOverrides<C>;
+    separator: keyof PlasmicClassOverrides<C>;
+    titleContainer: keyof PlasmicClassOverrides<C>;
+    optionsContainer: keyof PlasmicClassOverrides<C>;
+}
+export declare function useSelectOptionGroup<P extends BaseSelectOptionGroupProps, C extends AnyPlasmicClass>(plasmicClass: C, props: P, config: SelectOptionGroupConfig<C>): {
+    plasmicProps: {
+        variants: PlasmicClassVariants<C>;
+        args: PlasmicClassArgs<C>;
+        overrides: PlasmicClassOverrides<C>;
+    };
+};
+export {};

package/dist/plume/select/select-option.d.ts

@@ -1,23 +1,23 @@
-import * as React from "react";
-import { ItemLikeProps } from "../collection-utils";
-import { AnyPlasmicClass, PlasmicClassArgs, PlasmicClassOverrides, PlasmicClassVariants, VariantDef } from "../plume-utils";
-import { StyleProps } from "../props-utils";
-export interface BaseSelectOptionProps extends ItemLikeProps, StyleProps {
-}
-interface SelectOptionConfig<C extends AnyPlasmicClass> {
-    isSelectedVariant: VariantDef<PlasmicClassVariants<C>>;
-    isDisabledVariant?: VariantDef<PlasmicClassVariants<C>>;
-    isHighlightedVariant?: VariantDef<PlasmicClassVariants<C>>;
-    labelSlot: keyof PlasmicClassArgs<C>;
-    root: keyof PlasmicClassOverrides<C>;
-    labelContainer: keyof PlasmicClassOverrides<C>;
-}
-export type SelectOptionRef = React.Ref<HTMLElement>;
-export declare function useSelectOption<P extends BaseSelectOptionProps, C extends AnyPlasmicClass>(plasmicClass: C, props: P, config: SelectOptionConfig<C>, outerRef?: SelectOptionRef): {
-    plasmicProps: {
-        variants: PlasmicClassVariants<C>;
-        args: PlasmicClassArgs<C>;
-        overrides: PlasmicClassOverrides<C>;
-    };
-};
-export {};
+import * as React from "react";
+import { ItemLikeProps } from "../collection-utils";
+import { AnyPlasmicClass, PlasmicClassArgs, PlasmicClassOverrides, PlasmicClassVariants, VariantDef } from "../plume-utils";
+import { StyleProps } from "../props-utils";
+export interface BaseSelectOptionProps extends ItemLikeProps, StyleProps {
+}
+interface SelectOptionConfig<C extends AnyPlasmicClass> {
+    isSelectedVariant: VariantDef<PlasmicClassVariants<C>>;
+    isDisabledVariant?: VariantDef<PlasmicClassVariants<C>>;
+    isHighlightedVariant?: VariantDef<PlasmicClassVariants<C>>;
+    labelSlot: keyof PlasmicClassArgs<C>;
+    root: keyof PlasmicClassOverrides<C>;
+    labelContainer: keyof PlasmicClassOverrides<C>;
+}
+export type SelectOptionRef = React.Ref<HTMLElement>;
+export declare function useSelectOption<P extends BaseSelectOptionProps, C extends AnyPlasmicClass>(plasmicClass: C, props: P, config: SelectOptionConfig<C>, outerRef?: SelectOptionRef): {
+    plasmicProps: {
+        variants: PlasmicClassVariants<C>;
+        args: PlasmicClassArgs<C>;
+        overrides: PlasmicClassOverrides<C>;
+    };
+};
+export {};