@plasmicapp/react-web 0.2.347 → 0.2.349

package/dist/all.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="react" />
 import * as React$1 from 'react';
-import React__default, { AriaAttributes, DOMAttributes as DOMAttributes$1, AriaRole, CSSProperties as CSSProperties$1, FocusEvent, KeyboardEvent as KeyboardEvent$2, SyntheticEvent, ReactNode, ReactElement } from 'react';
+import React__default, { AriaAttributes, DOMAttributes as DOMAttributes$1, AriaRole, CSSProperties as CSSProperties$1, ReactNode, ReactElement, FocusEvent, KeyboardEvent as KeyboardEvent$1, SyntheticEvent } from 'react';
 
 interface PlasmicPageGuardProps {
     appId: string;
@@ -12826,269 +12826,6 @@ declare const Stack: (<T extends keyof JSX.IntrinsicElements = "div">(props: {
 
 
 
-interface AriaLabelingProps$1 {
-  /**
-   * Defines a string value that labels the current element.
-   */
-  'aria-label'?: string,
-
-  /**
-   * Identifies the element (or elements) that labels the current element.
-   */
-  'aria-labelledby'?: string,
-
-  /**
-   * Identifies the element (or elements) that describes the object.
-   */
-  'aria-describedby'?: string,
-
-  /**
-   * Identifies the element (or elements) that provide a detailed, extended description for the object.
-   */
-  'aria-details'?: string
-}
-
-// A set of common DOM props that are allowed on any component
-// Ensure this is synced with DOMPropNames in filterDOMProps
-interface DOMProps$1 {
-  /**
-   * The element's unique identifier. See [MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/id).
-   */
-  id?: string
-}
-
-interface FocusableDOMProps$1 extends DOMProps$1 {
-  /**
-   * Whether to exclude the element from the sequential tab order. If true,
-   * the element will not be focusable via the keyboard by tabbing. This should
-   * be avoided except in rare scenarios where an alternative means of accessing
-   * the element or its functionality via the keyboard is available.
-   */
-  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$1 | undefined,
-  className?: string | undefined
-}
-
-/*
- * 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.
- */
-
-
-
-interface InputBase$1 {
-  /** Whether the input is disabled. */
-  isDisabled?: boolean,
-  /** Whether the input can be selected but not changed by the user. */
-  isReadOnly?: 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.
- */
-
-
-
-type FocusStrategy$1 = 'first' | 'last';
-
-/*
- * 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$1<T extends SyntheticEvent> = T & {
-  /**
-   * Use continuePropagation.
-   * @deprecated */
-  stopPropagation(): void,
-  continuePropagation(): void
-}
-
-type KeyboardEvent$1 = BaseEvent$1<KeyboardEvent$2<any>>;
-
-interface KeyboardEvents$1 {
-  /** Handler that is called when a key is pressed. */
-  onKeyDown?: (e: KeyboardEvent$1) => void,
-  /** Handler that is called when a key is released. */
-  onKeyUp?: (e: KeyboardEvent$1) => void
-}
-
-interface FocusEvents$1<Target = Element> {
-  /** Handler that is called when the element receives focus. */
-  onFocus?: (e: FocusEvent<Target>) => void,
-  /** Handler that is called when the element loses focus. */
-  onBlur?: (e: FocusEvent<Target>) => void,
-  /** Handler that is called when the element's focus status changes. */
-  onFocusChange?: (isFocused: boolean) => void
-}
-
-interface FocusableProps$1<Target = Element> extends FocusEvents$1<Target>, KeyboardEvents$1 {
-  /** Whether the element should receive focus on render. */
-  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;
-};
-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$1.HTMLAttributes<HTMLElement>];
-
-declare const classNames: any;
-
-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]];
-}>;
-type VariantDefTuple<V> = DictTuples<VariantArgsChoices<V>>;
-type DistributeTuple<T> = T extends [infer T1, infer T2] ? {
-    group: T1;
-    variant: T2;
-} : never;
-type VariantDef<V> = DistributeTuple<VariantDefTuple<V>>;
-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$1.ReactElement | null;
-    internalVariantProps: (keyof V)[];
-    internalArgProps: (keyof A)[];
-};
-type AnyPlasmicClass = PlasmicClass<any, any, any>;
-type PlasmicClassVariants<C extends AnyPlasmicClass> = C extends PlasmicClass<infer V, any, any> ? V : unknown;
-type PlasmicClassArgs<C extends AnyPlasmicClass> = C extends PlasmicClass<any, infer A, any> ? A : unknown;
-type PlasmicClassOverrides<C extends AnyPlasmicClass> = C extends PlasmicClass<any, any, infer O> ? O : unknown;
-
-interface PlumeCommonProps {
-    showStartIcon?: boolean;
-    showEndIcon?: boolean;
-    startIcon?: React$1.ReactNode;
-    endIcon?: React$1.ReactNode;
-    children?: React$1.ReactNode;
-    isDisabled?: boolean;
-}
-interface HtmlButtonProps extends Omit<React$1.ComponentProps<"button">, "ref" | "disabled"> {
-}
-interface HtmlAnchorProps extends Omit<React$1.ComponentProps<"a">, "ref" | "href" | "target"> {
-}
-interface PlumeActualButtonProps {
-    submitsForm?: boolean;
-}
-interface PlumeAnchorProps {
-    link?: string;
-    target?: React$1.ComponentProps<"a">["target"] | boolean;
-}
-type PlumeButtonProps = PlumeCommonProps & PlumeActualButtonProps & PlumeAnchorProps;
-type BaseButtonProps = PlumeButtonProps & HtmlButtonProps & HtmlAnchorProps;
-type AllButtonProps = PlumeCommonProps & PlumeActualButtonProps & HtmlButtonProps;
-type AllAnchorProps = PlumeCommonProps & PlumeAnchorProps & HtmlAnchorProps;
-type HtmlAnchorOnlyProps = Exclude<keyof AllAnchorProps, keyof AllButtonProps>;
-type HtmlButtonOnlyProps = Exclude<keyof AllButtonProps, keyof AllAnchorProps>;
-type ButtonRef = React$1.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 PlumeButtonProps, 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");
- * 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.
- */
-
-
-
 interface AriaLabelingProps {
   /**
    * Defines a string value that labels the current element.
@@ -13145,6 +12882,18 @@ interface InputDOMProps {
   name?: string
 }
 
+/** 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$1 | undefined,
+  className?: string | undefined
+}
+
 /*
  * Copyright 2020 Adobe. All rights reserved.
  * This file is licensed to you under the Apache License, Version 2.0 (the "License");
@@ -13326,7 +13075,7 @@ type BaseEvent<T extends SyntheticEvent> = T & {
   continuePropagation(): void
 }
 
-type KeyboardEvent = BaseEvent<KeyboardEvent$2<any>>;
+type KeyboardEvent = BaseEvent<KeyboardEvent$1<any>>;
 
 type PointerType = 'mouse' | 'pen' | 'touch' | 'keyboard' | 'virtual';
 
@@ -13393,6 +13142,118 @@ interface FocusableProps<Target = Element> extends FocusEvents<Target>, Keyboard
 
 type Key = string | number;
 
+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;
+};
+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$1.HTMLAttributes<HTMLElement>];
+
+declare const classNames: any;
+
+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]];
+}>;
+type VariantDefTuple<V> = DictTuples<VariantArgsChoices<V>>;
+type DistributeTuple<T> = T extends [infer T1, infer T2] ? {
+    group: T1;
+    variant: T2;
+} : never;
+type VariantDef<V> = DistributeTuple<VariantDefTuple<V>>;
+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$1.ReactElement | null;
+    internalVariantProps: (keyof V)[];
+    internalArgProps: (keyof A)[];
+};
+type AnyPlasmicClass = PlasmicClass<any, any, any>;
+type PlasmicClassVariants<C extends AnyPlasmicClass> = C extends PlasmicClass<infer V, any, any> ? V : unknown;
+type PlasmicClassArgs<C extends AnyPlasmicClass> = C extends PlasmicClass<any, infer A, any> ? A : unknown;
+type PlasmicClassOverrides<C extends AnyPlasmicClass> = C extends PlasmicClass<any, any, infer O> ? O : unknown;
+
+interface PlumeCommonProps {
+    showStartIcon?: boolean;
+    showEndIcon?: boolean;
+    startIcon?: React$1.ReactNode;
+    endIcon?: React$1.ReactNode;
+    children?: React$1.ReactNode;
+    isDisabled?: boolean;
+}
+interface HtmlButtonProps extends Omit<React$1.ComponentProps<"button">, "ref" | "disabled"> {
+}
+interface HtmlAnchorProps extends Omit<React$1.ComponentProps<"a">, "ref" | "href" | "target"> {
+}
+interface PlumeActualButtonProps {
+    submitsForm?: boolean;
+}
+interface PlumeAnchorProps {
+    link?: string;
+    target?: React$1.ComponentProps<"a">["target"] | boolean;
+}
+type PlumeButtonProps = PlumeCommonProps & PlumeActualButtonProps & PlumeAnchorProps;
+type BaseButtonProps = PlumeButtonProps & HtmlButtonProps & HtmlAnchorProps;
+type AllButtonProps = PlumeCommonProps & PlumeActualButtonProps & HtmlButtonProps;
+type AllAnchorProps = PlumeCommonProps & PlumeAnchorProps & HtmlAnchorProps;
+type HtmlAnchorOnlyProps = Exclude<keyof AllAnchorProps, keyof AllButtonProps>;
+type HtmlButtonOnlyProps = Exclude<keyof AllButtonProps, keyof AllAnchorProps>;
+type ButtonRef = React$1.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 PlumeButtonProps, 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");
@@ -13496,7 +13357,7 @@ declare function useCheckbox<P extends CheckboxProps, C extends AnyPlasmicClass>
     state: CheckboxState;
 };
 
-interface BaseMenuProps extends DOMProps$1, AriaLabelingProps$1, StyleProps {
+interface BaseMenuProps extends DOMProps, AriaLabelingProps, StyleProps {
     /**
      * List of `Menu.Item`s or `Menu.Group`s that make up the menu
      */
@@ -13738,7 +13599,7 @@ interface DropdownMenuProps {
 }
 declare function DropdownMenu(props: DropdownMenuProps): React$1.JSX.Element;
 
-interface BaseMenuButtonProps extends DOMProps$1, FocusableProps$1, StyleProps, Pick<React$1.ComponentProps<"button">, "title"> {
+interface BaseMenuButtonProps extends DOMProps, FocusableProps, StyleProps, Pick<React$1.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.
@@ -13804,7 +13665,7 @@ declare function useMenuButton<P extends BaseMenuButtonProps, C extends AnyPlasm
     state: MenuButtonState;
 };
 
-interface BaseSelectProps extends DOMProps$1, AriaLabelingProps$1, FocusableDOMProps$1, InputBase$1, FocusableProps$1, StyleProps {
+interface BaseSelectProps extends DOMProps, AriaLabelingProps, FocusableDOMProps, InputBase, FocusableProps, StyleProps {
     /**
      * Key of the currently selected value
      */
@@ -14268,7 +14129,7 @@ declare function useTextInput<P extends PlumeTextInputProps, C extends AnyPlasmi
     };
 };
 
-interface BaseTriggeredOverlayProps extends StyleProps, DOMProps$1 {
+interface BaseTriggeredOverlayProps extends StyleProps, DOMProps {
     children?: React$1.ReactNode;
 }
 interface TriggeredOverlayConfig<C extends AnyPlasmicClass> {
@@ -14304,7 +14165,7 @@ interface OverlayTriggerState {
 interface TriggeredOverlayContextValue {
     triggerRef: React$1.RefObject<HTMLElement>;
     state: OverlayTriggerState;
-    autoFocus?: boolean | FocusStrategy$1;
+    autoFocus?: boolean | FocusStrategy;
     placement?: Placement;
     overlayMatchTriggerWidth?: boolean;
     overlayMinTriggerWidth?: boolean;

package/dist/index.cjs.js

@@ -1741,7 +1741,7 @@ function PlasmicRootProvider(props) {
     return (React__namespace.createElement(MaybeWrap, { cond: !disableLoadingBoundary && reactMajorVersion >= 18, wrapper: function (children) { return (React__namespace.createElement(host.DataProvider, { name: "plasmicInternalEnableLoadingBoundary", hidden: true, data: true },
             React__namespace.createElement(React__namespace.Suspense, { fallback: suspenseFallback !== null && suspenseFallback !== void 0 ? suspenseFallback : "Loading..." }, children))); } },
         React__namespace.createElement(PlasmicRootContext.Provider, { value: context },
-            React__namespace.createElement(ssr.SSRProvider, null,
+            React__namespace.createElement(MaybeWrap, { cond: reactMajorVersion < 18, wrapper: function (children) { return React__namespace.createElement(ssr.SSRProvider, null, children); } },
                 React__namespace.createElement(dataSourcesContext.PlasmicDataSourceContextProvider, { value: dataSourceContextValue },
                     React__namespace.createElement(PlasmicTranslatorContext.Provider, { value: (_a = props.i18n) !== null && _a !== void 0 ? _a : props.translator },
                         React__namespace.createElement(PlasmicHeadContext.Provider, { value: props.Head },