@tale-ui/utils 0.0.3

package/CHANGELOG.md

@@ -0,0 +1,14 @@
+# Versions
+
+## 0.2.0
+
+_Nov 17, 2025_
+
+- Add infrastructure to support nested stores (#3037) by @michaldudak
+- Export `useScrollLock` (#3233) by @atomiks
+
+## 0.1.0
+
+_Jul 30, 2025_
+
+Initial release

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 Material-UI SAS
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,3 @@
+# @tale-ui/utils
+
+A collection of React utility functions for Base UI.

package/detectBrowser.d.ts

@@ -0,0 +1,8 @@
+export declare const isWebKit: boolean;
+export declare const isIOS: boolean;
+export declare const isFirefox: boolean;
+export declare const isSafari: boolean;
+export declare const isEdge: boolean;
+export declare const isAndroid: boolean;
+export declare const isMac: boolean;
+export declare const isJSDOM: boolean;

package/detectBrowser.js

@@ -0,0 +1,64 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isWebKit = exports.isSafari = exports.isMac = exports.isJSDOM = exports.isIOS = exports.isFirefox = exports.isEdge = exports.isAndroid = void 0;
+const hasNavigator = typeof navigator !== 'undefined';
+const nav = getNavigatorData();
+const platform = getPlatform();
+const userAgent = getUserAgent();
+const isWebKit = exports.isWebKit = typeof CSS === 'undefined' || !CSS.supports ? false : CSS.supports('-webkit-backdrop-filter:none');
+const isIOS = exports.isIOS =
+// iPads can claim to be MacIntel
+nav.platform === 'MacIntel' && nav.maxTouchPoints > 1 ? true : /iP(hone|ad|od)|iOS/.test(nav.platform);
+const isFirefox = exports.isFirefox = hasNavigator && /firefox/i.test(userAgent);
+const isSafari = exports.isSafari = hasNavigator && /apple/i.test(navigator.vendor);
+const isEdge = exports.isEdge = hasNavigator && /Edg/i.test(userAgent);
+const isAndroid = exports.isAndroid = hasNavigator && /android/i.test(platform) || /android/i.test(userAgent);
+const isMac = exports.isMac = hasNavigator && platform.toLowerCase().startsWith('mac') && !navigator.maxTouchPoints;
+const isJSDOM = exports.isJSDOM = userAgent.includes('jsdom/');
+
+// Avoid Chrome DevTools blue warning.
+function getNavigatorData() {
+  if (!hasNavigator) {
+    return {
+      platform: '',
+      maxTouchPoints: -1
+    };
+  }
+  const uaData = navigator.userAgentData;
+  if (uaData?.platform) {
+    return {
+      platform: uaData.platform,
+      maxTouchPoints: navigator.maxTouchPoints
+    };
+  }
+  return {
+    platform: navigator.platform ?? '',
+    maxTouchPoints: navigator.maxTouchPoints ?? -1
+  };
+}
+function getUserAgent() {
+  if (!hasNavigator) {
+    return '';
+  }
+  const uaData = navigator.userAgentData;
+  if (uaData && Array.isArray(uaData.brands)) {
+    return uaData.brands.map(({
+      brand,
+      version
+    }) => `${brand}/${version}`).join(' ');
+  }
+  return navigator.userAgent;
+}
+function getPlatform() {
+  if (!hasNavigator) {
+    return '';
+  }
+  const uaData = navigator.userAgentData;
+  if (uaData?.platform) {
+    return uaData.platform;
+  }
+  return navigator.platform ?? '';
+}

package/empty.d.ts

@@ -0,0 +1,3 @@
+export declare function NOOP(): void;
+export declare const EMPTY_ARRAY: readonly any[];
+export declare const EMPTY_OBJECT: Readonly<{}>;

package/empty.js

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.EMPTY_OBJECT = exports.EMPTY_ARRAY = void 0;
+exports.NOOP = NOOP;
+function NOOP() {}
+const EMPTY_ARRAY = exports.EMPTY_ARRAY = Object.freeze([]);
+const EMPTY_OBJECT = exports.EMPTY_OBJECT = Object.freeze({});

package/error.d.ts

@@ -0,0 +1,2 @@
+export declare function error(...messages: string[]): void;
+export declare function reset(): void;

package/error.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.error = error;
+exports.reset = reset;
+let set;
+if (process.env.NODE_ENV !== 'production') {
+  set = new Set();
+}
+function error(...messages) {
+  if (process.env.NODE_ENV !== 'production') {
+    const messageKey = messages.join(' ');
+    if (!set.has(messageKey)) {
+      set.add(messageKey);
+      console.error(`Tale UI: ${messageKey}`);
+    }
+  }
+}
+function reset() {
+  set?.clear();
+}

package/esm/detectBrowser.d.ts

@@ -0,0 +1,8 @@
+export declare const isWebKit: boolean;
+export declare const isIOS: boolean;
+export declare const isFirefox: boolean;
+export declare const isSafari: boolean;
+export declare const isEdge: boolean;
+export declare const isAndroid: boolean;
+export declare const isMac: boolean;
+export declare const isJSDOM: boolean;

package/esm/detectBrowser.js

@@ -0,0 +1,58 @@
+const hasNavigator = typeof navigator !== 'undefined';
+const nav = getNavigatorData();
+const platform = getPlatform();
+const userAgent = getUserAgent();
+export const isWebKit = typeof CSS === 'undefined' || !CSS.supports ? false : CSS.supports('-webkit-backdrop-filter:none');
+export const isIOS =
+// iPads can claim to be MacIntel
+nav.platform === 'MacIntel' && nav.maxTouchPoints > 1 ? true : /iP(hone|ad|od)|iOS/.test(nav.platform);
+export const isFirefox = hasNavigator && /firefox/i.test(userAgent);
+export const isSafari = hasNavigator && /apple/i.test(navigator.vendor);
+export const isEdge = hasNavigator && /Edg/i.test(userAgent);
+export const isAndroid = hasNavigator && /android/i.test(platform) || /android/i.test(userAgent);
+export const isMac = hasNavigator && platform.toLowerCase().startsWith('mac') && !navigator.maxTouchPoints;
+export const isJSDOM = userAgent.includes('jsdom/');
+
+// Avoid Chrome DevTools blue warning.
+function getNavigatorData() {
+  if (!hasNavigator) {
+    return {
+      platform: '',
+      maxTouchPoints: -1
+    };
+  }
+  const uaData = navigator.userAgentData;
+  if (uaData?.platform) {
+    return {
+      platform: uaData.platform,
+      maxTouchPoints: navigator.maxTouchPoints
+    };
+  }
+  return {
+    platform: navigator.platform ?? '',
+    maxTouchPoints: navigator.maxTouchPoints ?? -1
+  };
+}
+function getUserAgent() {
+  if (!hasNavigator) {
+    return '';
+  }
+  const uaData = navigator.userAgentData;
+  if (uaData && Array.isArray(uaData.brands)) {
+    return uaData.brands.map(({
+      brand,
+      version
+    }) => `${brand}/${version}`).join(' ');
+  }
+  return navigator.userAgent;
+}
+function getPlatform() {
+  if (!hasNavigator) {
+    return '';
+  }
+  const uaData = navigator.userAgentData;
+  if (uaData?.platform) {
+    return uaData.platform;
+  }
+  return navigator.platform ?? '';
+}

package/esm/empty.d.ts

@@ -0,0 +1,3 @@
+export declare function NOOP(): void;
+export declare const EMPTY_ARRAY: readonly any[];
+export declare const EMPTY_OBJECT: Readonly<{}>;

package/esm/empty.js

@@ -0,0 +1,3 @@
+export function NOOP() {}
+export const EMPTY_ARRAY = Object.freeze([]);
+export const EMPTY_OBJECT = Object.freeze({});

package/esm/error.d.ts

@@ -0,0 +1,2 @@
+export declare function error(...messages: string[]): void;
+export declare function reset(): void;

package/esm/error.js

@@ -0,0 +1,16 @@
+let set;
+if (process.env.NODE_ENV !== 'production') {
+  set = new Set();
+}
+export function error(...messages) {
+  if (process.env.NODE_ENV !== 'production') {
+    const messageKey = messages.join(' ');
+    if (!set.has(messageKey)) {
+      set.add(messageKey);
+      console.error(`Tale UI: ${messageKey}`);
+    }
+  }
+}
+export function reset() {
+  set?.clear();
+}

package/esm/fastHooks.d.ts

@@ -0,0 +1,14 @@
+import * as React from 'react';
+export type Instance = {
+  didInitialize: boolean;
+};
+type HookType = {
+  before: (instance: any) => void;
+  after: (instance: any) => void;
+};
+export declare function getInstance(): Instance | undefined;
+export declare function setInstance(instance: Instance | undefined): void;
+export declare function register(hook: HookType): void;
+export declare function fastComponent<P extends object, E extends HTMLElement, R extends React.ReactNode>(fn: (props: P) => R): typeof fn;
+export declare function fastComponentRef<P extends object, E extends Element, R extends React.ReactNode>(fn: (props: React.PropsWithoutRef<P>, forwardedRef: React.Ref<E>) => R): React.ForwardRefExoticComponent<React.PropsWithoutRef<P> & React.RefAttributes<E>>;
+export {};

package/esm/fastHooks.js

@@ -0,0 +1,43 @@
+import * as React from 'react';
+import { useRefWithInit } from "./useRefWithInit.js";
+const hooks = [];
+let currentInstance = undefined;
+export function getInstance() {
+  return currentInstance;
+}
+export function setInstance(instance) {
+  currentInstance = instance;
+}
+export function register(hook) {
+  hooks.push(hook);
+}
+export function fastComponent(fn) {
+  const FastComponent = (props, forwardedRef) => {
+    const instance = useRefWithInit(createInstance).current;
+    let result;
+    try {
+      currentInstance = instance;
+      for (const hook of hooks) {
+        hook.before(instance);
+      }
+      result = fn(props, forwardedRef);
+      for (const hook of hooks) {
+        hook.after(instance);
+      }
+      instance.didInitialize = true;
+    } finally {
+      currentInstance = undefined;
+    }
+    return result;
+  };
+  FastComponent.displayName = fn.displayName || fn.name;
+  return FastComponent;
+}
+export function fastComponentRef(fn) {
+  return /*#__PURE__*/React.forwardRef(fastComponent(fn));
+}
+function createInstance() {
+  return {
+    didInitialize: false
+  };
+}

package/esm/fastObjectShallowCompare.d.ts

@@ -0,0 +1 @@
+export declare function fastObjectShallowCompare<T extends Record<string, any> | null>(a: T, b: T): boolean;

package/esm/fastObjectShallowCompare.js

@@ -0,0 +1,29 @@
+// https://github.com/mui/mui-x/blob/master/packages/x-internals/src/fastObjectShallowCompare/fastObjectShallowCompare.ts
+const is = Object.is;
+export function fastObjectShallowCompare(a, b) {
+  if (a === b) {
+    return true;
+  }
+  if (!(a instanceof Object) || !(b instanceof Object)) {
+    return false;
+  }
+  let aLength = 0;
+  let bLength = 0;
+
+  /* eslint-disable guard-for-in */
+  for (const key in a) {
+    aLength += 1;
+    if (!is(a[key], b[key])) {
+      return false;
+    }
+    if (!(key in b)) {
+      return false;
+    }
+  }
+
+  /* eslint-disable-next-line @typescript-eslint/naming-convention, @typescript-eslint/no-unused-vars */
+  for (const _ in b) {
+    bLength += 1;
+  }
+  return aLength === bLength;
+}

package/esm/formatErrorMessage.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Creates a formatErrorMessage function with a custom URL and prefix.
+ * @param baseUrl - The base URL for the error page (e.g., 'https://tale-ui.com/production-error')
+ * @param prefix - The prefix for the error message (e.g., 'Tale UI')
+ * @returns A function that formats error messages with the given URL and prefix
+ */
+export declare function createFormatErrorMessage(baseUrl: string, prefix: string): (code: number, ...args: string[]) => string;
+/**
+ * WARNING: Don't import this directly. It's imported by the code generated by
+ * `@mui/interal-babel-plugin-minify-errors`. Make sure to always use string literals in `Error`
+ * constructors to ensure the plugin works as expected. Supported patterns include:
+ *   throw new Error('My message');
+ *   throw new Error(`My message: ${foo}`);
+ *   throw new Error(`My message: ${foo}` + 'another string');
+ *   ...
+ */
+declare const formatErrorMessage: (code: number, ...args: string[]) => string;
+export default formatErrorMessage;

package/esm/formatErrorMessage.js

@@ -0,0 +1,26 @@
+/**
+ * Creates a formatErrorMessage function with a custom URL and prefix.
+ * @param baseUrl - The base URL for the error page (e.g., 'https://tale-ui.com/production-error')
+ * @param prefix - The prefix for the error message (e.g., 'Tale UI')
+ * @returns A function that formats error messages with the given URL and prefix
+ */
+export function createFormatErrorMessage(baseUrl, prefix) {
+  return function formatErrorMessage(code, ...args) {
+    const url = new URL(baseUrl);
+    url.searchParams.set('code', code.toString());
+    args.forEach(arg => url.searchParams.append('args[]', arg));
+    return `${prefix} error #${code}; visit ${url} for the full message.`;
+  };
+}
+
+/**
+ * WARNING: Don't import this directly. It's imported by the code generated by
+ * `@mui/interal-babel-plugin-minify-errors`. Make sure to always use string literals in `Error`
+ * constructors to ensure the plugin works as expected. Supported patterns include:
+ *   throw new Error('My message');
+ *   throw new Error(`My message: ${foo}`);
+ *   throw new Error(`My message: ${foo}` + 'another string');
+ *   ...
+ */
+const formatErrorMessage = createFormatErrorMessage('https://base-ui.com/production-error', 'Tale UI');
+export default formatErrorMessage;

package/esm/generateId.d.ts

@@ -0,0 +1 @@
+export declare function generateId(prefix: string): string;

package/esm/generateId.js

@@ -0,0 +1,5 @@
+let counter = 0;
+export function generateId(prefix) {
+  counter += 1;
+  return `${prefix}-${Math.random().toString(36).slice(2, 6)}-${counter}`;
+}

package/esm/getReactElementRef.d.ts

@@ -0,0 +1,5 @@
+import * as React from 'react';
+/**
+ * Extracts the `ref` from a React element, handling different React versions.
+ */
+export declare function getReactElementRef(element: unknown): React.Ref<unknown> | null;

package/esm/getReactElementRef.js

@@ -0,0 +1,14 @@
+import * as React from 'react';
+import { isReactVersionAtLeast } from "./reactVersion.js";
+
+/**
+ * Extracts the `ref` from a React element, handling different React versions.
+ */
+export function getReactElementRef(element) {
+  if (! /*#__PURE__*/React.isValidElement(element)) {
+    return null;
+  }
+  const reactElement = element;
+  const propsWithRef = reactElement.props;
+  return (isReactVersionAtLeast(19) ? propsWithRef?.ref : reactElement.ref) ?? null;
+}

package/esm/inertValue.d.ts

@@ -0,0 +1 @@
+export declare function inertValue(value?: boolean): boolean | undefined;

package/esm/inertValue.js

@@ -0,0 +1,8 @@
+import { isReactVersionAtLeast } from "./reactVersion.js";
+export function inertValue(value) {
+  if (isReactVersionAtLeast(19)) {
+    return value;
+  }
+  // compatibility with React < 19
+  return value ? 'true' : undefined;
+}

package/esm/isElementDisabled.d.ts

@@ -0,0 +1 @@
+export declare function isElementDisabled(element: HTMLElement | null): boolean;

package/esm/isElementDisabled.js

@@ -0,0 +1,3 @@
+export function isElementDisabled(element) {
+  return element == null || element.hasAttribute('disabled') || element.getAttribute('aria-disabled') === 'true';
+}

package/esm/isMouseWithinBounds.d.ts

@@ -0,0 +1 @@
+export declare function isMouseWithinBounds(event: React.MouseEvent): boolean;

package/esm/isMouseWithinBounds.js

@@ -0,0 +1,10 @@
+export function isMouseWithinBounds(event) {
+  const targetRect = event.currentTarget.getBoundingClientRect();
+
+  // Safari randomly fires `mouseleave` incorrectly when the item is
+  // aligned to the trigger. This is a workaround to prevent the highlight
+  // from being removed while the cursor is still within the bounds of the item.
+  // https://github.com/mui/base-ui/issues/869
+  const isWithinBounds = targetRect.top + 1 <= event.clientY && event.clientY <= targetRect.bottom - 1 && targetRect.left + 1 <= event.clientX && event.clientX <= targetRect.right - 1;
+  return isWithinBounds;
+}

package/esm/mergeObjects.d.ts

@@ -0,0 +1 @@
+export declare function mergeObjects<A extends object | undefined, B extends object | undefined>(a: A, b: B): NonNullable<A> | NonNullable<B> | (A & B) | undefined;

package/esm/mergeObjects.js

@@ -0,0 +1,15 @@
+export function mergeObjects(a, b) {
+  if (a && !b) {
+    return a;
+  }
+  if (!a && b) {
+    return b;
+  }
+  if (a || b) {
+    return {
+      ...a,
+      ...b
+    };
+  }
+  return undefined;
+}

package/esm/owner.d.ts

@@ -0,0 +1,2 @@
+export { getWindow as ownerWindow } from '@floating-ui/utils/dom';
+export declare function ownerDocument(node: Element | null): Document;

package/esm/owner.js

@@ -0,0 +1,4 @@
+export { getWindow as ownerWindow } from '@floating-ui/utils/dom';
+export function ownerDocument(node) {
+  return node?.ownerDocument || document;
+}

package/esm/package.json

@@ -0,0 +1 @@
+{"type":"module","sideEffects":false}

package/esm/reactVersion.d.ts

@@ -0,0 +1,3 @@
+type SupportedVersions = 17 | 18 | 19;
+export declare function isReactVersionAtLeast(reactVersionToCheck: SupportedVersions): boolean;
+export {};

package/esm/reactVersion.js

@@ -0,0 +1,5 @@
+import * as React from 'react';
+const majorVersion = parseInt(React.version, 10);
+export function isReactVersionAtLeast(reactVersionToCheck) {
+  return majorVersion >= reactVersionToCheck;
+}

package/esm/safeReact.d.ts

@@ -0,0 +1,2 @@
+import * as React from 'react';
+export declare const SafeReact: typeof React;

package/esm/safeReact.js

@@ -0,0 +1,6 @@
+import * as React from 'react';
+
+// https://github.com/mui/material-ui/issues/41190#issuecomment-2040873379
+export const SafeReact = {
+  ...React
+};

package/esm/store/ReactStore.d.ts

@@ -0,0 +1,91 @@
+import { Store } from "./Store.js";
+/**
+ * A Store that supports controlled state keys, non-reactive values and provides utility methods for React.
+ */
+export declare class ReactStore<State extends object, Context = Record<string, never>, Selectors extends Record<string, SelectorFunction<State>> = Record<string, never>> extends Store<State> {
+  /**
+   * Creates a new ReactStore instance.
+   *
+   * @param state Initial state of the store.
+   * @param context Non-reactive context values.
+   * @param selectors Optional selectors for use with `useState`.
+   */
+  constructor(state: State, context?: Context, selectors?: Selectors);
+  /**
+   * Non-reactive values such as refs, callbacks, etc.
+   */
+  readonly context: Context;
+  private selectors;
+  /**
+   * Synchronizes a single external value into the store.
+   *
+   * Note that the while the value in `state` is updated immediately, the value returned
+   * by `useState` is updated before the next render (similarly to React's `useState`).
+   */
+  useSyncedValue<Key extends keyof State, Value extends State[Key]>(key: keyof State, value: Value): void;
+  /**
+   * Synchronizes a single external value into the store and
+   * cleans it up (sets to `undefined`) on unmount.
+   *
+   * Note that the while the value in `state` is updated immediately, the value returned
+   * by `useState` is updated before the next render (similarly to React's `useState`).
+   */
+  useSyncedValueWithCleanup<Key extends KeysAllowingUndefined<State>>(key: Key, value: State[Key]): void;
+  /**
+   * Synchronizes multiple external values into the store.
+   *
+   * Note that the while the values in `state` are updated immediately, the values returned
+   * by `useState` are updated before the next render (similarly to React's `useState`).
+   */
+  useSyncedValues(statePart: Partial<State>): void;
+  /**
+   * Registers a controllable prop pair (`controlled`, `defaultValue`) for a specific key. If `controlled`
+   * is non-undefined, the store's state at `key` is updated to match `controlled`.
+   */
+  useControlledProp<Key extends keyof State, Value extends State[Key]>(key: keyof State, controlled: Value | undefined): void;
+  /** Gets the current value from the store using a selector with the provided key.
+   *
+   * @param key Key of the selector to use.
+   */
+  select<Key extends keyof Selectors>(key: Key, ...args: SelectorArgs<Selectors[Key]>): ReturnType<Selectors[Key]>;
+  /**
+   * Returns a value from the store's state using a selector function.
+   * Used to subscribe to specific parts of the state.
+   * This methods causes a rerender whenever the selected state changes.
+   *
+   * @param key Key of the selector to use.
+   */
+  useState<Key extends keyof Selectors>(key: Key, ...args: SelectorArgs<Selectors[Key]>): ReturnType<Selectors[Key]>;
+  /**
+   * Wraps a function with `useStableCallback` to ensure it has a stable reference
+   * and assigns it to the context.
+   *
+   * @param key Key of the event callback. Must be a function in the context.
+   * @param fn Function to assign.
+   */
+  useContextCallback<Key extends ContextFunctionKeys<Context>>(key: Key, fn: ContextFunction<Context, Key> | undefined): void;
+  /**
+   * Returns a stable setter function for a specific key in the store's state.
+   * It's commonly used to pass as a ref callback to React elements.
+   *
+   * @param key Key of the state to set.
+   */
+  useStateSetter<const Key extends keyof State, Value extends State[Key]>(key: keyof State): (v: Value) => void;
+  /**
+   * Observes changes derived from the store's selectors and calls the listener when the selected value changes.
+   *
+   * @param key Key of the selector to observe.
+   * @param listener Listener function called when the selector result changes.
+   */
+  observe<Key extends keyof Selectors>(selector: Key, listener: (newValue: ReturnType<Selectors[Key]>, oldValue: ReturnType<Selectors[Key]>, store: this) => void): () => void;
+  observe<Selector extends ObserveSelector<State>>(selector: Selector, listener: (newValue: ReturnType<Selector>, oldValue: ReturnType<Selector>, store: this) => void): () => void;
+}
+type MaybeCallable = (...args: any[]) => any;
+type ContextFunctionKeys<Context> = { [Key in keyof Context]-?: Extract<Context[Key], MaybeCallable> extends never ? never : Key }[keyof Context];
+type ContextFunction<Context, Key extends keyof Context> = Extract<Context[Key], MaybeCallable>;
+type KeysAllowingUndefined<State> = { [Key in keyof State]-?: undefined extends State[Key] ? Key : never }[keyof State];
+type ObserveSelector<State> = (state: State) => any;
+type SelectorFunction<State> = (state: State, ...args: any[]) => any;
+type Tail<T extends readonly any[]> = T extends readonly [any, ...infer Rest] ? Rest : [];
+type SelectorArgs<Selector> = Selector extends ((...params: infer Params) => any) ? Tail<Params> : never;
+export {};