@plasmicapp/react-web 0.2.301 → 0.2.302

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, Key, ReactNode, ReactElement, FocusEvent, KeyboardEvent as KeyboardEvent$1, SyntheticEvent } from 'react';
+import React__default, { AriaAttributes, DOMAttributes as DOMAttributes$1, AriaRole, CSSProperties as CSSProperties$1, Key, ReactNode, ReactElement, FocusEvent, KeyboardEvent as KeyboardEvent$3, SyntheticEvent } from 'react';
 
 // LICENSE is MIT
 //
@@ -11472,6 +11472,10 @@ interface PropTypeBase<P> {
      * (This behavior only applies to canvas)
      */
     forceRemount?: boolean;
+    /**
+     * If true, the prop can't be overriden in different variants.
+     */
+    invariantable?: boolean;
 }
 interface Defaultable<P, T> {
     /**
@@ -12474,7 +12478,7 @@ declare const Stack: (<T extends keyof JSX.IntrinsicElements = "div">(props: {
 
 
 
-interface AriaLabelingProps {
+interface AriaLabelingProps$2 {
   /**
    * Defines a string value that labels the current element.
    */
@@ -12496,24 +12500,16 @@ interface AriaLabelingProps {
   'aria-details'?: string
 }
 
-interface AriaValidationProps {
-  // https://www.w3.org/TR/wai-aria-1.2/#aria-errormessage
-  /**
-   * Identifies the element that provides an error message for the object.
-   */
-  'aria-errormessage'?: string
-}
-
 // A set of common DOM props that are allowed on any component
 // Ensure this is synced with DOMPropNames in filterDOMProps
-interface DOMProps {
+interface DOMProps$2 {
   /**
    * The element's unique identifier. See [MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/id).
    */
   id?: string
 }
 
-interface FocusableDOMProps extends DOMProps {
+interface FocusableDOMProps$2 extends DOMProps$2 {
   /**
    * 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
@@ -12523,13 +12519,6 @@ interface FocusableDOMProps extends DOMProps {
   excludeFromTabOrder?: boolean
 }
 
-interface InputDOMProps {
-  /**
-   * The name of the input element, used when submitting an HTML form. See [MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#htmlattrdefname).
-   */
-  name?: string
-}
-
 /** Any focusable element, including both HTML and SVG elements. */
 interface FocusableElement extends Element, HTMLOrSVGElement {}
 
@@ -12556,18 +12545,7 @@ interface DOMAttributes<T = FocusableElement> extends AriaAttributes, DOMAttribu
 
 
 
-type ValidationState = 'valid' | 'invalid';
-
-interface Validation {
-  /** Whether user input is required on the input before form submission. */
-  isRequired?: boolean,
-  /** Whether the input value is invalid. */
-  isInvalid?: boolean,
-  /** @deprecated Use `isInvalid` instead. */
-  validationState?: ValidationState
-}
-
-interface InputBase {
+interface InputBase$2 {
   /** Whether the input is disabled. */
   isDisabled?: boolean,
   /** Whether the input can be selected but not changed by the user. */
@@ -12699,7 +12677,7 @@ interface Node<T> {
 
 // 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 & {
+type BaseEvent$2<T extends SyntheticEvent> = T & {
   /**
    * Use continuePropagation.
    * @deprecated */
@@ -12707,7 +12685,7 @@ type BaseEvent<T extends SyntheticEvent> = T & {
   continuePropagation(): void
 }
 
-type KeyboardEvent = BaseEvent<KeyboardEvent$1<any>>;
+type KeyboardEvent$2 = BaseEvent$2<KeyboardEvent$3<any>>;
 
 type PointerType = 'mouse' | 'pen' | 'touch' | 'keyboard' | 'virtual';
 
@@ -12739,14 +12717,14 @@ interface LongPressEvent extends Omit<PressEvent, 'type' | 'continuePropagation'
   type: 'longpressstart' | 'longpressend' | 'longpress'
 }
 
-interface KeyboardEvents {
+interface KeyboardEvents$2 {
   /** Handler that is called when a key is pressed. */
-  onKeyDown?: (e: KeyboardEvent) => void,
+  onKeyDown?: (e: KeyboardEvent$2) => void,
   /** Handler that is called when a key is released. */
-  onKeyUp?: (e: KeyboardEvent) => void
+  onKeyUp?: (e: KeyboardEvent$2) => void
 }
 
-interface FocusEvents<Target = Element> {
+interface FocusEvents$2<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. */
@@ -12755,7 +12733,7 @@ interface FocusEvents<Target = Element> {
   onFocusChange?: (isFocused: boolean) => void
 }
 
-interface FocusableProps<Target = Element> extends FocusEvents<Target>, KeyboardEvents {
+interface FocusableProps$2<Target = Element> extends FocusEvents$2<Target>, KeyboardEvents$2 {
   /** Whether the element should receive focus on render. */
   autoFocus?: boolean
 }
@@ -12886,7 +12864,172 @@ declare function useButton<P extends PlumeButtonProps, C extends AnyPlasmicClass
 
 
 
-interface ToggleProps extends InputBase, Validation, FocusableProps {
+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
+}
+
+interface AriaValidationProps {
+  // https://www.w3.org/TR/wai-aria-1.2/#aria-errormessage
+  /**
+   * Identifies the element that provides an error message for the object.
+   */
+  'aria-errormessage'?: 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
+}
+
+interface InputDOMProps$1 {
+  /**
+   * The name of the input element, used when submitting an HTML form. See [MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#htmlattrdefname).
+   */
+  name?: string
+}
+
+/*
+ * 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 ValidationState = 'valid' | 'invalid';
+
+type ValidationError = string | string[];
+
+interface Validation<T> {
+  /** Whether user input is required on the input before form submission. */
+  isRequired?: boolean,
+  /** Whether the input value is invalid. */
+  isInvalid?: boolean,
+  /** @deprecated Use `isInvalid` instead. */
+  validationState?: ValidationState,
+  /**
+   * Whether to use native HTML form validation to prevent form submission
+   * when the value is missing or invalid, or mark the field as required
+   * or invalid via ARIA.
+   * @default 'aria'
+   */
+  validationBehavior?: 'aria' | 'native',
+  /**
+   * A function that returns an error message if a given value is invalid.
+   * Validation errors are displayed to the user when the form is submitted
+   * if `validationBehavior="native"`. For realtime validation, use the `isInvalid`
+   * prop instead.
+   */
+  validate?: (value: T) => ValidationError | true | null | undefined
+}
+
+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.
+ */
+
+
+
+// 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$3<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
+}
+
+/*
+ * 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 ToggleProps extends InputBase$1, Validation<boolean>, FocusableProps$1 {
   /**
    * The label for the element.
    */
@@ -12909,7 +13052,7 @@ interface ToggleProps extends InputBase, Validation, FocusableProps {
   value?: string
 }
 
-interface AriaToggleProps extends ToggleProps, FocusableDOMProps, AriaLabelingProps, AriaValidationProps, InputDOMProps {
+interface AriaToggleProps extends ToggleProps, FocusableDOMProps$1, AriaLabelingProps$1, AriaValidationProps, InputDOMProps$1 {
   /**
    * Identifies the element (or elements) whose contents or presence are controlled by the current element.
    */
@@ -12975,7 +13118,7 @@ declare function useCheckbox<P extends CheckboxProps, C extends AnyPlasmicClass>
     state: CheckboxState;
 };
 
-interface BaseMenuProps extends DOMProps, AriaLabelingProps, StyleProps {
+interface BaseMenuProps extends DOMProps$2, AriaLabelingProps$2, StyleProps {
     /**
      * List of `Menu.Item`s or `Menu.Group`s that make up the menu
      */
@@ -13217,7 +13360,7 @@ interface DropdownMenuProps {
 }
 declare function DropdownMenu(props: DropdownMenuProps): React$1.JSX.Element;
 
-interface BaseMenuButtonProps extends DOMProps, FocusableProps, StyleProps, Pick<React$1.ComponentProps<"button">, "title"> {
+interface BaseMenuButtonProps extends DOMProps$2, FocusableProps$2, 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.
@@ -13283,7 +13426,7 @@ declare function useMenuButton<P extends BaseMenuButtonProps, C extends AnyPlasm
     state: MenuButtonState;
 };
 
-interface BaseSelectProps extends DOMProps, AriaLabelingProps, FocusableDOMProps, InputBase, FocusableProps, StyleProps {
+interface BaseSelectProps extends DOMProps$2, AriaLabelingProps$2, FocusableDOMProps$2, InputBase$2, FocusableProps$2, StyleProps {
     /**
      * Key of the currently selected value
      */
@@ -13640,6 +13783,136 @@ declare const SelectContext: React$1.Context<ListState<any> | undefined>;
 
 
 
+interface AriaLabelingProps {
+  /**
+   * 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 {
+  /**
+   * The element's unique identifier. See [MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/id).
+   */
+  id?: string
+}
+
+interface FocusableDOMProps extends DOMProps {
+  /**
+   * 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
+}
+
+interface InputDOMProps {
+  /**
+   * The name of the input element, used when submitting an HTML form. See [MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#htmlattrdefname).
+   */
+  name?: string
+}
+
+/*
+ * 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 {
+  /** 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.
+ */
+
+
+
+// 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 & {
+  /**
+   * Use continuePropagation.
+   * @deprecated */
+  stopPropagation(): void,
+  continuePropagation(): void
+}
+
+type KeyboardEvent = BaseEvent<KeyboardEvent$3<any>>;
+
+interface KeyboardEvents {
+  /** Handler that is called when a key is pressed. */
+  onKeyDown?: (e: KeyboardEvent) => void,
+  /** Handler that is called when a key is released. */
+  onKeyUp?: (e: KeyboardEvent) => void
+}
+
+interface FocusEvents<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<Target = Element> extends FocusEvents<Target>, KeyboardEvents {
+  /** Whether the element should receive focus on render. */
+  autoFocus?: 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.
+ */
+
+
+
 interface SwitchBase extends InputBase, FocusableProps {
   /**
    * The content to render as the Switch's label.
@@ -13744,7 +14017,7 @@ declare function useTextInput<P extends PlumeTextInputProps, C extends AnyPlasmi
     };
 };
 
-interface BaseTriggeredOverlayProps extends StyleProps, DOMProps {
+interface BaseTriggeredOverlayProps extends StyleProps, DOMProps$2 {
     children?: React$1.ReactNode;
 }
 interface TriggeredOverlayConfig<C extends AnyPlasmicClass> {

package/dist/index.cjs.js

@@ -1591,6 +1591,9 @@ function maybeAsString(node) {
     if (typeof node === "string") {
         return node;
     }
+    if (typeof node === "number") {
+        return "".concat(node);
+    }
     if (Array.isArray(node) && node.length === 1 && typeof node[0] === "string") {
         return node[0];
     }