@thalesfp/snapstate 0.1.0

package/dist/react/index.cjs

@@ -0,0 +1,693 @@
+"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);
+
+// src/react/index.ts
+var react_exports = {};
+__export(react_exports, {
+  SnapStore: () => ReactSnapStore,
+  asyncStatus: () => asyncStatus,
+  setDefaultHeaders: () => setDefaultHeaders,
+  setHttpClient: () => setHttpClient
+});
+module.exports = __toCommonJS(react_exports);
+
+// src/react/store.ts
+var import_react = require("react");
+
+// src/core/types.ts
+var _statuses = {
+  idle: Object.freeze({ value: "idle", isIdle: true, isLoading: false, isReady: false, isError: false }),
+  loading: Object.freeze({ value: "loading", isIdle: false, isLoading: true, isReady: false, isError: false }),
+  ready: Object.freeze({ value: "ready", isIdle: false, isLoading: false, isReady: true, isError: false }),
+  error: Object.freeze({ value: "error", isIdle: false, isLoading: false, isReady: false, isError: true })
+};
+function asyncStatus(value) {
+  return _statuses[value];
+}
+
+// src/core/trie.ts
+function invokeAll(listeners) {
+  let firstError;
+  for (const l of listeners) {
+    try {
+      l();
+    } catch (e) {
+      firstError ??= e;
+    }
+  }
+  if (firstError !== void 0) {
+    throw firstError;
+  }
+}
+function createNode() {
+  return { listeners: /* @__PURE__ */ new Set(), children: /* @__PURE__ */ new Map() };
+}
+function parsePath(path) {
+  if (path === "") {
+    return [];
+  }
+  return path.split(".");
+}
+var SubscriptionTrie = class {
+  root = createNode();
+  globalListeners = /* @__PURE__ */ new Set();
+  /** Subscribe to a specific path. Returns unsubscribe function. */
+  add(path, listener) {
+    const segments = parsePath(path);
+    const parents = [];
+    let node = this.root;
+    for (const seg of segments) {
+      if (!node.children.has(seg)) {
+        node.children.set(seg, createNode());
+      }
+      parents.push({ parent: node, segment: seg });
+      node = node.children.get(seg);
+    }
+    node.listeners.add(listener);
+    return () => {
+      node.listeners.delete(listener);
+      for (let i = parents.length - 1; i >= 0; i--) {
+        const { parent, segment } = parents[i];
+        const child = parent.children.get(segment);
+        if (child.listeners.size === 0 && child.children.size === 0) {
+          parent.children.delete(segment);
+        } else {
+          break;
+        }
+      }
+    };
+  }
+  /** Subscribe to all changes (no path filter). */
+  addGlobal(listener) {
+    this.globalListeners.add(listener);
+    return () => {
+      this.globalListeners.delete(listener);
+    };
+  }
+  /** Notify listeners for exact path, all ancestors, and all descendants. */
+  notify(path) {
+    const segments = parsePath(path);
+    const collected = /* @__PURE__ */ new Set();
+    for (const l of this.globalListeners) collected.add(l);
+    let node = this.root;
+    for (const l of node.listeners) collected.add(l);
+    let matched = true;
+    for (const seg of segments) {
+      const wildcard = node.children.get("*");
+      if (wildcard) {
+        for (const l of wildcard.listeners) collected.add(l);
+        this.collectDescendants(wildcard, collected);
+      }
+      const child = node.children.get(seg);
+      if (!child) {
+        matched = false;
+        break;
+      }
+      node = child;
+      for (const l of node.listeners) collected.add(l);
+    }
+    if (matched) {
+      this.collectDescendants(node, collected);
+    }
+    invokeAll(collected);
+  }
+  /** Notify all listeners in the trie. */
+  notifyAll() {
+    const collected = /* @__PURE__ */ new Set();
+    for (const l of this.globalListeners) collected.add(l);
+    this.collectDescendants(this.root, collected);
+    for (const l of this.root.listeners) collected.add(l);
+    invokeAll(collected);
+  }
+  collectDescendants(node, out) {
+    for (const child of node.children.values()) {
+      for (const l of child.listeners) out.add(l);
+      this.collectDescendants(child, out);
+    }
+  }
+  clear() {
+    this.root = createNode();
+    this.globalListeners.clear();
+  }
+};
+
+// src/core/structural.ts
+function applyUpdate(state, path, value) {
+  const segments = path.split(".");
+  return updateAtPath(state, segments, 0, value);
+}
+function updateAtPath(current, segments, index, value) {
+  if (index === segments.length) {
+    if (typeof value === "function") {
+      return value(current);
+    }
+    return value;
+  }
+  const key = segments[index];
+  if (Array.isArray(current)) {
+    const i = Number(key);
+    const next2 = updateAtPath(current[i], segments, index + 1, value);
+    if (Object.is(next2, current[i])) {
+      return current;
+    }
+    const copy = current.slice();
+    copy[i] = next2;
+    return copy;
+  }
+  if (current !== null && typeof current === "object") {
+    const obj = current;
+    const next2 = updateAtPath(obj[key], segments, index + 1, value);
+    if (Object.is(next2, obj[key])) {
+      return current;
+    }
+    return { ...obj, [key]: next2 };
+  }
+  const next = updateAtPath(void 0, segments, index + 1, value);
+  return { [key]: next };
+}
+function getAtPath(state, path) {
+  if (path === "") {
+    return state;
+  }
+  const segments = path.split(".");
+  let current = state;
+  for (const seg of segments) {
+    if (current === null || current === void 0) {
+      return void 0;
+    }
+    current = current[seg];
+  }
+  return current;
+}
+
+// src/core/computed.ts
+function createComputed(host, deps, fn) {
+  let cachedValue;
+  let dirty = true;
+  const unsubs = [];
+  const markDirty = () => {
+    dirty = true;
+  };
+  for (const dep of deps) {
+    unsubs.push(host.subscribe(dep, markDirty));
+  }
+  try {
+    cachedValue = fn(host.getSnapshot());
+  } catch (e) {
+    for (const unsub of unsubs) unsub();
+    unsubs.length = 0;
+    throw e;
+  }
+  dirty = false;
+  return {
+    get() {
+      if (dirty) {
+        cachedValue = fn(host.getSnapshot());
+        dirty = false;
+      }
+      return cachedValue;
+    },
+    destroy() {
+      for (const unsub of unsubs) unsub();
+      unsubs.length = 0;
+    }
+  };
+}
+
+// src/core/store.ts
+function createStore(initialState, options = {}) {
+  const { autoBatch = true } = options;
+  let state = initialState;
+  const trie = new SubscriptionTrie();
+  let batchDepth = 0;
+  let pendingPaths = /* @__PURE__ */ new Set();
+  let microtaskScheduled = false;
+  function flushNotifications() {
+    const paths = pendingPaths;
+    pendingPaths = /* @__PURE__ */ new Set();
+    microtaskScheduled = false;
+    if (paths.size === 0) {
+      return;
+    }
+    const sorted = [...paths].sort();
+    const deduped = [];
+    for (const p of sorted) {
+      const last = deduped[deduped.length - 1];
+      if (last !== void 0 && p.startsWith(last + ".")) {
+        continue;
+      }
+      deduped.push(p);
+    }
+    for (const path of deduped) {
+      trie.notify(path);
+    }
+  }
+  function scheduleFlush() {
+    if (batchDepth > 0) {
+      return;
+    }
+    if (autoBatch && !microtaskScheduled) {
+      microtaskScheduled = true;
+      queueMicrotask(flushNotifications);
+    } else if (!autoBatch) {
+      flushNotifications();
+    }
+  }
+  function get(path) {
+    if (path === void 0 || path === "") {
+      return state;
+    }
+    return getAtPath(state, path);
+  }
+  function set(path, value) {
+    if (path === "") {
+      throw new Error("Cannot set with an empty path. Use a specific path to update state.");
+    }
+    const prev = state;
+    state = applyUpdate(state, path, value);
+    if (state !== prev) {
+      pendingPaths.add(path);
+      scheduleFlush();
+    }
+  }
+  function batch(fn) {
+    batchDepth++;
+    try {
+      fn();
+    } finally {
+      batchDepth--;
+      if (batchDepth === 0) {
+        flushNotifications();
+      }
+    }
+  }
+  function subscribe(pathOrCallback, callback) {
+    if (typeof pathOrCallback === "function") {
+      return trie.addGlobal(pathOrCallback);
+    }
+    return trie.add(pathOrCallback, callback);
+  }
+  function getSnapshot() {
+    return state;
+  }
+  function computed(deps, fn) {
+    return createComputed({ getSnapshot, subscribe }, deps, fn);
+  }
+  function notify() {
+    trie.notifyAll();
+  }
+  function destroy() {
+    trie.clear();
+    pendingPaths.clear();
+  }
+  return {
+    get,
+    set,
+    batch,
+    subscribe,
+    getSnapshot,
+    computed,
+    notify,
+    destroy
+  };
+}
+
+// src/core/base.ts
+var IDLE_STATE = { status: asyncStatus("idle"), error: null };
+var defaultHttpClient = {
+  async request(url, init) {
+    const fetchInit = { method: init?.method ?? "GET" };
+    const merged = { ...defaultHeaders, ...init?.headers };
+    if (Object.keys(merged).length) {
+      fetchInit.headers = merged;
+    }
+    if (init?.body !== void 0) {
+      fetchInit.body = JSON.stringify(init.body);
+      fetchInit.headers = { "Content-Type": "application/json", ...merged };
+    }
+    const res = await fetch(url, fetchInit);
+    if (!res.ok) {
+      let message = `HTTP ${res.status}`;
+      try {
+        const text2 = await res.text();
+        if (text2) {
+          const json = JSON.parse(text2);
+          message = json.error ?? json.message ?? message;
+        }
+      } catch {
+      }
+      throw new Error(message);
+    }
+    const text = await res.text();
+    return text ? JSON.parse(text) : void 0;
+  }
+};
+var httpClient = defaultHttpClient;
+var defaultHeaders = {};
+function setHttpClient(client) {
+  httpClient = client;
+}
+function setDefaultHeaders(headers) {
+  defaultHeaders = headers;
+}
+var SnapStore = class {
+  _store;
+  _operations = /* @__PURE__ */ new Map();
+  _generations = /* @__PURE__ */ new Map();
+  state;
+  api;
+  constructor(initialState, options) {
+    this._store = createStore(initialState, options);
+    const store = this._store;
+    const operations = this._operations;
+    const generations = this._generations;
+    const doFetch = async (key, fn) => {
+      const gen = (generations.get(key) ?? 0) + 1;
+      generations.set(key, gen);
+      operations.set(key, { status: asyncStatus("loading"), error: null });
+      store.notify();
+      try {
+        await fn();
+        if (generations.get(key) !== gen) {
+          return;
+        }
+        operations.set(key, { status: asyncStatus("ready"), error: null });
+      } catch (e) {
+        if (generations.get(key) !== gen) {
+          return;
+        }
+        operations.set(key, {
+          status: asyncStatus("error"),
+          error: e instanceof Error ? e.message : "Unknown error"
+        });
+        store.notify();
+        throw e;
+      }
+      store.notify();
+    };
+    const doSend = async (key, method, url, options2) => {
+      await doFetch(key, async () => {
+        try {
+          const data = await httpClient.request(url, {
+            method,
+            body: options2?.body,
+            headers: options2?.headers
+          });
+          options2?.onSuccess?.(data);
+        } catch (e) {
+          options2?.onError?.(e instanceof Error ? e : new Error("Unknown error"));
+          throw e;
+        }
+      });
+    };
+    this.state = {
+      get: ((path) => {
+        if (path === void 0) {
+          return store.get();
+        }
+        return store.get(path);
+      }),
+      set: (path, value) => store.set(path, value),
+      batch: (fn) => store.batch(fn),
+      computed: (deps, fn) => store.computed(deps, fn),
+      append: (path, ...items) => {
+        store.set(path, ((prev) => [...prev, ...items]));
+      },
+      prepend: (path, ...items) => {
+        store.set(path, ((prev) => [...items, ...prev]));
+      },
+      insertAt: (path, index, ...items) => {
+        store.set(path, ((prev) => {
+          const arr = prev;
+          return [...arr.slice(0, index), ...items, ...arr.slice(index)];
+        }));
+      },
+      patch: (path, predicate, updates) => {
+        store.set(path, ((prev) => {
+          const arr = prev;
+          let changed = false;
+          const result = arr.map((item) => {
+            if (item == null) {
+              return item;
+            }
+            if (predicate(item)) {
+              changed = true;
+              return Object.assign(Object.create(Object.getPrototypeOf(item)), item, updates);
+            }
+            return item;
+          });
+          return changed ? result : arr;
+        }));
+      },
+      remove: (path, predicate) => {
+        store.set(path, ((prev) => {
+          const arr = prev;
+          const result = arr.filter((item) => !predicate(item));
+          return result.length === arr.length ? arr : result;
+        }));
+      },
+      removeAt: (path, index) => {
+        store.set(path, ((prev) => {
+          const arr = prev;
+          const i = index < 0 ? arr.length + index : index;
+          if (i < 0 || i >= arr.length) {
+            throw new RangeError(`Index ${index} out of bounds for array of length ${arr.length}`);
+          }
+          return [...arr.slice(0, i), ...arr.slice(i + 1)];
+        }));
+      },
+      at: (path, index) => {
+        return store.get(path).at(index);
+      },
+      filter: (path, predicate) => {
+        return store.get(path).filter(predicate);
+      },
+      find: (path, predicate) => {
+        return store.get(path).find(predicate);
+      },
+      findIndexOf: (path, predicate) => {
+        return store.get(path).findIndex(predicate);
+      },
+      count: (path, predicate) => {
+        return store.get(path).filter(predicate).length;
+      }
+    };
+    this.api = {
+      fetch: doFetch,
+      get: async (key, url, onSuccess) => {
+        await doFetch(key, async () => {
+          const data = await httpClient.request(url);
+          onSuccess?.(data);
+        });
+      },
+      post: (key, url, options2) => doSend(key, "POST", url, options2),
+      put: (key, url, options2) => doSend(key, "PUT", url, options2),
+      patch: (key, url, options2) => doSend(key, "PATCH", url, options2),
+      delete: (key, url, options2) => doSend(key, "DELETE", url, options2)
+    };
+  }
+  subscribe(pathOrCallback, callback) {
+    if (typeof pathOrCallback === "function") {
+      return this._store.subscribe(pathOrCallback);
+    }
+    return this._store.subscribe(pathOrCallback, callback);
+  }
+  /** Return a snapshot of the current state. Compatible with React's `useSyncExternalStore`. */
+  getSnapshot = () => {
+    return this._store.getSnapshot();
+  };
+  /** Get the async status of an operation by key. Returns `idle` if never started. */
+  getStatus(key) {
+    return { ...this._operations.get(key) ?? IDLE_STATE };
+  }
+  /** Tear down subscriptions and cleanup. */
+  destroy() {
+    this._store.destroy();
+  }
+};
+
+// src/react/store.ts
+function shallowEqual(a, b) {
+  const keysA = Object.keys(a);
+  const keysB = Object.keys(b);
+  if (keysA.length !== keysB.length) {
+    return false;
+  }
+  for (const key of keysA) {
+    if (a[key] !== b[key]) {
+      return false;
+    }
+  }
+  return true;
+}
+var ReactSnapStore = class extends SnapStore {
+  constructor(initialState, options) {
+    super(initialState, options);
+  }
+  connect(Component, configOrMapper) {
+    const store = this;
+    if (typeof configOrMapper === "object" && "select" in configOrMapper) {
+      return this._connectWithSelect(Component, configOrMapper.select);
+    }
+    const mapToProps = typeof configOrMapper === "function" ? configOrMapper : configOrMapper.props;
+    const fetchFn = typeof configOrMapper === "function" ? void 0 : configOrMapper.fetch;
+    const loadingComponent = typeof configOrMapper === "function" ? void 0 : configOrMapper.loading;
+    const errorComponent = typeof configOrMapper === "function" ? void 0 : configOrMapper.error;
+    const Connected = (0, import_react.forwardRef)(function Connected2(ownProps, ref) {
+      const cachedRef = (0, import_react.useRef)(null);
+      const revisionRef = (0, import_react.useRef)(0);
+      const subscribe = (0, import_react.useCallback)(
+        (cb) => store.subscribe(() => {
+          revisionRef.current++;
+          cb();
+        }),
+        [store]
+      );
+      const getSnapshot = (0, import_react.useCallback)(() => {
+        const currentRevision = revisionRef.current;
+        if (cachedRef.current && cachedRef.current.revision === currentRevision) {
+          return cachedRef.current.props;
+        }
+        const next = mapToProps(store);
+        if (cachedRef.current && shallowEqual(cachedRef.current.props, next)) {
+          cachedRef.current = { revision: currentRevision, props: cachedRef.current.props };
+          return cachedRef.current.props;
+        }
+        cachedRef.current = { revision: currentRevision, props: next };
+        return next;
+      }, [store]);
+      const mappedProps = (0, import_react.useSyncExternalStore)(subscribe, getSnapshot, getSnapshot);
+      const [asyncState, setAsyncState] = (0, import_react.useState)({ status: asyncStatus("idle"), error: null });
+      const fetchGenRef = (0, import_react.useRef)(0);
+      (0, import_react.useEffect)(() => {
+        if (!fetchFn) {
+          return;
+        }
+        let cancelled = false;
+        const gen = ++fetchGenRef.current;
+        setAsyncState({ status: asyncStatus("loading"), error: null });
+        Promise.resolve().then(() => {
+          if (cancelled) {
+            return;
+          }
+          return fetchFn(store);
+        }).then(() => {
+          if (gen === fetchGenRef.current) {
+            setAsyncState({ status: asyncStatus("ready"), error: null });
+          }
+        }).catch((e) => {
+          if (gen === fetchGenRef.current) {
+            setAsyncState({
+              status: asyncStatus("error"),
+              error: e instanceof Error ? e.message : "Unknown error"
+            });
+          }
+        });
+        return () => {
+          cancelled = true;
+        };
+      }, []);
+      if (fetchFn) {
+        if (loadingComponent && (asyncState.status.isIdle || asyncState.status.isLoading)) {
+          return (0, import_react.createElement)(loadingComponent);
+        }
+        if (errorComponent && asyncState.status.isError) {
+          return (0, import_react.createElement)(errorComponent, { error: asyncState.error });
+        }
+      }
+      return (0, import_react.createElement)(Component, {
+        ...ownProps,
+        ...mappedProps,
+        ...fetchFn ? asyncState : {},
+        ref
+      });
+    });
+    Connected.displayName = `Connect(${Component.displayName || Component.name || "Component"})`;
+    return Connected;
+  }
+  _connectWithSelect(Component, selectFn) {
+    const store = this;
+    const resolvePathValue = (path) => {
+      const segments = path.split(".");
+      let val = store.getSnapshot();
+      for (const seg of segments) {
+        if (val == null) {
+          return void 0;
+        }
+        val = val[seg];
+      }
+      return val;
+    };
+    const trackedPaths = [];
+    const trackingPick = ((path) => {
+      trackedPaths.push(path);
+      return resolvePathValue(path);
+    });
+    selectFn(trackingPick);
+    const paths = [...trackedPaths];
+    const readPick = ((path) => {
+      return resolvePathValue(path);
+    });
+    const Connected = (0, import_react.forwardRef)(function Connected2(ownProps, ref) {
+      const cachedRef = (0, import_react.useRef)(null);
+      const revisionRef = (0, import_react.useRef)(0);
+      const subscribe = (0, import_react.useCallback)(
+        (cb) => {
+          const unsubs = paths.map(
+            (p) => store.subscribe(p, () => {
+              revisionRef.current++;
+              cb();
+            })
+          );
+          return () => unsubs.forEach((u) => u());
+        },
+        [store]
+      );
+      const getSnapshot = (0, import_react.useCallback)(() => {
+        const currentRevision = revisionRef.current;
+        if (cachedRef.current && cachedRef.current.revision === currentRevision) {
+          return cachedRef.current.props;
+        }
+        const next = selectFn(readPick);
+        if (cachedRef.current && shallowEqual(cachedRef.current.props, next)) {
+          cachedRef.current = { revision: currentRevision, props: cachedRef.current.props };
+          return cachedRef.current.props;
+        }
+        cachedRef.current = { revision: currentRevision, props: next };
+        return next;
+      }, [store]);
+      const mappedProps = (0, import_react.useSyncExternalStore)(subscribe, getSnapshot, getSnapshot);
+      return (0, import_react.createElement)(Component, {
+        ...ownProps,
+        ...mappedProps,
+        ref
+      });
+    });
+    Connected.displayName = `Connect(${Component.displayName || Component.name || "Component"})`;
+    return Connected;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SnapStore,
+  asyncStatus,
+  setDefaultHeaders,
+  setHttpClient
+});
+//# sourceMappingURL=index.cjs.map