@plasmicapp/react-web 1.0.15 → 1.0.17

package/dist/all.d.ts

@@ -1,6 +1,8 @@
 /// <reference types="react" />
 import * as React$1 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';
+import { AriaCheckboxProps } from '@react-types/checkbox';
+import { AriaSwitchProps } from '@react-types/switch';
 
 declare global {
     interface Window {
@@ -13967,43 +13969,58 @@ declare function Trans({ transKey, children }: TransProps): React__default.React
 
 
 
+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.
+ */
+
+
+
 interface AriaLabelingProps {
   /**
    * Defines a string value that labels the current element.
    */
-  'aria-label'?: string,
+  'aria-label'?: string;
 
   /**
    * Identifies the element (or elements) that labels the current element.
    */
-  'aria-labelledby'?: string,
+  '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
-}
+  'aria-describedby'?: 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.
+   * Identifies the element (or elements) that provide a detailed, extended description for the
+   * object.
    */
-  'aria-errormessage'?: string
+  '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).
+   * The element's unique identifier. See
+   * [MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/id).
    */
-  id?: string
+  id?: string;
 }
 
 interface FocusableDOMProps extends DOMProps {
@@ -14013,14 +14030,7 @@ interface FocusableDOMProps extends DOMProps {
    * 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
+  excludeFromTabOrder?: boolean;
 }
 
 /** Any focusable element, including both HTML and SVG elements. */
@@ -14028,59 +14038,11 @@ 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.
- */
-
-
-
-type ValidationState = 'valid' | 'invalid';
-
-type ValidationError = string | string[];
-
-interface Validation<T = unknown> {
-  /** 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 {
-  /** Whether the input is disabled. */
-  isDisabled?: boolean,
-  /** Whether the input can be selected but not changed by the user. */
-  isReadOnly?: boolean
+  id?: string | undefined;
+  role?: AriaRole | undefined;
+  tabIndex?: number | undefined;
+  style?: CSSProperties$1 | undefined;
+  className?: string | undefined;
 }
 
 /*
@@ -14119,27 +14081,27 @@ type DisabledBehavior = 'selection' | 'all';
 
 
 interface Rect {
-  x: number,
-  y: number,
-  width: number,
-  height: number
+  x: number;
+  y: number;
+  width: number;
+  height: number;
 }
 
 interface Size {
-  width: number,
-  height: number
+  width: number;
+  height: number;
 }
 
 /** A LayoutDelegate provides layout information for collection items. */
 interface LayoutDelegate {
   /** Returns a rectangle for the item with the given key. */
-  getItemRect(key: Key): Rect | null,
+  getItemRect(key: Key): Rect | null;
   /** Returns the visible rectangle of the collection. */
-  getVisibleRect(): Rect,
+  getVisibleRect(): Rect;
   /** Returns the size of the scrollable content in the collection. */
-  getContentSize(): Size,
+  getContentSize(): Size;
   /** Returns a list of keys between `from` and `to`. */
-  getKeyRange?(from: Key, to: Key): Key[]
+  getKeyRange?(from: Key, to: Key): Key[];
 }
 
 /**
@@ -14148,77 +14110,82 @@ interface LayoutDelegate {
  */
 interface Collection<T> extends Iterable<T> {
   /** The number of items in the collection. */
-  readonly size: number,
+  readonly size: number;
 
   /** Iterate over all keys in the collection. */
-  getKeys(): Iterable<Key>,
+  getKeys(): Iterable<Key>;
 
   /** Get an item by its key. */
-  getItem(key: Key): T | null,
+  getItem(key: Key): T | null;
 
   /** Get an item by the index of its key. */
-  at(idx: number): T | null,
+  at(idx: number): T | null;
 
   /** Get the key that comes before the given key in the collection. */
-  getKeyBefore(key: Key): Key | null,
+  getKeyBefore(key: Key): Key | null;
 
   /** Get the key that comes after the given key in the collection. */
-  getKeyAfter(key: Key): Key | null,
+  getKeyAfter(key: Key): Key | null;
 
   /** Get the first key in the collection. */
-  getFirstKey(): Key | null,
+  getFirstKey(): Key | null;
 
   /** Get the last key in the collection. */
-  getLastKey(): Key | null,
+  getLastKey(): Key | null;
 
   /** Iterate over the child items of the given key. */
-  getChildren?(key: Key): Iterable<T>,
+  getChildren?(key: Key): Iterable<T>;
 
   /** Returns a string representation of the item's contents. */
-  getTextValue?(key: Key): string,
+  getTextValue?(key: Key): string;
 
   /** Filters the collection using the given function. */
-  UNSTABLE_filter?(filterFn: (nodeValue: string) => boolean): Collection<T>
+  filter?(filterFn: (nodeValue: string, node: T) => boolean): Collection<T>;
 }
 
 interface Node<T> {
   /** The type of item this node represents. */
-  type: string,
+  type: string;
   /** A unique key for the node. */
-  key: Key,
+  key: Key;
   /** The object value the node was created from. */
-  value: T | null,
+  value: T | null;
   /** The level of depth this node is at in the hierarchy. */
-  level: number,
+  level: number;
   /** Whether this item has children, even if not loaded yet. */
-  hasChildNodes: boolean,
+  hasChildNodes: boolean;
   /**
    * The loaded children of this node.
+   *
    * @deprecated Use `collection.getChildren(node.key)` instead.
    */
-  childNodes: Iterable<Node<T>>,
+  childNodes: Iterable<Node<T>>;
   /** The rendered contents of this node (e.g. JSX). */
-  rendered: ReactNode,
+  rendered: ReactNode;
   /** A string value for this node, used for features like typeahead. */
-  textValue: string,
+  textValue: string;
   /** An accessibility label for this node. */
-  'aria-label'?: string,
+  'aria-label'?: string;
   /** The index of this node within its parent. */
-  index: number,
+  index: number;
   /** A function that should be called to wrap the rendered node. */
-  wrapper?: (element: ReactElement) => ReactElement,
+  wrapper?: (element: ReactElement) => ReactElement;
   /** The key of the parent node. */
-  parentKey?: Key | null,
+  parentKey?: Key | null;
   /** The key of the node before this node. */
-  prevKey?: Key | null,
+  prevKey?: Key | null;
   /** The key of the node after this node. */
-  nextKey?: Key | null,
+  nextKey?: Key | null;
+  /** The first child key of this node. */
+  firstChildKey?: Key | null;
+  /** The last child key of this node. */
+  lastChildKey?: Key | null;
   /** Additional properties specific to a particular node type. */
-  props?: any,
+  props?: any;
   /** @private */
-  shouldInvalidate?: (context: any) => boolean,
+  shouldInvalidate?: (context: any) => boolean;
   /** A function that renders this node to a React Element in the DOM. */
-  render?: (node: Node<any>) => ReactElement
+  render?: (node: Node<any>) => ReactElement;
 }
 
 /*
@@ -14240,10 +14207,12 @@ interface Node<T> {
 type BaseEvent<T extends SyntheticEvent> = T & {
   /**
    * Use continuePropagation.
-   * @deprecated */
-  stopPropagation(): void,
-  continuePropagation(): void
-}
+   *
+   * @deprecated
+   */
+  stopPropagation(): void;
+  continuePropagation(): void;
+};
 
 type KeyboardEvent = BaseEvent<KeyboardEvent$1<any>>;
 
@@ -14251,55 +14220,60 @@ type PointerType = 'mouse' | 'pen' | 'touch' | 'keyboard' | 'virtual';
 
 interface PressEvent {
   /** The type of press event being fired. */
-  type: 'pressstart' | 'pressend' | 'pressup' | 'press',
+  type: 'pressstart' | 'pressend' | 'pressup' | 'press';
   /** The pointer type that triggered the press event. */
-  pointerType: PointerType,
+  pointerType: PointerType;
   /** The target element of the press event. */
-  target: Element,
+  target: Element;
   /** Whether the shift keyboard modifier was held during the press event. */
-  shiftKey: boolean,
+  shiftKey: boolean;
   /** Whether the ctrl keyboard modifier was held during the press event. */
-  ctrlKey: boolean,
+  ctrlKey: boolean;
   /** Whether the meta keyboard modifier was held during the press event. */
-  metaKey: boolean,
+  metaKey: boolean;
   /** Whether the alt keyboard modifier was held during the press event. */
-  altKey: boolean,
+  altKey: boolean;
   /** X position relative to the target. */
-  x: number,
+  x: number;
   /** Y position relative to the target. */
-  y: number,
+  y: number;
+  /**
+   * The key that triggered the press event, if it was triggered by a keyboard interaction.
+   * This is useful for differentiating between Space and Enter key presses.
+   */
+  key?: string;
   /**
    * By default, press events stop propagation to parent elements.
    * In cases where a handler decides not to handle a specific event,
    * it can call `continuePropagation()` to allow a parent to handle it.
    */
-  continuePropagation(): void
+  continuePropagation(): void;
 }
 
 interface LongPressEvent extends Omit<PressEvent, 'type' | 'continuePropagation'> {
   /** The type of long press event being fired. */
-  type: 'longpressstart' | 'longpressend' | 'longpress'
+  type: 'longpressstart' | 'longpressend' | 'longpress';
 }
 
 interface KeyboardEvents {
   /** Handler that is called when a key is pressed. */
-  onKeyDown?: (e: KeyboardEvent) => void,
+  onKeyDown?: (e: KeyboardEvent) => void;
   /** Handler that is called when a key is released. */
-  onKeyUp?: (e: KeyboardEvent) => void
+  onKeyUp?: (e: KeyboardEvent) => void;
 }
 
 interface FocusEvents<Target = Element> {
   /** Handler that is called when the element receives focus. */
-  onFocus?: (e: FocusEvent<Target>) => void,
+  onFocus?: (e: FocusEvent<Target>) => void;
   /** Handler that is called when the element loses focus. */
-  onBlur?: (e: FocusEvent<Target>) => void,
+  onBlur?: (e: FocusEvent<Target>) => void;
   /** Handler that is called when the element's focus status changes. */
-  onFocusChange?: (isFocused: boolean) => void
+  onFocusChange?: (isFocused: boolean) => void;
 }
 
 interface FocusableProps<Target = Element> extends FocusEvents<Target>, KeyboardEvents {
   /** Whether the element should receive focus on render. */
-  autoFocus?: boolean
+  autoFocus?: boolean;
 }
 
 /*
@@ -14316,27 +14290,28 @@ interface FocusableProps<Target = Element> extends FocusEvents<Target>, Keyboard
 
 type Key = string | number;
 
+interface FocusRingAria {
+    /** Whether the element is currently focused. */
+    isFocused: boolean;
+    /** Whether keyboard focus should be visible. */
+    isFocusVisible: boolean;
+    /** Props to apply to the container element with the focus ring. */
+    focusProps: DOMAttributes;
+}
+
 interface PressResult {
     /** Whether the target is currently pressed. */
     isPressed: boolean;
     /** Props to spread on the target element. */
     pressProps: DOMAttributes;
 }
+
 interface HoverResult {
     /** Props to spread on the target element. */
     hoverProps: DOMAttributes;
     isHovered: boolean;
 }
 
-interface FocusRingAria {
-    /** Whether the element is currently focused. */
-    isFocused: boolean;
-    /** Whether keyboard focus should be visible. */
-    isFocusVisible: boolean;
-    /** Props to apply to the container element with the focus ring. */
-    focusProps: DOMAttributes;
-}
-
 type FocusHookResult = [boolean, FocusRingAria["focusProps"]];
 type HoverHookResult = [boolean, HoverResult["hoverProps"]];
 type PressHookResult = [boolean, PressResult["pressProps"]];
@@ -14446,63 +14421,6 @@ declare function useButton<P extends PlumeButtonProps, C extends AnyPlasmicClass
     };
 };
 
-/*
- * 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 ToggleStateOptions extends InputBase {
-  /**
-   * Whether the element should be selected (uncontrolled).
-   */
-  defaultSelected?: boolean,
-  /**
-   * Whether the element should be selected (controlled).
-   */
-  isSelected?: boolean,
-  /**
-   * Handler that is called when the element's selection state changes.
-   */
-  onChange?: (isSelected: boolean) => void
-}
-
-interface ToggleProps extends ToggleStateOptions, Validation<boolean>, FocusableProps {
-  /**
-   * The label for the element.
-   */
-  children?: ReactNode,
-  /**
-   * The value of the input element, used when submitting an HTML form. See [MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#htmlattrdefvalue).
-   */
-  value?: string
-}
-
-interface AriaToggleProps extends ToggleProps, FocusableDOMProps, AriaLabelingProps, AriaValidationProps, InputDOMProps {
-  /**
-   * Identifies the element (or elements) whose contents or presence are controlled by the current element.
-   */
-  'aria-controls'?: string
-}
-
-interface CheckboxProps$1 extends ToggleProps {
-  /**
-   * Indeterminism is presentational only.
-   * The indeterminate visual representation remains regardless of user interaction.
-   */
-  isIndeterminate?: boolean
-}
-
-interface AriaCheckboxProps extends CheckboxProps$1, AriaToggleProps {}
-
 interface StyleProps {
     className?: string;
     style?: React$1.CSSProperties;
@@ -14743,24 +14661,20 @@ declare function useMenuItem<P extends BaseMenuItemProps, C extends AnyPlasmicCl
     };
 };
 
-/*
- * 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 Placement = 'bottom' | 'bottom left' | 'bottom right' | 'bottom start' | 'bottom end' | 'top' | 'top left' | 'top right' | 'top start' | 'top end' | 'left' | 'left top' | 'left bottom' | 'start' | 'start top' | 'start bottom' | 'right' | 'right top' | 'right bottom' | 'end' | 'end top' | 'end bottom';
 
-
-type Placement = 'bottom' | 'bottom left' | 'bottom right' | 'bottom start' | 'bottom end' |
-    'top' | 'top left' | 'top right' | 'top start' | 'top end' |
-    'left' | 'left top' | 'left bottom' | 'start' | 'start top' | 'start bottom' |
-    'right' | 'right top' | 'right bottom' | 'end' | 'end top' | 'end bottom';
+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 DropdownMenuProps {
     /**
@@ -15013,7 +14927,10 @@ interface FocusState {
     readonly focusedKey: Key | null;
     /** Whether the first or last child of the focused key should receive focus. */
     readonly childFocusStrategy: FocusStrategy | null;
-    /** Sets the focused key, and optionally, whether the first or last child of that key should receive focus. */
+    /**
+     * Sets the focused key, and optionally, whether the first or last child of that key should
+     * receive focus.
+     */
     setFocusedKey(key: Key | null, child?: FocusStrategy): void;
 }
 interface MultipleSelectionState extends FocusState {
@@ -15091,15 +15008,22 @@ interface MultipleSelectionManager extends FocusState {
     /** The collection of nodes that the selection manager handles. */
     collection: Collection<Node<unknown>>;
 }
+
 interface SelectionManagerOptions {
     allowsCellSelection?: boolean;
     layoutDelegate?: LayoutDelegate;
+    fullCollection?: Collection<Node<unknown>>;
 }
 /**
  * An interface for reading and updating multiple selection state.
  */
 declare class SelectionManager implements MultipleSelectionManager {
     collection: Collection<Node<unknown>>;
+    private state;
+    private allowsCellSelection;
+    private _isSelectAll;
+    private layoutDelegate;
+    private fullCollection;
     constructor(collection: Collection<Node<unknown>>, state: MultipleSelectionState, options?: SelectionManagerOptions);
     /**
      * The type of selection that is allowed in the collection.
@@ -15164,6 +15088,9 @@ declare class SelectionManager implements MultipleSelectionManager {
      * Extends the selection to the given key.
      */
     extendSelection(toKey: Key): void;
+    private getKeyRange;
+    private getKeyRangeInternal;
+    private getKey;
     /**
      * Toggles whether the given key is selected.
      */
@@ -15176,6 +15103,7 @@ declare class SelectionManager implements MultipleSelectionManager {
      * Replaces the selection with the given keys.
      */
     setSelectedKeys(keys: Iterable<Key>): void;
+    private getSelectAllKeys;
     /**
      * Selects all items in the collection.
      */
@@ -15194,6 +15122,7 @@ declare class SelectionManager implements MultipleSelectionManager {
      */
     isSelectionEqual(selection: Set<Key>): boolean;
     canSelectItem(key: Key): boolean;
+    private canSelectItemIn;
     isDisabled(key: Key): boolean;
     isLink(key: Key): boolean;
     getItemProps(key: Key): any;
@@ -15211,51 +15140,6 @@ interface ListState<T> {
 
 declare const SelectContext: React$1.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");
- * 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.
-   */
-  children?: ReactNode,
-  /**
-   * Whether the Switch should be selected (uncontrolled).
-   */
-  defaultSelected?: boolean,
-  /**
-   * Whether the Switch should be selected (controlled).
-   */
-  isSelected?: boolean,
-  /**
-   * Handler that is called when the Switch's selection state changes.
-   */
-  onChange?: (isSelected: boolean) => void,
-  /**
-   * The value of the input element, used when submitting an HTML form. See [MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#htmlattrdefvalue).
-   */
-  value?: string
-}
-interface SwitchProps$1 extends SwitchBase {}
-interface AriaSwitchBase extends SwitchBase, FocusableDOMProps, InputDOMProps, AriaLabelingProps {
-  /**
-   * Identifies the element (or elements) whose contents or presence are controlled by the current element.
-   */
-  'aria-controls'?: string
-}
-interface AriaSwitchProps extends SwitchProps$1, AriaSwitchBase {}
-
 type SwitchRef = React$1.Ref<SwitchRefValue>;
 interface SwitchRefValue extends SwitchState {
     getRoot: () => HTMLElement | null;
@@ -15349,19 +15233,6 @@ 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$1.RefObject<HTMLElement>;
     state: OverlayTriggerState;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plasmicapp/react-web",
-  "version": "1.0.15",
+  "version": "1.0.17",
   "description": "plasmic library for rendering in the presentational style",
   "main": "dist/index.cjs.js",
   "types": "dist/index.d.ts",
@@ -75,7 +75,7 @@
   "scripts": {
     "build": "rollup -c && mkdir -p lib && cp src/styles/plasmic.css lib/",
     "clean": "rm -rf dist/ skinny/dist/ lib/host/*js lib/host/*.ts lib/host/*.map lib/data-sources/*js lib/data-sources/*.ts lib/data-sources/*.map lib/query/*js lib/query/*.ts lib/query/*.map lib/auth/*js lib/auth/*.ts lib/auth/*.map lib/splits/*js lib/splits/*.ts lib/splits/*.map",
-    "test": "TEST_CWD=`pwd` yarn --cwd=../.. test",
+    "test": "TEST_CWD=`pwd` pnpm -w test",
     "lint": "eslint",
     "prepublishOnly": "npm run build",
     "size": "size-limit",
@@ -85,14 +85,14 @@
     "test-storybook": "test-storybook"
   },
   "dependencies": {
-    "@plasmicapp/auth-react": "0.0.27",
-    "@plasmicapp/data-sources": "1.0.14",
-    "@plasmicapp/data-sources-context": "0.1.23",
-    "@plasmicapp/host": "2.0.6",
-    "@plasmicapp/loader-splits": "1.0.70",
-    "@plasmicapp/nextjs-app-router": "1.0.23",
-    "@plasmicapp/prepass": "1.0.24",
-    "@plasmicapp/query": "0.1.84",
+    "@plasmicapp/auth-react": "0.0.28",
+    "@plasmicapp/data-sources": "1.0.15",
+    "@plasmicapp/data-sources-context": "0.1.24",
+    "@plasmicapp/host": "2.0.7",
+    "@plasmicapp/loader-splits": "1.0.71",
+    "@plasmicapp/nextjs-app-router": "1.0.25",
+    "@plasmicapp/prepass": "1.0.25",
+    "@plasmicapp/query": "0.1.85",
     "@react-aria/checkbox": "^3.15.5",
     "@react-aria/focus": "^3.20.3",
     "@react-aria/interactions": "^3.25.1",
@@ -142,5 +142,5 @@
     "react": ">=18.0.0",
     "react-dom": ">=18.0.0"
   },
-  "gitHead": "da8b62e5312e2ba8e771e607aeb2f6c3ca5b73f1"
+  "gitHead": "ff7171136453b094d87c56ff90e078d930f99b29"
 }