@plasmicapp/react-web 0.2.104 → 0.2.107

package/dist/all.d.ts

@@ -1,5 +1,5 @@
 import * as React from 'react';
-import React__default, { AriaAttributes, DOMAttributes as DOMAttributes$1, AriaRole, CSSProperties, 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;
@@ -386,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 & {
@@ -396,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,
@@ -1055,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");
@@ -1185,7 +1537,7 @@ interface TriggeredOverlayConfig<C extends AnyPlasmicClass> {
     contentContainer: keyof PlasmicClassOverrides<C>;
 }
 declare type TriggeredOverlayRef = React.Ref<HTMLElement>;
-declare function useTriggeredOverlay<P extends BaseTriggeredOverlayProps, C extends AnyPlasmicClass>(plasmicClass: C, props: P, config: TriggeredOverlayConfig<C>, outerRef?: TriggeredOverlayRef): {
+declare function useTriggeredOverlay<P extends BaseTriggeredOverlayProps, C extends AnyPlasmicClass>(plasmicClass: C, props: P, config: TriggeredOverlayConfig<C>, outerRef?: TriggeredOverlayRef, isDismissable?: boolean): {
     plasmicProps: {
         variants: PlasmicClassVariants<C>;
         args: PlasmicClassArgs<C>;
@@ -1193,6 +1545,30 @@ 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;
@@ -1217,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";

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

@@ -1,3 +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";

package/dist/plume/triggered-overlay/index.d.ts

@@ -1 +1,2 @@
 export { BaseTriggeredOverlayProps, TriggeredOverlayConfig, TriggeredOverlayRef, useTriggeredOverlay, } from "./triggered-overlay";
+export { TriggeredOverlayContext } from "./context";

package/dist/plume/triggered-overlay/triggered-overlay.d.ts

@@ -15,7 +15,7 @@ export interface TriggeredOverlayConfig<C extends AnyPlasmicClass> {
     contentContainer: keyof PlasmicClassOverrides<C>;
 }
 export declare type TriggeredOverlayRef = React.Ref<HTMLElement>;
-export declare function useTriggeredOverlay<P extends BaseTriggeredOverlayProps, C extends AnyPlasmicClass>(plasmicClass: C, props: P, config: TriggeredOverlayConfig<C>, outerRef?: TriggeredOverlayRef): {
+export declare function useTriggeredOverlay<P extends BaseTriggeredOverlayProps, C extends AnyPlasmicClass>(plasmicClass: C, props: P, config: TriggeredOverlayConfig<C>, outerRef?: TriggeredOverlayRef, isDismissable?: boolean): {
     plasmicProps: {
         variants: PlasmicClassVariants<C>;
         args: PlasmicClassArgs<C>;

package/dist/react-web.cjs.development.js

@@ -811,6 +811,83 @@ function ensureGlobalVariants(globalVariantValues) {
   return globalVariantValues;
 }
 
+var PlasmicHeadContext = /*#__PURE__*/React.createContext(undefined);
+function PlasmicHead(props) {
+  var Head = React.useContext(PlasmicHeadContext);
+
+  if (!Head) {
+    console.warn("Plasmic: Head meta tags are being ignored. To make them work, pass a Head component into PlasmicRootProvider."); // TODO: Link to doc about Head.
+
+    return null;
+  }
+
+  return React.createElement(Head, null, props.image ? React.createElement(React.Fragment, null, React.createElement("meta", {
+    name: "twitter:card",
+    content: "summary_large_image"
+  }), React.createElement("meta", {
+    key: "og:image",
+    property: "og:image",
+    content: props.image
+  }), React.createElement("meta", {
+    key: "twitter:image",
+    name: "twitter:image",
+    content: props.image
+  })) : React.createElement("meta", {
+    name: "twitter:card",
+    content: "summary"
+  }), props.title && React.createElement(React.Fragment, null, React.createElement("title", {
+    key: "title"
+  }, props.title), React.createElement("meta", {
+    key: "og:title",
+    property: "og:title",
+    content: props.title
+  }), React.createElement("meta", {
+    key: "twitter:title",
+    property: "twitter:title",
+    content: props.title
+  })), props.description && React.createElement(React.Fragment, null, React.createElement("meta", {
+    key: "description",
+    name: "description",
+    content: props.description
+  }), React.createElement("meta", {
+    key: "og:description",
+    property: "og:description",
+    content: props.description
+  }), React.createElement("meta", {
+    key: "twitter:description",
+    name: "twitter:description",
+    content: props.description
+  })), props.canonical && React.createElement("link", {
+    ref: "canonical",
+    href: props.canonical
+  }));
+}
+var plasmicHeadMeta = {
+  name: "hostless-plasmic-head",
+  displayName: "Head",
+  description: "Used to add page metadata to HEAD tag",
+  importName: "PlasmicHead",
+  importPath: "@plasmicapp/react-web",
+  props: {
+    title: {
+      type: "string",
+      displayName: "Title"
+    },
+    description: {
+      type: "string",
+      displayName: "Description"
+    },
+    image: {
+      type: "imageUrl",
+      displayName: "Image"
+    },
+    canonical: {
+      type: "string",
+      displayName: "Canonical URL"
+    }
+  }
+};
+
 function PlasmicIcon(props) {
   var PlasmicIconType = props.PlasmicIconType,
       rest = _objectWithoutPropertiesLoose(props, ["PlasmicIconType"]);
@@ -1464,7 +1541,9 @@ function PlasmicRootProvider(props) {
     value: context
   }, React.createElement(ssr.SSRProvider, null, React.createElement(PlasmicTranslatorContext.Provider, {
     value: props.translator
-  }, children)));
+  }, React.createElement(PlasmicHeadContext.Provider, {
+    value: props.Head
+  }, children))));
 }
 var useIsSSR = ssr.useIsSSR;
 function useHasPlasmicRoot() {
@@ -3001,13 +3080,17 @@ function useTextInput(plasmicClass, props, config, ref) {
   };
 }
 
-function useTriggeredOverlay(plasmicClass, props, config, outerRef) {
+function useTriggeredOverlay(plasmicClass, props, config, outerRef, isDismissable) {
   var _extends2, _overrides;
 
   if (outerRef === void 0) {
     outerRef = null;
   }
 
+  if (isDismissable === void 0) {
+    isDismissable = true;
+  }
+
   var overlayRef = React.useRef(null);
   var onOverlayRef = mergeRefs(overlayRef, outerRef);
   var context = React.useContext(TriggeredOverlayContext);
@@ -3045,7 +3128,7 @@ function useTriggeredOverlay(plasmicClass, props, config, outerRef) {
   var _useOverlay = overlays.useOverlay({
     isOpen: state.isOpen,
     onClose: state.close,
-    isDismissable: true,
+    isDismissable: isDismissable,
     shouldCloseOnBlur: true
   }, overlayRef),
       overlayAriaProps = _useOverlay.overlayProps;
@@ -3595,13 +3678,16 @@ function fillUninitializedStateValues(specs, props, stateValues, states) {
 }
 
 exports.DropdownMenu = DropdownMenu;
+exports.PlasmicHead = PlasmicHead;
 exports.PlasmicIcon = PlasmicIcon;
 exports.PlasmicImg = PlasmicImg;
 exports.PlasmicLink = PlasmicLink;
 exports.PlasmicRootProvider = PlasmicRootProvider;
 exports.PlasmicSlot = PlasmicSlot;
+exports.SelectContext = SelectContext;
 exports.Stack = Stack;
 exports.Trans = Trans;
+exports.TriggeredOverlayContext = TriggeredOverlayContext;
 exports.classNames = classNames;
 exports.createPlasmicElementProxy = createPlasmicElementProxy;
 exports.createUseScreenVariants = createUseScreenVariants;
@@ -3615,6 +3701,7 @@ exports.hasVariant = hasVariant;
 exports.makeFragment = makeFragment;
 exports.omit = omit;
 exports.pick = pick;
+exports.plasmicHeadMeta = plasmicHeadMeta;
 exports.renderPlasmicSlot = renderPlasmicSlot;
 exports.setPlumeStrictMode = setPlumeStrictMode;
 exports.useButton = useButton;