@octanejs/base-ui 0.1.30 → 0.1.32

package/dist/cjs/utils/store/ReactStore.cjs

@@ -0,0 +1,135 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ReactStore_exports = {};
+__export(ReactStore_exports, {
+  ReactStore: () => ReactStore
+});
+module.exports = __toCommonJS(ReactStore_exports);
+var import_octane = require("octane");
+var import_useStableCallback = require("../useStableCallback.cjs");
+var import_noop = require("../noop.cjs");
+var import_Store = require("./Store.cjs");
+var import_useStore = require("./useStore.cjs");
+class ReactStore extends import_Store.Store {
+  context;
+  selectors;
+  constructor(state, context = {}, selectors) {
+    super(state);
+    this.context = context;
+    this.selectors = selectors;
+  }
+  /** Sync a single external value into the store (in a layout effect). */
+  useSyncedValue(key, value, slot) {
+    const store = this;
+    (0, import_octane.useLayoutEffect)(
+      () => {
+        if (store.state[key] !== value) {
+          store.set(key, value);
+        }
+      },
+      [store, key, value],
+      slot
+    );
+  }
+  /** Sync a single external value into the store; reset to `undefined` on unmount. */
+  useSyncedValueWithCleanup(key, value, slot) {
+    const store = this;
+    (0, import_octane.useLayoutEffect)(
+      () => {
+        if (store.state[key] !== value) {
+          store.set(key, value);
+        }
+        return () => {
+          store.set(key, void 0);
+        };
+      },
+      [store, key, value],
+      slot
+    );
+  }
+  /** Sync multiple external values into the store. */
+  useSyncedValues(statePart, slot) {
+    const store = this;
+    const dependencies = Object.values(statePart);
+    (0, import_octane.useLayoutEffect)(
+      () => {
+        store.update(statePart);
+      },
+      [store, ...dependencies],
+      slot
+    );
+  }
+  /** Register a controllable prop: when `controlled` is defined, the store key tracks it. */
+  useControlledProp(key, controlled, slot) {
+    const store = this;
+    const isControlled = controlled !== void 0;
+    (0, import_octane.useLayoutEffect)(
+      () => {
+        if (isControlled && !Object.is(store.state[key], controlled)) {
+          store.setState({ ...store.state, [key]: controlled });
+        }
+      },
+      [store, key, controlled, isControlled],
+      slot
+    );
+  }
+  /** Non-hook: read a selector's current value synchronously. */
+  select(key, a1, a2, a3) {
+    const selector = this.selectors[key];
+    return selector(this.state, a1, a2, a3);
+  }
+  /** Subscribe to a selector's value (re-renders on change). */
+  useState(key, slot, a1, a2, a3) {
+    return (0, import_useStore.useStore)(this, this.selectors[key], slot, a1, a2, a3);
+  }
+  /** Wrap a callback with `useStableCallback` and assign it to `context[key]`. */
+  useContextCallback(key, fn, slot) {
+    const stableFunction = (0, import_useStableCallback.useStableCallback)(fn ?? import_noop.NOOP, slot);
+    this.context[key] = stableFunction;
+  }
+  /** A stable ref-callback setter for a state key (commonly passed as a `ref`). */
+  useStateSetter(key, slot) {
+    const store = this;
+    const ref = (0, import_octane.useRef)(void 0, slot);
+    if (ref.current === void 0) {
+      ref.current = (value) => {
+        store.set(key, value);
+      };
+    }
+    return ref.current;
+  }
+  /** Non-hook: observe a selector; call `listener` when its value changes (fires once now). */
+  observe(selector, listener) {
+    const selectFn = typeof selector === "function" ? selector : this.selectors[selector];
+    let prevValue = selectFn(this.state);
+    listener(prevValue, prevValue, this);
+    return this.subscribe((nextState) => {
+      const nextValue = selectFn(nextState);
+      if (!Object.is(prevValue, nextValue)) {
+        const oldValue = prevValue;
+        prevValue = nextValue;
+        listener(nextValue, oldValue, this);
+      }
+    });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ReactStore
+});

package/dist/cjs/utils/store/Store.cjs

@@ -0,0 +1,83 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var Store_exports = {};
+__export(Store_exports, {
+  Store: () => Store
+});
+module.exports = __toCommonJS(Store_exports);
+var import_useStore = require("./useStore.cjs");
+class Store {
+  state;
+  listeners;
+  // Internal state to handle recursive `setState()` calls.
+  updateTick;
+  constructor(state) {
+    this.state = state;
+    this.listeners = /* @__PURE__ */ new Set();
+    this.updateTick = 0;
+  }
+  subscribe = (fn) => {
+    this.listeners.add(fn);
+    return () => {
+      this.listeners.delete(fn);
+    };
+  };
+  getSnapshot = () => {
+    return this.state;
+  };
+  setState(newState) {
+    if (this.state === newState) {
+      return;
+    }
+    this.state = newState;
+    this.updateTick += 1;
+    const currentTick = this.updateTick;
+    for (const listener of this.listeners) {
+      if (currentTick !== this.updateTick) {
+        return;
+      }
+      listener(newState);
+    }
+  }
+  update(changes) {
+    for (const key in changes) {
+      if (!Object.is(this.state[key], changes[key])) {
+        this.setState({ ...this.state, ...changes });
+        return;
+      }
+    }
+  }
+  set(key, value) {
+    if (!Object.is(this.state[key], value)) {
+      this.setState({ ...this.state, [key]: value });
+    }
+  }
+  notifyAll() {
+    const newState = { ...this.state };
+    this.setState(newState);
+  }
+  // octane: slot is threaded explicitly (was `use(selector, ...args)` in React).
+  use(selector, slot, a1, a2, a3) {
+    return (0, import_useStore.useStore)(this, selector, slot, a1, a2, a3);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Store
+});

package/dist/cjs/utils/store/createSelector.cjs

@@ -0,0 +1,74 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var createSelector_exports = {};
+__export(createSelector_exports, {
+  createSelector: () => createSelector
+});
+module.exports = __toCommonJS(createSelector_exports);
+const createSelector = ((a, b, c, d, e, f, ...other) => {
+  if (other.length > 0) {
+    throw new Error("Unsupported number of selectors");
+  }
+  let selector;
+  if (a && b && c && d && e && f) {
+    selector = (state, a1, a2, a3) => {
+      const va = a(state, a1, a2, a3);
+      const vb = b(state, a1, a2, a3);
+      const vc = c(state, a1, a2, a3);
+      const vd = d(state, a1, a2, a3);
+      const ve = e(state, a1, a2, a3);
+      return f(va, vb, vc, vd, ve, a1, a2, a3);
+    };
+  } else if (a && b && c && d && e) {
+    selector = (state, a1, a2, a3) => {
+      const va = a(state, a1, a2, a3);
+      const vb = b(state, a1, a2, a3);
+      const vc = c(state, a1, a2, a3);
+      const vd = d(state, a1, a2, a3);
+      return e(va, vb, vc, vd, a1, a2, a3);
+    };
+  } else if (a && b && c && d) {
+    selector = (state, a1, a2, a3) => {
+      const va = a(state, a1, a2, a3);
+      const vb = b(state, a1, a2, a3);
+      const vc = c(state, a1, a2, a3);
+      return d(va, vb, vc, a1, a2, a3);
+    };
+  } else if (a && b && c) {
+    selector = (state, a1, a2, a3) => {
+      const va = a(state, a1, a2, a3);
+      const vb = b(state, a1, a2, a3);
+      return c(va, vb, a1, a2, a3);
+    };
+  } else if (a && b) {
+    selector = (state, a1, a2, a3) => {
+      const va = a(state, a1, a2, a3);
+      return b(va, a1, a2, a3);
+    };
+  } else if (a) {
+    selector = a;
+  } else {
+    throw new Error("Missing arguments");
+  }
+  return selector;
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createSelector
+});

package/dist/cjs/utils/store/useStore.cjs

@@ -0,0 +1,51 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var useStore_exports = {};
+__export(useStore_exports, {
+  useStore: () => useStore
+});
+module.exports = __toCommonJS(useStore_exports);
+var import_octane = require("octane");
+var import_internal = require("../../internal.cjs");
+function useStore(store, selector, slot, a1, a2, a3) {
+  const cache = (0, import_octane.useRef)(
+    { hasValue: false, value: void 0 },
+    (0, import_internal.subSlot)(slot, "sel")
+  );
+  const select = (state) => {
+    const next = selector(state, a1, a2, a3);
+    const c = cache.current;
+    if (c.hasValue && Object.is(c.value, next)) {
+      return c.value;
+    }
+    c.hasValue = true;
+    c.value = next;
+    return next;
+  };
+  return (0, import_octane.useSyncExternalStore)(
+    store.subscribe,
+    () => select(store.getSnapshot()),
+    () => select(store.getSnapshot()),
+    (0, import_internal.subSlot)(slot, "uses")
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useStore
+});

package/dist/cjs/utils/stringifyLocale.cjs

@@ -0,0 +1,36 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var stringifyLocale_exports = {};
+__export(stringifyLocale_exports, {
+  stringifyLocale: () => stringifyLocale
+});
+module.exports = __toCommonJS(stringifyLocale_exports);
+function stringifyLocale(locale) {
+  if (Array.isArray(locale)) {
+    return locale.map((value) => stringifyLocale(value)).join(",");
+  }
+  if (locale == null) {
+    return "";
+  }
+  return String(locale);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  stringifyLocale
+});