@proyecto-viviana/solid-stately 0.5.1 → 0.6.0-rc.0

package/src/select/createSelectState.ts

@@ -1,15 +1,35 @@
+/*
+ * 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.
+ */
+
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-stately/src/select/useSelectState.ts
+
 /**
  * State management for select components.
  * Based on @react-stately/select useSelectState.
  */
 
-import { createSignal, createMemo, type Accessor } from "solid-js";
-import { access, type MaybeAccessor } from "../utils";
+import { createMemo } from "solid-js";
+import type { Accessor } from "solid-js";
+import { createInternalSignal, access, type MaybeAccessor } from "../utils";
 import { createListState } from "../collections/createListState";
 import { createOverlayTriggerState } from "../overlays";
 import type { Key, CollectionNode, Collection } from "../collections/types";
 import type { SelectionMode, Selection } from "../collections/types";
 import type { SelectionManager } from "../selection/SelectionManager";
+import {
+  createFormValidationState,
+  type FormValidationState,
+  type ValidationFunction,
+} from "../form";
 
 export interface SelectStateProps<T = unknown> {
   /** The items to display in the select. */
@@ -46,9 +66,22 @@ export interface SelectStateProps<T = unknown> {
   isDisabled?: boolean;
   /** Whether the select is required. */
   isRequired?: boolean;
+  /** Whether the select is invalid (controlled). */
+  isInvalid?: boolean;
+  /** @deprecated Use isInvalid instead. */
+  validationState?: "valid" | "invalid";
+  /** Custom validation function. */
+  validate?: ValidationFunction<Key | null | Selection>;
+  /**
+   * Whether to use native HTML form validation or ARIA validation semantics.
+   * @default "native"
+   */
+  validationBehavior?: "aria" | "native";
+  /** Field name(s) for server error lookup. */
+  name?: string | string[];
 }
 
-export interface SelectState<T = unknown> {
+export interface SelectState<T = unknown> extends FormValidationState {
   /** The collection of items. */
   readonly collection: Accessor<Collection<T>>;
   /**
@@ -120,10 +153,10 @@ export function createSelectState<T = unknown>(
   // Track selected key
   const isControlledSingle = () => getProps().selectedKey !== undefined;
   const isControlledMultiple = () => getProps().selectedKeys !== undefined;
-  const [internalSelectedKey, setInternalSelectedKey] = createSignal<Key | null>(
+  const [internalSelectedKey, setInternalSelectedKey] = createInternalSignal<Key | null>(
     getProps().defaultSelectedKey ?? null,
   );
-  const [internalSelectedKeys, setInternalSelectedKeys] = createSignal<Selection>(
+  const [internalSelectedKeys, setInternalSelectedKeys] = createInternalSignal<Selection>(
     getProps().defaultSelectedKeys === "all"
       ? "all"
       : new Set(getProps().defaultSelectedKeys ?? []),
@@ -193,6 +226,27 @@ export function createSelectState<T = unknown>(
     setSelectedKey(key);
   };
 
+  const validation = createFormValidationState({
+    get value() {
+      return selectionMode() === "multiple" ? selectedKeys() : selectedKey();
+    },
+    get isInvalid() {
+      return getProps().isInvalid;
+    },
+    get validationState() {
+      return getProps().validationState;
+    },
+    get validate() {
+      return getProps().validate;
+    },
+    get name() {
+      return getProps().name;
+    },
+    get validationBehavior() {
+      return getProps().validationBehavior ?? "native";
+    },
+  });
+
   // Create list state with select selection mode
   const listState = createListState<T>({
     get items() {
@@ -213,7 +267,12 @@ export function createSelectState<T = unknown>(
     get selectionMode() {
       return selectionMode();
     },
-    disallowEmptySelection: true,
+    // Upstream only requires a value in single-selection mode. Multiple
+    // selection must permit toggling the last selected option off.
+    get disallowEmptySelection() {
+      return selectionMode() === "single";
+    },
+    allowDuplicateSelectionEvents: true,
     get selectedKeys() {
       const keys = selectedKeys();
       if (keys === "all") return "all";
@@ -228,6 +287,7 @@ export function createSelectState<T = unknown>(
         if (keys !== "all") {
           getProps().onSelectionChange?.(keys.size > 0 ? Array.from(keys)[0] : null);
         }
+        validation.commitValidation();
         return;
       }
 
@@ -235,8 +295,8 @@ export function createSelectState<T = unknown>(
       if (keys === "all") return;
       const key = keys.size > 0 ? Array.from(keys)[0] : null;
       setSelectedKey(key);
-      // Close the dropdown after selection in single mode
       overlayState.close();
+      validation.commitValidation();
     },
   });
 
@@ -244,7 +304,7 @@ export function createSelectState<T = unknown>(
   // focus-within state on the selection manager — upstream useSelectState keeps
   // these apart with a dedicated useState. Sharing the manager's signal makes
   // trigger focus re-arm the item roving-focus effect and steal focus back.
-  const [isFocused, setFocused] = createSignal(false);
+  const [isFocused, setFocused] = createInternalSignal(false);
 
   // Get the selected item from the collection (memoized)
   const selectedItem: Accessor<CollectionNode<T> | null> = createMemo(() => {
@@ -268,6 +328,11 @@ export function createSelectState<T = unknown>(
   });
 
   return {
+    realtimeValidation: validation.realtimeValidation,
+    displayValidation: validation.displayValidation,
+    updateValidation: validation.updateValidation,
+    resetValidation: validation.resetValidation,
+    commitValidation: validation.commitValidation,
     // Collection
     collection: listState.collection,
     selectionManager: listState.selectionManager,

package/src/selection/Selection.ts

@@ -1,8 +1,22 @@
+/*
+ * 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.
+ */
+
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-stately/src/selection/Selection.ts
+
 /**
  * A Selection is a special Set containing Keys, which also has an anchor
  * and current selected key for use when range selecting.
  *
- * Based on @react-stately/selection.
+ * Ported from packages/react-stately/src/selection/Selection.ts.
  */
 
 import type { Key } from "../collections/types";

package/src/selection/SelectionManager.ts

@@ -1,3 +1,17 @@
+/*
+ * 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.
+ */
+
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-stately/src/selection/SelectionManager.ts
+
 /**
  * An interface for reading and updating multiple selection state.
  *

package/src/selection/createMultipleSelectionState.ts

@@ -1,18 +1,31 @@
+/*
+ * 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.
+ */
+
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-stately/src/selection/useMultipleSelectionState.ts
+
 /**
  * Raw multiple-selection + focus state for a collection.
  *
  * The lower of the two selection layers ported from upstream
- * (`@react-stately/selection`'s `useMultipleSelectionState`): it owns the
+ * (`packages/react-stately/src/selection/useMultipleSelectionState.ts`): it owns the
  * selected keys, focus, selection behavior, and disabled keys, but is NOT
  * collection-aware. The collection-aware operations (toggle, extend, select
  * all, range, etc.) live in {@link SelectionManager}, which is built on top of
  * this state.
- *
- * Based on @react-stately/selection.
  */
 
-import { createSignal, createMemo, createComputed, untrack, type Accessor } from "solid-js";
-import { access, type MaybeAccessor } from "../utils";
+import { createMemo, createEffect } from "solid-js";
+import type { Accessor } from "solid-js";
+import { access, createInternalSignal, readNow, type MaybeAccessor } from "../utils";
 import type { SelectionStateProps } from "../collections/createSelectionState";
 import type {
   DisabledBehavior,
@@ -105,16 +118,18 @@ export function createMultipleSelectionState(
 
   // Focus is a plain signal in Solid; upstream needs a ref + state pair only
   // because React requires both a synchronous read and a re-render trigger.
-  const [isFocused, setIsFocused] = createSignal(false);
-  const [focusedKey, setFocusedKeySignal] = createSignal<Key | null>(null);
-  const [childFocusStrategy, setChildFocusStrategy] = createSignal<FocusStrategy | null>(null);
+  const [isFocused, setIsFocused] = createInternalSignal(false);
+  const [focusedKey, setFocusedKeySignal] = createInternalSignal<Key | null>(null);
+  const [childFocusStrategy, setChildFocusStrategy] = createInternalSignal<FocusStrategy | null>(
+    null,
+  );
 
   const defaultSelectedKeys = convertSelection(
     getProps().defaultSelectedKeys,
     new SelectionClass(),
   );
   const [uncontrolledSelectedKeys, setUncontrolledSelectedKeys] =
-    createSignal<Selection>(defaultSelectedKeys);
+    createInternalSignal<Selection>(defaultSelectedKeys);
 
   const selectedKeys = createMemo<Selection>(() => {
     const p = getProps();
@@ -130,27 +145,28 @@ export function createMultipleSelectionState(
   const selectionBehaviorProp = (): SelectionBehavior => getProps().selectionBehavior ?? "toggle";
 
   const [selectionBehavior, setSelectionBehaviorState] =
-    createSignal<SelectionBehavior>(selectionBehaviorProp());
+    createInternalSignal<SelectionBehavior>(selectionBehaviorProp());
 
   // If the selectionBehavior prop is 'replace' but the current state is 'toggle'
   // (e.g. due to a long press to enter selection mode on touch) and the
   // selection becomes empty, reset the behavior back to 'replace'.
-  createComputed(() => {
-    const keys = selectedKeys();
-    if (
-      selectionBehaviorProp() === "replace" &&
-      untrack(selectionBehavior) === "toggle" &&
-      typeof keys === "object" &&
-      keys.size === 0
-    ) {
-      setSelectionBehaviorState("replace");
-    }
-  });
+  createEffect(
+    () => ({ keys: selectedKeys(), prop: selectionBehaviorProp() }),
+    ({ keys, prop }) => {
+      if (
+        prop === "replace" &&
+        selectionBehavior() === "toggle" &&
+        typeof keys === "object" &&
+        keys.size === 0
+      ) {
+        setSelectionBehaviorState("replace");
+      }
+    },
+  );
 
   // If the selectionBehavior prop changes, sync it into state.
   let lastSelectionBehavior = selectionBehaviorProp();
-  createComputed(() => {
-    const prop = selectionBehaviorProp();
+  createEffect(selectionBehaviorProp, (prop) => {
     if (prop !== lastSelectionBehavior) {
       setSelectionBehaviorState(prop);
       lastSelectionBehavior = prop;
@@ -169,9 +185,12 @@ export function createMultipleSelectionState(
     getProps().onSelectionChange?.(keys);
   };
 
+  const liveSelectedKeys = (): Selection =>
+    getProps().selectedKeys !== undefined ? selectedKeys() : readNow(uncontrolledSelectedKeys);
+
   const setSelectedKeys = (keys: Selection) => {
     const p = getProps();
-    const current = selectedKeys();
+    const current = liveSelectedKeys();
     const shouldUpdate =
       p.allowDuplicateSelectionEvents ||
       keys === "all" ||
@@ -227,7 +246,7 @@ export function createMultipleSelectionState(
       setChildFocusStrategy(strategy);
     },
     get selectedKeys() {
-      return selectedKeys();
+      return liveSelectedKeys();
     },
     get lastSelectionEvent() {
       return lastSelectionEvent;

package/src/slider/createSliderState.ts

@@ -1,10 +1,25 @@
+/*
+ * 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.
+ */
+
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-stately/src/slider/useSliderState.ts
+
 /**
  * Creates state for a slider component.
  * Based on @react-stately/slider useSliderState.
  */
 
-import { type Accessor, createSignal, createMemo } from "solid-js";
-import { access, type MaybeAccessor } from "../utils";
+import { createMemo } from "solid-js";
+import type { Accessor } from "solid-js";
+import { createInternalSignal, access, type MaybeAccessor } from "../utils";
 
 export type SliderOrientation = "horizontal" | "vertical";
 
@@ -119,7 +134,7 @@ export function createSliderState(props: MaybeAccessor<SliderStateProps>): Slide
   const isControlled = () => getProps().value !== undefined;
 
   // Internal signal for uncontrolled mode
-  const [internalValue, setInternalValue] = createSignal(
+  const [internalValue, setInternalValue] = createInternalSignal(
     snapToStep(
       initialProps.defaultValue ?? initialMinValue,
       initialMinValue,
@@ -129,8 +144,8 @@ export function createSliderState(props: MaybeAccessor<SliderStateProps>): Slide
   );
 
   // Dragging and focus state
-  const [isDragging, setIsDragging] = createSignal(false);
-  const [isFocused, setIsFocused] = createSignal(false);
+  const [isDragging, setIsDragging] = createInternalSignal(false);
+  const [isFocused, setIsFocused] = createInternalSignal(false);
 
   // Current value accessor
   const value = createMemo(() => {

package/src/ssr/index.ts

@@ -1,15 +1,34 @@
+/*
+ * 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.
+ */
+
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-aria/src/ssr/SSRProvider.tsx
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-aria/src/utils/useId.ts
+
 /**
  * SSR utilities for Solid Stately
  *
  * SolidJS has built-in SSR support with `isServer` and `createUniqueId()`.
- * These utilities provide a consistent API matching React-Stately's patterns.
+ * These utilities provide a consistent port of the upstream SSR API.
+ *
+ * Ported from:
+ * - packages/react-aria/src/ssr/SSRProvider.tsx
+ * - packages/react-aria/src/utils/useId.ts
  */
 
 import { createUniqueId } from "solid-js";
-import { isServer as _isServer } from "solid-js/web";
+import { isServer as _isServer } from "@solidjs/web";
 
 /**
- * Re-export isServer from solid-js/web for convenience.
+ * Re-export isServer from @solidjs/web for convenience.
  */
 export const isServer = _isServer;
 
@@ -28,10 +47,14 @@ export function createIsSSR(): boolean {
  * @param defaultId - Optional default ID to use instead of generating one.
  */
 export function createId(defaultId?: string): string {
+  // Generate first, choose second, like upstream `useId`: `createUniqueId` is
+  // order-dependent in both of its branches, so returning early on `defaultId`
+  // would shift every later id in the same render or hydration pass.
+  const uniqueId = createUniqueId();
   if (defaultId) {
     return defaultId;
   }
-  return `solid-stately-${createUniqueId()}`;
+  return `solid-stately-${uniqueId}`;
 }
 
 /**

package/src/steplist/createStepListState.ts

@@ -1,9 +1,28 @@
+/*
+ * Copyright 2023 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.
+ */
+
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-stately/src/steplist/useStepListState.ts
+
 /**
  * State management for step list components.
  * Tracks selected step, completion status, and selectability.
+ *
+ * Ported from packages/react-stately/src/steplist/useStepListState.ts.
  */
 
-import { createEffect, createMemo, createSignal, type Accessor } from "solid-js";
+import { createEffect, createMemo } from "solid-js";
+import type { Accessor } from "solid-js";
+import { createInternalSignal } from "../utils";
+
 import type { Key } from "../collections/types";
 
 export interface StepListStateProps {
@@ -64,9 +83,8 @@ export function createStepListState(props: StepListStateProps): StepListState {
   const isReadOnly: Accessor<boolean> = () => props.isReadOnly ?? false;
 
   // Last completed step signal (uncontrolled)
-  const [lastCompletedStepInternal, setLastCompletedStepInternal] = createSignal<Key | null>(
-    props.defaultLastCompletedStep ?? null,
-  );
+  const [lastCompletedStepInternal, setLastCompletedStepInternal] =
+    createInternalSignal<Key | null>(props.defaultLastCompletedStep ?? null);
 
   const lastCompletedStep: Accessor<Key | null> = () => {
     if (props.lastCompletedStep !== undefined) {
@@ -144,7 +162,7 @@ export function createStepListState(props: StepListStateProps): StepListState {
   };
 
   // Selected key signal (uncontrolled)
-  const [selectedKeyInternal, setSelectedKeyInternal] = createSignal<Key | null>(
+  const [selectedKeyInternal, setSelectedKeyInternal] = createInternalSignal<Key | null>(
     props.defaultSelectedKey ?? findDefaultSelectedKey(),
   );
 
@@ -187,18 +205,21 @@ export function createStepListState(props: StepListStateProps): StepListState {
   // lastCompleted index), advancing `lastCompletedStep` to `selectedIdx - 1`
   // marks every intermediate step complete. This runs regardless of
   // `isDisabled` / `isReadOnly`, exactly as upstream (the effect is ungated).
-  createEffect(() => {
-    const selKey = selectedKey();
-    if (selKey === null) return;
-    const selIdx = indexMap().get(selKey);
-    if (selIdx === undefined || selIdx <= 0) return;
-    const completed = lastCompletedStep();
-    const lcs = completed !== null ? (indexMap().get(completed) ?? -1) : -1;
-    if (selIdx > lcs + 1) {
-      const prevKey = items()[selIdx - 1]?.key;
-      if (prevKey !== undefined) setLastCompletedStep(prevKey);
-    }
-  });
+  createEffect(
+    () => {
+      const selKey = selectedKey();
+      if (selKey === null) return null;
+      const selIdx = indexMap().get(selKey);
+      if (selIdx === undefined || selIdx <= 0) return null;
+      const completed = lastCompletedStep();
+      const lcs = completed !== null ? (indexMap().get(completed) ?? -1) : -1;
+      if (selIdx <= lcs + 1) return null;
+      return items()[selIdx - 1]?.key;
+    },
+    (prevKey) => {
+      if (prevKey !== undefined && prevKey !== null) setLastCompletedStep(prevKey);
+    },
+  );
 
   return {
     selectedKey,

package/src/table/TableCollection.ts

@@ -1,3 +1,17 @@
+/*
+ * 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.
+ */
+
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-stately/src/table/TableCollection.ts
+
 /**
  * TableCollection - A collection class for table data.
  * Based on @react-stately/table/TableCollection.

package/src/table/createTableColumnResizeState.ts

@@ -1,3 +1,17 @@
+/*
+ * Copyright 2022 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.
+ */
+
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-stately/src/table/useTableColumnResizeState.ts
+
 /**
  * Table column resize state management.
  * Based on @react-stately/table/useTableColumnResizeState.
@@ -7,7 +21,10 @@
  * width distribution and clamping.
  */
 
-import { createSignal, createMemo, type Accessor } from "solid-js";
+import { createMemo } from "solid-js";
+import type { Accessor } from "solid-js";
+import { createInternalSignal } from "../utils";
+
 import type { Key } from "../collections/types";
 
 /** Column size: a number (px) or a string ('100px', '50%', '1fr'). */
@@ -154,8 +171,8 @@ export function createTableColumnResizeState(
   );
 
   // User-overridden widths (set during/after resize)
-  const [overrides, setOverrides] = createSignal<Map<Key, number>>(new Map());
-  const [resizingColumn, setResizingColumn] = createSignal<Key | null>(null);
+  const [overrides, setOverrides] = createInternalSignal<Map<Key, number>>(new Map());
+  const [resizingColumn, setResizingColumn] = createInternalSignal<Key | null>(null);
 
   // Computed widths: initial merged with overrides
   const columnWidths = createMemo(() => {

package/src/table/createTableState.ts

@@ -1,9 +1,24 @@
+/*
+ * 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.
+ */
+
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-stately/src/table/useTableState.ts
+
 /**
  * Table state management for Table components.
  * Based on @react-stately/table/useTableState.
  */
 
-import { createMemo, type Accessor } from "solid-js";
+import { createMemo } from "solid-js";
+import type { Accessor } from "solid-js";
 import { createGridState } from "../grid/createGridState";
 import type { Key } from "../collections/types";
 import type {
@@ -111,6 +126,12 @@ export function createTableState<
     get selectedKeys() {
       return gridState.selectedKeys;
     },
+    get isEmpty() {
+      return gridState.isEmpty;
+    },
+    get isSelectAll() {
+      return gridState.isSelectAll;
+    },
 
     // Grid state methods
     isSelected: gridState.isSelected,

package/src/table/createTreeGridState.ts

@@ -1,3 +1,17 @@
+/*
+ * Copyright 2023 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.
+ */
+
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-stately/src/table/useTreeGridState.ts
+
 /**
  * Tree grid state management for expandable Table rows.
  * Based on @react-stately/table/useTreeGridState (the `UNSTABLE_` tree-grid feature).
@@ -6,7 +20,10 @@
  * collection from it, and layers the expansion API on top of {@link createTableState}.
  */
 
-import { createMemo, createSignal, type Accessor } from "solid-js";
+import { createMemo } from "solid-js";
+import type { Accessor } from "solid-js";
+import { createInternalSignal } from "../utils";
+
 import { createTableState } from "./createTableState";
 import { createTableCollection, TableCollection } from "./TableCollection";
 import type { Key } from "../collections/types";
@@ -24,17 +41,17 @@ export function createTreeGridState<
 
   // Expanded keys: controlled via `UNSTABLE_expandedKeys`, otherwise the internal signal
   // seeded from `UNSTABLE_defaultExpandedKeys`.
-  const [internalExpandedKeys, setInternalExpandedKeys] = createSignal<"all" | Set<Key>>(
+  const [internalExpandedKeys, setInternalExpandedKeys] = createInternalSignal<"all" | Set<Key>>(
     getInitialExpanded(getOptions().UNSTABLE_defaultExpandedKeys),
   );
 
-  const expandedKeys = createMemo<"all" | Set<Key>>(() => {
+  const expandedKeys = (): "all" | Set<Key> => {
     const controlled = getOptions().UNSTABLE_expandedKeys;
     if (controlled !== undefined) {
       return convertExpanded(controlled);
     }
     return internalExpandedKeys();
-  });
+  };
 
   // Rebuild the tree collection whenever the expanded keys (or the data) change.
   const collection = createMemo(