@tale-ui/utils 0.0.3

package/fastHooks.js

@@ -0,0 +1,54 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.fastComponent = fastComponent;
+exports.fastComponentRef = fastComponentRef;
+exports.getInstance = getInstance;
+exports.register = register;
+exports.setInstance = setInstance;
+var React = _interopRequireWildcard(require("react"));
+var _useRefWithInit = require("./useRefWithInit");
+const hooks = [];
+let currentInstance = undefined;
+function getInstance() {
+  return currentInstance;
+}
+function setInstance(instance) {
+  currentInstance = instance;
+}
+function register(hook) {
+  hooks.push(hook);
+}
+function fastComponent(fn) {
+  const FastComponent = (props, forwardedRef) => {
+    const instance = (0, _useRefWithInit.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;
+}
+function fastComponentRef(fn) {
+  return /*#__PURE__*/React.forwardRef(fastComponent(fn));
+}
+function createInstance() {
+  return {
+    didInitialize: false
+  };
+}

package/fastObjectShallowCompare.d.ts

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

package/fastObjectShallowCompare.js

@@ -0,0 +1,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.fastObjectShallowCompare = fastObjectShallowCompare;
+// https://github.com/mui/mui-x/blob/master/packages/x-internals/src/fastObjectShallowCompare/fastObjectShallowCompare.ts
+const is = Object.is;
+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/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/formatErrorMessage.js

@@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createFormatErrorMessage = createFormatErrorMessage;
+exports.default = void 0;
+/**
+ * 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
+ */
+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');
+var _default = exports.default = formatErrorMessage;

package/generateId.d.ts

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

package/generateId.js

@@ -0,0 +1,11 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.generateId = generateId;
+let counter = 0;
+function generateId(prefix) {
+  counter += 1;
+  return `${prefix}-${Math.random().toString(36).slice(2, 6)}-${counter}`;
+}

package/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/getReactElementRef.js

@@ -0,0 +1,20 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getReactElementRef = getReactElementRef;
+var React = _interopRequireWildcard(require("react"));
+var _reactVersion = require("./reactVersion");
+/**
+ * Extracts the `ref` from a React element, handling different React versions.
+ */
+function getReactElementRef(element) {
+  if (! /*#__PURE__*/React.isValidElement(element)) {
+    return null;
+  }
+  const reactElement = element;
+  const propsWithRef = reactElement.props;
+  return ((0, _reactVersion.isReactVersionAtLeast)(19) ? propsWithRef?.ref : reactElement.ref) ?? null;
+}

package/inertValue.d.ts

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

package/inertValue.js

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.inertValue = inertValue;
+var _reactVersion = require("./reactVersion");
+function inertValue(value) {
+  if ((0, _reactVersion.isReactVersionAtLeast)(19)) {
+    return value;
+  }
+  // compatibility with React < 19
+  return value ? 'true' : undefined;
+}

package/isElementDisabled.d.ts

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

package/isElementDisabled.js

@@ -0,0 +1,9 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isElementDisabled = isElementDisabled;
+function isElementDisabled(element) {
+  return element == null || element.hasAttribute('disabled') || element.getAttribute('aria-disabled') === 'true';
+}

package/isMouseWithinBounds.d.ts

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

package/isMouseWithinBounds.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isMouseWithinBounds = isMouseWithinBounds;
+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/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/mergeObjects.js

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.mergeObjects = mergeObjects;
+function mergeObjects(a, b) {
+  if (a && !b) {
+    return a;
+  }
+  if (!a && b) {
+    return b;
+  }
+  if (a || b) {
+    return {
+      ...a,
+      ...b
+    };
+  }
+  return undefined;
+}

package/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/owner.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ownerDocument = ownerDocument;
+Object.defineProperty(exports, "ownerWindow", {
+  enumerable: true,
+  get: function () {
+    return _dom.getWindow;
+  }
+});
+var _dom = require("@floating-ui/utils/dom");
+function ownerDocument(node) {
+  return node?.ownerDocument || document;
+}

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@tale-ui/utils",
+  "version": "0.0.3",
+  "description": "A collection of React utility functions for Tale UI.",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Tale-UI/react.git",
+    "directory": "packages/utils"
+  },
+  "license": "MIT",
+  "type": "commonjs",
+  "dependencies": {
+    "@babel/runtime": "^7.28.6",
+    "@floating-ui/utils": "^0.2.10",
+    "reselect": "^5.1.1",
+    "use-sync-external-store": "^1.6.0"
+  },
+  "peerDependencies": {
+    "@types/react": "^17 || ^18 || ^19",
+    "react": "^17 || ^18 || ^19",
+    "react-dom": "^17 || ^18 || ^19"
+  },
+  "peerDependenciesMeta": {
+    "@types/react": {
+      "optional": true
+    }
+  },
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "exports": {
+    "./package.json": "./package.json",
+    "./store": {
+      "import": {
+        "types": "./esm/store/index.d.ts",
+        "default": "./esm/store/index.js"
+      },
+      "require": {
+        "types": "./store/index.d.ts",
+        "default": "./store/index.js"
+      },
+      "default": {
+        "types": "./esm/store/index.d.ts",
+        "default": "./esm/store/index.js"
+      }
+    },
+    "./*": {
+      "import": {
+        "types": "./esm/*.d.ts",
+        "default": "./esm/*.js"
+      },
+      "require": {
+        "types": "./*.d.ts",
+        "default": "./*.js"
+      },
+      "default": {
+        "types": "./esm/*.d.ts",
+        "default": "./esm/*.js"
+      }
+    },
+    "./esm": null
+  }
+}

package/reactVersion.d.ts

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

package/reactVersion.js

@@ -0,0 +1,12 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isReactVersionAtLeast = isReactVersionAtLeast;
+var React = _interopRequireWildcard(require("react"));
+const majorVersion = parseInt(React.version, 10);
+function isReactVersionAtLeast(reactVersionToCheck) {
+  return majorVersion >= reactVersionToCheck;
+}

package/safeReact.d.ts

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

package/safeReact.js

@@ -0,0 +1,12 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SafeReact = void 0;
+var React = _interopRequireWildcard(require("react"));
+// https://github.com/mui/material-ui/issues/41190#issuecomment-2040873379
+const SafeReact = exports.SafeReact = {
+  ...React
+};

package/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 {};