@plasmicapp/react-web 0.2.103 → 0.2.106

package/dist/all.d.ts

@@ -1,5 +1,5 @@
 import * as React from 'react';
-import React__default, { FocusEvent, KeyboardEvent as KeyboardEvent$1, SyntheticEvent, ReactNode } from 'react';
+import React__default, { AriaAttributes, DOMAttributes as DOMAttributes$1, AriaRole, CSSProperties, Key, ReactNode, ReactElement, FocusEvent, KeyboardEvent as KeyboardEvent$1, SyntheticEvent } from 'react';
 
 // This is the only way I found to break circular references between ClassArray and ClassValue
 // https://github.com/Microsoft/TypeScript/issues/3496#issuecomment-128553540
@@ -82,6 +82,39 @@ declare function deriveRenderOpts(props: Record<string, any>, config: {
 
 declare function ensureGlobalVariants<T extends Record<string, any>>(globalVariantValues: T): T;
 
+declare type PlasmicHeadProps = {
+    title?: string;
+    description?: string;
+    image?: string;
+    canonical?: string;
+};
+declare function PlasmicHead(props: PlasmicHeadProps): JSX.Element | null;
+declare const plasmicHeadMeta: {
+    name: string;
+    displayName: string;
+    description: string;
+    importName: string;
+    importPath: string;
+    props: {
+        title: {
+            type: string;
+            displayName: string;
+        };
+        description: {
+            type: string;
+            displayName: string;
+        };
+        image: {
+            type: string;
+            displayName: string;
+        };
+        canonical: {
+            type: string;
+            displayName: string;
+        };
+    };
+};
+
 declare function PlasmicIcon(props: React.ComponentProps<"svg"> & {
     PlasmicIconType: React.ComponentType;
 }): JSX.Element;
@@ -213,6 +246,7 @@ interface PlasmicRootProviderProps {
     platform?: "nextjs" | "gatsby";
     children?: React.ReactNode;
     translator?: PlasmicTranslator;
+    Head?: React.ComponentType<any>;
 }
 declare function PlasmicRootProvider(props: PlasmicRootProviderProps): JSX.Element;
 declare const useIsSSR: typeof useIsSSR$1;
@@ -268,109 +302,6 @@ declare const Stack: (<T extends "symbol" | "object" | "a" | "abbr" | "address"
     }>;
 };
 
-declare function useFocused(opts: {
-    isTextInput?: boolean;
-}): (boolean | React.HTMLAttributes<HTMLElement>)[];
-declare function useFocusVisible(opts: {
-    isTextInput?: boolean;
-}): (boolean | React.HTMLAttributes<HTMLElement>)[];
-declare function useFocusedWithin(opts: {
-    isTextInput?: boolean;
-}): (boolean | React.HTMLAttributes<HTMLElement>)[];
-declare function useFocusVisibleWithin(opts: {
-    isTextInput?: boolean;
-}): (boolean | React.HTMLAttributes<HTMLElement>)[];
-declare function useHover(): (boolean | {
-    onMouseEnter: () => void;
-    onMouseLeave: () => void;
-})[];
-declare function usePressed(): (boolean | {
-    onMouseDown: () => void;
-    onMouseUp: () => void;
-})[];
-declare const TRIGGER_TO_HOOK: {
-    readonly useHover: typeof useHover;
-    readonly useFocused: typeof useFocused;
-    readonly useFocusVisible: typeof useFocusVisible;
-    readonly useFocusedWithin: typeof useFocusedWithin;
-    readonly useFocusVisibleWithin: typeof useFocusVisibleWithin;
-    readonly usePressed: typeof usePressed;
-};
-declare type TriggerType = keyof typeof TRIGGER_TO_HOOK;
-interface TriggerOpts {
-    isTextInput?: boolean;
-}
-/**
- * Installs argment trigger. All the useTrigger calls must use hardcoded `trigger` arg,
- * as it's not valid to install variable React hooks!
- */
-declare function useTrigger(trigger: TriggerType, opts: TriggerOpts): [boolean, React.HTMLAttributes<HTMLElement>];
-
-declare const classNames: ClassNamesExport;
-
-declare function setPlumeStrictMode(mode: boolean): void;
-declare type VariantArgChoices<T> = T extends (infer M)[] ? M : T extends SingleChoiceArg<infer M> ? M : never;
-declare type VariantArgsChoices<V> = {
-    [k in keyof V]-?: VariantArgChoices<V[k]>;
-};
-declare type DictValues<V extends Record<string, any>> = V[keyof V];
-declare type DictTuples<V extends Record<string, any>> = DictValues<{
-    [K in keyof V]: [K, V[K]];
-}>;
-declare type VariantDefTuple<V> = DictTuples<VariantArgsChoices<V>>;
-declare type DistributeTuple<T> = T extends [infer T1, infer T2] ? {
-    group: T1;
-    variant: T2;
-} : never;
-declare type VariantDef<V> = DistributeTuple<VariantDefTuple<V>>;
-declare 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)[];
-};
-declare type AnyPlasmicClass = PlasmicClass<any, any, any>;
-declare type PlasmicClassVariants<C extends AnyPlasmicClass> = C extends PlasmicClass<infer V, any, any> ? V : unknown;
-declare type PlasmicClassArgs<C extends AnyPlasmicClass> = C extends PlasmicClass<any, infer A, any> ? A : unknown;
-declare type PlasmicClassOverrides<C extends AnyPlasmicClass> = C extends PlasmicClass<any, any, infer O> ? O : unknown;
-
-interface CommonProps {
-    showStartIcon?: boolean;
-    showEndIcon?: boolean;
-    startIcon?: React.ReactNode;
-    endIcon?: React.ReactNode;
-    children?: React.ReactNode;
-    isDisabled?: boolean;
-}
-interface HtmlButtonProps extends Omit<React.ComponentProps<"button">, "ref" | "disabled"> {
-}
-interface HtmlAnchorProps extends Omit<React.ComponentProps<"a">, "ref" | "href"> {
-    link?: string;
-}
-declare type BaseButtonProps = CommonProps & HtmlButtonProps & HtmlAnchorProps;
-declare type HtmlAnchorOnlyProps = Exclude<keyof HtmlAnchorProps, keyof HtmlButtonProps>;
-declare type HtmlButtonOnlyProps = Exclude<keyof HtmlButtonProps, keyof HtmlAnchorProps>;
-declare type ButtonRef = React.Ref<HTMLButtonElement | HTMLAnchorElement>;
-interface ButtonConfig<C extends AnyPlasmicClass> {
-    showStartIconVariant: VariantDef<PlasmicClassVariants<C>>;
-    showEndIconVariant?: VariantDef<PlasmicClassVariants<C>>;
-    isDisabledVariant?: VariantDef<PlasmicClassVariants<C>>;
-    startIconSlot?: keyof PlasmicClassArgs<C>;
-    endIconSlot?: keyof PlasmicClassArgs<C>;
-    contentSlot: keyof PlasmicClassArgs<C>;
-    root: keyof PlasmicClassOverrides<C>;
-}
-declare function useButton<P extends BaseButtonProps, C extends AnyPlasmicClass>(plasmicClass: C, props: P, config: ButtonConfig<C>, ref?: ButtonRef): {
-    plasmicProps: {
-        variants: PlasmicClassVariants<C>;
-        args: PlasmicClassArgs<C>;
-        overrides: PlasmicClassOverrides<C>;
-    };
-};
-
 /*
  * Copyright 2020 Adobe. All rights reserved.
  * This file is licensed to you under the Apache License, Version 2.0 (the "License");
@@ -433,6 +364,17 @@ interface FocusableDOMProps extends DOMProps {
   excludeFromTabOrder?: boolean
 }
 
+/** Any focusable element, including both HTML and SVG elements. */
+interface FocusableElement extends Element, HTMLOrSVGElement {}
+
+/** All DOM attributes supported across both HTML and SVG elements. */
+interface DOMAttributes<T = FocusableElement> extends AriaAttributes, DOMAttributes$1<T> {
+  id?: string | undefined,
+  role?: AriaRole | undefined,
+  tabIndex?: number | undefined,
+  style?: CSSProperties | undefined
+}
+
 /*
  * Copyright 2020 Adobe. All rights reserved.
  * This file is licensed to you under the Apache License, Version 2.0 (the "License");
@@ -478,6 +420,104 @@ interface InputBase {
  */
 
 
+type SelectionMode = 'none' | 'single' | 'multiple';
+type SelectionBehavior = 'toggle' | 'replace';
+type Selection = 'all' | Set<Key>;
+
+type FocusStrategy = 'first' | 'last';
+type DisabledBehavior = 'selection' | 'all';
+
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+
+/**
+ * A generic interface to access a readonly sequential
+ * collection of unique keyed items.
+ */
+interface Collection<T> extends Iterable<T> {
+  /** The number of items in the collection. */
+  readonly size: number,
+
+  /** Iterate over all keys in the collection. */
+  getKeys(): Iterable<Key>,
+
+  /** Get an item by its key. */
+  getItem(key: Key): T,
+
+  /** Get an item by the index of its key. */
+  at(idx: number): T,
+
+  /** Get the key that comes before the given key in the collection. */
+  getKeyBefore(key: Key): Key | null,
+
+  /** Get the key that comes after the given key in the collection. */
+  getKeyAfter(key: Key): Key | null,
+
+  /** Get the first key in the collection. */
+  getFirstKey(): Key | null,
+
+  /** Get the last key in the collection. */
+  getLastKey(): Key | null
+}
+
+interface Node<T> {
+  /** The type of item this node represents. */
+  type: string,
+  /** A unique key for the node. */
+  key: Key,
+  /** The object value the node was created from. */
+  value: T,
+  /** The level of depth this node is at in the heirarchy. */
+  level: number,
+  /** Whether this item has children, even if not loaded yet. */
+  hasChildNodes: boolean,
+  /** The loaded children of this node. */
+  childNodes: Iterable<Node<T>>,
+  /** The rendered contents of this node (e.g. JSX). */
+  rendered: ReactNode,
+  /** A string value for this node, used for features like typeahead. */
+  textValue: string,
+  /** An accessibility label for this node. */
+  'aria-label'?: string,
+  /** The index of this node within its parent. */
+  index?: number,
+  /** A function that should be called to wrap the rendered node. */
+  wrapper?: (element: ReactElement) => ReactElement,
+  /** The key of the parent node. */
+  parentKey?: Key,
+  /** The key of the node before this node. */
+  prevKey?: Key,
+  /** The key of the node after this node. */
+  nextKey?: Key,
+  /** Additional properties specific to a particular node type. */
+  props?: any,
+  /** @private */
+  shouldInvalidate?: (context: unknown) => boolean
+}
+
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+
 // Event bubbling can be problematic in real-world applications, so the default for React Spectrum components
 // is not to propagate. This can be overridden by calling continuePropagation() on the event.
 type BaseEvent<T extends SyntheticEvent> = T & {
@@ -488,6 +528,30 @@ type BaseEvent<T extends SyntheticEvent> = T & {
 
 type KeyboardEvent = BaseEvent<KeyboardEvent$1<any>>;
 
+type PointerType = 'mouse' | 'pen' | 'touch' | 'keyboard' | 'virtual';
+
+interface PressEvent {
+  /** The type of press event being fired. */
+  type: 'pressstart' | 'pressend' | 'pressup' | 'press',
+  /** The pointer type that triggered the press event. */
+  pointerType: PointerType,
+  /** The target element of the press event. */
+  target: Element,
+  /** Whether the shift keyboard modifier was held during the press event. */
+  shiftKey: boolean,
+  /** Whether the ctrl keyboard modifier was held during the press event. */
+  ctrlKey: boolean,
+  /** Whether the meta keyboard modifier was held during the press event. */
+  metaKey: boolean,
+  /** Whether the alt keyboard modifier was held during the press event. */
+  altKey: boolean
+}
+
+interface LongPressEvent extends Omit<PressEvent, 'type'> {
+  /** The type of long press event being fired. */
+  type: 'longpressstart' | 'longpressend' | 'longpress'
+}
+
 interface KeyboardEvents {
   /** Handler that is called when a key is pressed. */
   onKeyDown?: (e: KeyboardEvent) => void,
@@ -509,6 +573,109 @@ interface FocusableProps extends FocusEvents, KeyboardEvents {
   autoFocus?: boolean
 }
 
+declare function useFocused(opts: {
+    isTextInput?: boolean;
+}): (boolean | DOMAttributes<FocusableElement>)[];
+declare function useFocusVisible(opts: {
+    isTextInput?: boolean;
+}): (boolean | DOMAttributes<FocusableElement>)[];
+declare function useFocusedWithin(opts: {
+    isTextInput?: boolean;
+}): (boolean | DOMAttributes<FocusableElement>)[];
+declare function useFocusVisibleWithin(opts: {
+    isTextInput?: boolean;
+}): (boolean | DOMAttributes<FocusableElement>)[];
+declare function useHover(): (boolean | {
+    onMouseEnter: () => void;
+    onMouseLeave: () => void;
+})[];
+declare function usePressed(): (boolean | {
+    onMouseDown: () => void;
+    onMouseUp: () => void;
+})[];
+declare const TRIGGER_TO_HOOK: {
+    readonly useHover: typeof useHover;
+    readonly useFocused: typeof useFocused;
+    readonly useFocusVisible: typeof useFocusVisible;
+    readonly useFocusedWithin: typeof useFocusedWithin;
+    readonly useFocusVisibleWithin: typeof useFocusVisibleWithin;
+    readonly usePressed: typeof usePressed;
+};
+declare type TriggerType = keyof typeof TRIGGER_TO_HOOK;
+interface TriggerOpts {
+    isTextInput?: boolean;
+}
+/**
+ * Installs argment trigger. All the useTrigger calls must use hardcoded `trigger` arg,
+ * as it's not valid to install variable React hooks!
+ */
+declare function useTrigger(trigger: TriggerType, opts: TriggerOpts): [boolean, React.HTMLAttributes<HTMLElement>];
+
+declare const classNames: ClassNamesExport;
+
+declare function setPlumeStrictMode(mode: boolean): void;
+declare type VariantArgChoices<T> = T extends (infer M)[] ? M : T extends SingleChoiceArg<infer M> ? M : never;
+declare type VariantArgsChoices<V> = {
+    [k in keyof V]-?: VariantArgChoices<V[k]>;
+};
+declare type DictValues<V extends Record<string, any>> = V[keyof V];
+declare type DictTuples<V extends Record<string, any>> = DictValues<{
+    [K in keyof V]: [K, V[K]];
+}>;
+declare type VariantDefTuple<V> = DictTuples<VariantArgsChoices<V>>;
+declare type DistributeTuple<T> = T extends [infer T1, infer T2] ? {
+    group: T1;
+    variant: T2;
+} : never;
+declare type VariantDef<V> = DistributeTuple<VariantDefTuple<V>>;
+declare 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)[];
+};
+declare type AnyPlasmicClass = PlasmicClass<any, any, any>;
+declare type PlasmicClassVariants<C extends AnyPlasmicClass> = C extends PlasmicClass<infer V, any, any> ? V : unknown;
+declare type PlasmicClassArgs<C extends AnyPlasmicClass> = C extends PlasmicClass<any, infer A, any> ? A : unknown;
+declare type PlasmicClassOverrides<C extends AnyPlasmicClass> = C extends PlasmicClass<any, any, infer O> ? O : unknown;
+
+interface CommonProps {
+    showStartIcon?: boolean;
+    showEndIcon?: boolean;
+    startIcon?: React.ReactNode;
+    endIcon?: React.ReactNode;
+    children?: React.ReactNode;
+    isDisabled?: boolean;
+}
+interface HtmlButtonProps extends Omit<React.ComponentProps<"button">, "ref" | "disabled"> {
+}
+interface HtmlAnchorProps extends Omit<React.ComponentProps<"a">, "ref" | "href"> {
+    link?: string;
+}
+declare type BaseButtonProps = CommonProps & HtmlButtonProps & HtmlAnchorProps;
+declare type HtmlAnchorOnlyProps = Exclude<keyof HtmlAnchorProps, keyof HtmlButtonProps>;
+declare type HtmlButtonOnlyProps = Exclude<keyof HtmlButtonProps, keyof HtmlAnchorProps>;
+declare type ButtonRef = React.Ref<HTMLButtonElement | HTMLAnchorElement>;
+interface ButtonConfig<C extends AnyPlasmicClass> {
+    showStartIconVariant: VariantDef<PlasmicClassVariants<C>>;
+    showEndIconVariant?: VariantDef<PlasmicClassVariants<C>>;
+    isDisabledVariant?: VariantDef<PlasmicClassVariants<C>>;
+    startIconSlot?: keyof PlasmicClassArgs<C>;
+    endIconSlot?: keyof PlasmicClassArgs<C>;
+    contentSlot: keyof PlasmicClassArgs<C>;
+    root: keyof PlasmicClassOverrides<C>;
+}
+declare function useButton<P extends BaseButtonProps, C extends AnyPlasmicClass>(plasmicClass: C, props: P, config: ButtonConfig<C>, ref?: ButtonRef): {
+    plasmicProps: {
+        variants: PlasmicClassVariants<C>;
+        args: PlasmicClassArgs<C>;
+        overrides: PlasmicClassOverrides<C>;
+    };
+};
+
 /*
  * Copyright 2020 Adobe. All rights reserved.
  * This file is licensed to you under the Apache License, Version 2.0 (the "License");
@@ -1044,6 +1211,202 @@ declare function useSelectOptionGroup<P extends BaseSelectOptionGroupProps, C ex
     };
 };
 
+interface FocusState {
+    /** Whether the collection is currently focused. */
+    readonly isFocused: boolean;
+    /** Sets whether the collection is focused. */
+    setFocused(isFocused: boolean): void;
+    /** The current focused key in the collection. */
+    readonly focusedKey: Key;
+    /** Whether the first or last child of the focused key should receive focus. */
+    readonly childFocusStrategy: FocusStrategy;
+    /** Sets the focused key, and optionally, whether the first or last child of that key should receive focus. */
+    setFocusedKey(key: Key, child?: FocusStrategy): void;
+}
+interface MultipleSelectionState extends FocusState {
+    /** The type of selection that is allowed in the collection. */
+    readonly selectionMode: SelectionMode;
+    /** The selection behavior for the collection. */
+    readonly selectionBehavior: SelectionBehavior;
+    /** Sets the selection behavior for the collection. */
+    setSelectionBehavior(selectionBehavior: SelectionBehavior): void;
+    /** Whether the collection allows empty selection. */
+    readonly disallowEmptySelection: boolean;
+    /** The currently selected keys in the collection. */
+    readonly selectedKeys: Selection;
+    /** Sets the selected keys in the collection. */
+    setSelectedKeys(keys: Selection): void;
+    /** The currently disabled keys in the collection. */
+    readonly disabledKeys: Set<Key>;
+    /** Whether `disabledKeys` applies to selection, actions, or both. */
+    readonly disabledBehavior: DisabledBehavior;
+}
+interface MultipleSelectionManager extends FocusState {
+    /** The type of selection that is allowed in the collection. */
+    readonly selectionMode: SelectionMode;
+    /** The selection behavior for the collection. */
+    readonly selectionBehavior: SelectionBehavior;
+    /** Whether the collection allows empty selection. */
+    readonly disallowEmptySelection?: boolean;
+    /** The currently selected keys in the collection. */
+    readonly selectedKeys: Set<Key>;
+    /** Whether the selection is empty. */
+    readonly isEmpty: boolean;
+    /** Whether all items in the collection are selected. */
+    readonly isSelectAll: boolean;
+    /** The first selected key in the collection. */
+    readonly firstSelectedKey: Key | null;
+    /** The last selected key in the collection. */
+    readonly lastSelectedKey: Key | null;
+    /** The currently disabled keys in the collection. */
+    readonly disabledKeys: Set<Key>;
+    /** Whether `disabledKeys` applies to selection, actions, or both. */
+    readonly disabledBehavior: DisabledBehavior;
+    /** Returns whether a key is selected. */
+    isSelected(key: Key): boolean;
+    /** Returns whether the current selection is equal to the given selection. */
+    isSelectionEqual(selection: Set<Key>): boolean;
+    /** Extends the selection to the given key. */
+    extendSelection(toKey: Key): void;
+    /** Toggles whether the given key is selected. */
+    toggleSelection(key: Key): void;
+    /** Replaces the selection with only the given key. */
+    replaceSelection(key: Key): void;
+    /** Replaces the selection with the given keys. */
+    setSelectedKeys(keys: Iterable<Key>): void;
+    /** Selects all items in the collection. */
+    selectAll(): void;
+    /** Removes all keys from the selection. */
+    clearSelection(): void;
+    /** Toggles between select all and an empty selection. */
+    toggleSelectAll(): void;
+    /**
+     * Toggles, replaces, or extends selection to the given key depending
+     * on the pointer event and collection's selection mode.
+     */
+    select(key: Key, e?: PressEvent | LongPressEvent | PointerEvent): void;
+    /** Returns whether the given key can be selected. */
+    canSelectItem(key: Key): boolean;
+    /** Returns whether the given key is non-interactive, i.e. both selection and actions are disabled. */
+    isDisabled(key: Key): boolean;
+    /** Sets the selection behavior for the collection. */
+    setSelectionBehavior(selectionBehavior: SelectionBehavior): void;
+}
+interface SelectionManagerOptions {
+    allowsCellSelection?: boolean;
+}
+/**
+ * An interface for reading and updating multiple selection state.
+ */
+declare class SelectionManager implements MultipleSelectionManager {
+    constructor(collection: Collection<Node<unknown>>, state: MultipleSelectionState, options?: SelectionManagerOptions);
+    /**
+     * The type of selection that is allowed in the collection.
+     */
+    get selectionMode(): SelectionMode;
+    /**
+     * Whether the collection allows empty selection.
+     */
+    get disallowEmptySelection(): boolean;
+    /**
+     * The selection behavior for the collection.
+     */
+    get selectionBehavior(): SelectionBehavior;
+    /**
+     * Sets the selection behavior for the collection.
+     */
+    setSelectionBehavior(selectionBehavior: SelectionBehavior): void;
+    /**
+     * Whether the collection is currently focused.
+     */
+    get isFocused(): boolean;
+    /**
+     * Sets whether the collection is focused.
+     */
+    setFocused(isFocused: boolean): void;
+    /**
+     * The current focused key in the collection.
+     */
+    get focusedKey(): Key;
+    /** Whether the first or last child of the focused key should receive focus. */
+    get childFocusStrategy(): FocusStrategy;
+    /**
+     * Sets the focused key.
+     */
+    setFocusedKey(key: Key, childFocusStrategy?: FocusStrategy): void;
+    /**
+     * The currently selected keys in the collection.
+     */
+    get selectedKeys(): Set<Key>;
+    /**
+     * The raw selection value for the collection.
+     * Either 'all' for select all, or a set of keys.
+     */
+    get rawSelection(): Selection;
+    /**
+     * Returns whether a key is selected.
+     */
+    isSelected(key: Key): boolean;
+    /**
+     * Whether the selection is empty.
+     */
+    get isEmpty(): boolean;
+    /**
+     * Whether all items in the collection are selected.
+     */
+    get isSelectAll(): boolean;
+    get firstSelectedKey(): Key | null;
+    get lastSelectedKey(): Key | null;
+    get disabledKeys(): Set<Key>;
+    get disabledBehavior(): DisabledBehavior;
+    /**
+     * Extends the selection to the given key.
+     */
+    extendSelection(toKey: Key): void;
+    /**
+     * Toggles whether the given key is selected.
+     */
+    toggleSelection(key: Key): void;
+    /**
+     * Replaces the selection with only the given key.
+     */
+    replaceSelection(key: Key): void;
+    /**
+     * Replaces the selection with the given keys.
+     */
+    setSelectedKeys(keys: Iterable<Key>): void;
+    /**
+     * Selects all items in the collection.
+     */
+    selectAll(): void;
+    /**
+     * Removes all keys from the selection.
+     */
+    clearSelection(): void;
+    /**
+     * Toggles between select all and an empty selection.
+     */
+    toggleSelectAll(): void;
+    select(key: Key, e?: PressEvent | LongPressEvent | PointerEvent): void;
+    /**
+     * Returns whether the current selection is equal to the given selection.
+     */
+    isSelectionEqual(selection: Set<Key>): boolean;
+    canSelectItem(key: Key): boolean;
+    isDisabled(key: Key): boolean;
+}
+
+interface ListState<T> {
+    /** A collection of items in the list. */
+    collection: Collection<Node<T>>;
+    /** A set of items that are disabled. */
+    disabledKeys: Set<Key>;
+    /** A selection manager to read and update multiple selection state. */
+    selectionManager: SelectionManager;
+}
+
+declare const SelectContext: React.Context<ListState<any> | undefined>;
+
 /*
  * Copyright 2020 Adobe. All rights reserved.
  * This file is licensed to you under the Apache License, Version 2.0 (the "License");
@@ -1182,12 +1545,38 @@ declare function useTriggeredOverlay<P extends BaseTriggeredOverlayProps, C exte
     };
 };
 
+interface OverlayTriggerState {
+    /** Whether the overlay is currently open. */
+    readonly isOpen: boolean;
+    /** Sets whether the overlay is open. */
+    setOpen(isOpen: boolean): void;
+    /** Opens the overlay. */
+    open(): void;
+    /** Closes the overlay. */
+    close(): void;
+    /** Toggles the overlay's visibility. */
+    toggle(): void;
+}
+
+interface TriggeredOverlayContextValue {
+    triggerRef: React.RefObject<HTMLElement>;
+    state: OverlayTriggerState;
+    autoFocus?: boolean | FocusStrategy;
+    placement?: Placement;
+    overlayMatchTriggerWidth?: boolean;
+    overlayMinTriggerWidth?: boolean;
+    overlayWidth?: number;
+}
+declare const TriggeredOverlayContext: React.Context<TriggeredOverlayContextValue | undefined>;
+
+declare type InitFunc<T> = ($props: Record<string, any>, $state: $State) => T;
 interface $State {
     [key: string]: any;
+    registerInitFunc: (path: string, f: InitFunc<any>) => any;
 }
 interface $StateSpec<T> {
     path: string;
-    initFunc?: ($props: Record<string, any>, $state: $State) => T;
+    initFunc?: InitFunc<T>;
     initVal?: T;
     type: "private" | "readonly" | "writable";
     valueProp?: string;
@@ -1204,4 +1593,4 @@ declare function generateStateOnChangeProp($state: $State, stateName: string, da
  */
 declare function generateStateValueProp($state: $State, path: (string | number)[]): any;
 
-export { BaseButtonProps, BaseMenuButtonProps, BaseMenuGroupProps, BaseMenuItemProps, BaseMenuProps, BaseSelectOptionGroupProps, BaseSelectOptionProps, BaseSelectProps, BaseTextInputProps, BaseTriggeredOverlayProps, ButtonRef, CheckboxProps, CheckboxRef, CheckboxRefValue, DropdownMenu, Flex, HTMLElementRefOf, HtmlAnchorOnlyProps, HtmlButtonOnlyProps, MenuButtonRef, MenuButtonRefValue, MenuRef, MenuRefValue, MultiChoiceArg, PlasmicIcon, PlasmicImg, PlasmicLink, PlasmicRootProvider, PlasmicSlot, SelectOptionRef, SelectRef, SelectRefValue, SingleBooleanChoiceArg, SingleChoiceArg, Stack, StrictProps, SwitchProps, SwitchRef, SwitchRefValue, TextInputRef, TextInputRefValue, Trans, TriggeredOverlayConfig, TriggeredOverlayRef, classNames, createPlasmicElementProxy, createUseScreenVariants, deriveRenderOpts, ensureGlobalVariants, genTranslatableString, generateStateOnChangeProp, generateStateValueProp, getDataProps, hasVariant, makeFragment, omit, pick, renderPlasmicSlot, setPlumeStrictMode, useButton, useCheckbox, useVanillaDollarState as useDollarState, useIsSSR, useMenu, useMenuButton, useMenuGroup, useMenuItem, useSelect, useSelectOption, useSelectOptionGroup, useSwitch, useTextInput, useTrigger, useTriggeredOverlay, wrapWithClassName };
+export { BaseButtonProps, BaseMenuButtonProps, BaseMenuGroupProps, BaseMenuItemProps, BaseMenuProps, BaseSelectOptionGroupProps, BaseSelectOptionProps, BaseSelectProps, BaseTextInputProps, BaseTriggeredOverlayProps, ButtonRef, CheckboxProps, CheckboxRef, CheckboxRefValue, DropdownMenu, Flex, HTMLElementRefOf, HtmlAnchorOnlyProps, HtmlButtonOnlyProps, MenuButtonRef, MenuButtonRefValue, MenuRef, MenuRefValue, MultiChoiceArg, PlasmicHead, PlasmicIcon, PlasmicImg, PlasmicLink, PlasmicRootProvider, PlasmicSlot, SelectContext, SelectOptionRef, SelectRef, SelectRefValue, SingleBooleanChoiceArg, SingleChoiceArg, Stack, StrictProps, SwitchProps, SwitchRef, SwitchRefValue, TextInputRef, TextInputRefValue, Trans, TriggeredOverlayConfig, TriggeredOverlayContext, TriggeredOverlayRef, classNames, createPlasmicElementProxy, createUseScreenVariants, deriveRenderOpts, ensureGlobalVariants, genTranslatableString, generateStateOnChangeProp, generateStateValueProp, getDataProps, hasVariant, makeFragment, omit, pick, plasmicHeadMeta, renderPlasmicSlot, setPlumeStrictMode, useButton, useCheckbox, useVanillaDollarState as useDollarState, useIsSSR, useMenu, useMenuButton, useMenuGroup, useMenuItem, useSelect, useSelectOption, useSelectOptionGroup, useSwitch, useTextInput, useTrigger, useTriggeredOverlay, wrapWithClassName };

package/dist/index-common.d.ts

@@ -3,6 +3,7 @@ export { omit, pick } from "./common";
 export { HTMLElementRefOf, StrictProps } from "./react-utils";
 export { createPlasmicElementProxy, deriveRenderOpts, Flex, hasVariant, makeFragment, MultiChoiceArg, SingleBooleanChoiceArg, SingleChoiceArg, wrapWithClassName, } from "./render/elements";
 export { ensureGlobalVariants } from "./render/global-variants";
+export { PlasmicHead, plasmicHeadMeta } from "./render/PlasmicHead";
 export { PlasmicIcon } from "./render/PlasmicIcon";
 export { PlasmicImg } from "./render/PlasmicImg";
 export { PlasmicLink } from "./render/PlasmicLink";
@@ -10,5 +11,5 @@ export { PlasmicSlot, renderPlasmicSlot } from "./render/PlasmicSlot";
 export { createUseScreenVariants } from "./render/screen-variants";
 export { PlasmicRootProvider, useIsSSR } from "./render/ssr";
 export { Stack } from "./render/Stack";
+export { genTranslatableString, Trans } from "./render/translation";
 export { useTrigger } from "./render/triggers";
-export { Trans, genTranslatableString } from "./render/translation";