@ohos-ports/stacksjs-stx 0.2.287-beta.0

package/dist/state-management.js

@@ -0,0 +1,519 @@
+import { recordStoreMutation, registerStore as registerDevToolsStore } from "./devtools.js";
+const globalState = {
+  stores: new Map,
+  subscriptions: new Map
+};
+export function registerStore(name, store) {
+  globalState.stores.set(name, store);
+}
+export function getStore(name) {
+  return globalState.stores.get(name);
+}
+export function hasStore(name) {
+  return globalState.stores.has(name);
+}
+export function getStoreNames() {
+  return Array.from(globalState.stores.keys());
+}
+export function clearStores() {
+  for (const store of globalState.stores.values())
+    store.destroy();
+  globalState.stores.clear();
+  globalState.subscriptions.clear();
+}
+const memoryStorage = new Map;
+function getStorageAdapter(type) {
+  if (type === "memory")
+    return {
+      getItem: (key) => memoryStorage.get(key) ?? null,
+      setItem: (key, value) => memoryStorage.set(key, value),
+      removeItem: (key) => memoryStorage.delete(key)
+    };
+  if (typeof window > "u")
+    return {
+      getItem: (key) => memoryStorage.get(key) ?? null,
+      setItem: (key, value) => memoryStorage.set(key, value),
+      removeItem: (key) => memoryStorage.delete(key)
+    };
+  return type === "local" ? window.localStorage : window.sessionStorage;
+}
+function pickPaths(obj, paths) {
+  const result = {};
+  for (const path of paths) {
+    const parts = path.split(".");
+    let source = obj, target = result, valid = !0;
+    for (let i = 0;i < parts.length - 1; i++) {
+      const part = parts[i];
+      if (source && typeof source === "object" && part in source) {
+        source = source[part];
+        if (!(part in target))
+          target[part] = {};
+        target = target[part];
+      } else {
+        valid = !1;
+        break;
+      }
+    }
+    if (valid && source && typeof source === "object") {
+      const lastPart = parts[parts.length - 1];
+      if (lastPart in source)
+        target[lastPart] = source[lastPart];
+    }
+  }
+  return result;
+}
+export function createStore(initialValue, options = {}) {
+  const {
+    name,
+    persist,
+    devtools = !1,
+    middleware = [],
+    equals = (a, b) => a === b
+  } = options;
+  let currentValue = initialValue;
+  const subscribers = new Set;
+  let persistTimeout = null;
+  if (persist) {
+    const storage = getStorageAdapter(persist.storage || "local"), key = persist.key || `stx-store:${name || "unnamed"}`, deserialize = persist.deserialize || JSON.parse;
+    try {
+      const stored = storage.getItem(key);
+      if (stored) {
+        const parsed = deserialize(stored);
+        if (persist.paths && typeof parsed === "object" && parsed !== null)
+          currentValue = { ...initialValue, ...parsed };
+        else
+          currentValue = parsed;
+      }
+    } catch {}
+  }
+  const persistValue = (value) => {
+    if (!persist)
+      return;
+    const storage = getStorageAdapter(persist.storage || "local"), key = persist.key || `stx-store:${name || "unnamed"}`, serialize = persist.serialize || JSON.stringify, toPersist = persist.paths && typeof value === "object" && value !== null ? pickPaths(value, persist.paths) : value;
+    if (persist.debounce) {
+      if (persistTimeout)
+        clearTimeout(persistTimeout);
+      persistTimeout = setTimeout(() => {
+        storage.setItem(key, serialize(toPersist));
+      }, persist.debounce);
+    } else
+      storage.setItem(key, serialize(toPersist));
+  }, notify = (newValue, prevValue) => {
+    for (const subscriber of subscribers)
+      try {
+        subscriber(newValue, prevValue);
+      } catch (error) {
+        console.error("[stx-store] Subscriber error:", error);
+      }
+  }, devToolsNotify = devtools ? (action, newValue) => {
+    recordStoreMutation(name || "unnamed", action, currentValue, newValue);
+    if (typeof window < "u")
+      window.__STX_DEVTOOLS__?.onStoreChange?.(name || "unnamed", action, newValue);
+  } : () => {}, baseSet = (value) => {
+    const prevValue = currentValue;
+    if (!equals(value, prevValue)) {
+      currentValue = value;
+      persistValue(value);
+      notify(value, prevValue);
+      devToolsNotify("set", value);
+    }
+  };
+  let wrappedSet = baseSet;
+  const store = {
+    get: () => currentValue,
+    set: (value) => {
+      if (typeof value === "function")
+        wrappedSet(value(currentValue));
+      else
+        wrappedSet(value);
+    },
+    subscribe: (subscriber) => {
+      subscribers.add(subscriber);
+      return () => {
+        subscribers.delete(subscriber);
+      };
+    },
+    update: (updater) => {
+      if (typeof currentValue !== "object" || currentValue === null)
+        throw Error("update() can only be used with object stores");
+      const partial = typeof updater === "function" ? updater(currentValue) : updater;
+      store.set({ ...currentValue, ...partial });
+    },
+    reset: () => {
+      store.set(initialValue);
+      devToolsNotify("reset", initialValue);
+    },
+    name,
+    destroy: () => {
+      subscribers.clear();
+      if (persistTimeout)
+        clearTimeout(persistTimeout);
+      if (name)
+        globalState.stores.delete(name);
+    }
+  };
+  for (const mw of middleware.reverse())
+    wrappedSet = mw(baseSet, () => currentValue, store)(wrappedSet);
+  if (name) {
+    registerStore(name, store);
+    if (devtools)
+      registerDevToolsStore(name, currentValue ?? {}, {}, []);
+  }
+  return store;
+}
+export function createReadonlyStore(getter, options = {}) {
+  const subscribers = new Set;
+  let currentValue = getter();
+  return {
+    get: () => {
+      const newValue = getter();
+      if (newValue !== currentValue) {
+        const prevValue = currentValue;
+        currentValue = newValue;
+        for (const subscriber of subscribers)
+          subscriber(newValue, prevValue);
+      }
+      return currentValue;
+    },
+    subscribe: (subscriber) => {
+      subscribers.add(subscriber);
+      return () => {
+        subscribers.delete(subscriber);
+      };
+    },
+    name: options.name,
+    destroy: () => {
+      subscribers.clear();
+    }
+  };
+}
+export function computed(stores, compute, options = {}) {
+  const { equals = (a, b) => a === b } = options, getValues = () => stores.map((s) => s.get());
+  let currentValue = compute(...getValues());
+  const subscribers = new Set, unsubscribes = [];
+  for (const sourceStore of stores) {
+    const unsub = sourceStore.subscribe(() => {
+      const newValue = compute(...getValues());
+      if (!equals(newValue, currentValue)) {
+        const prevValue = currentValue;
+        currentValue = newValue;
+        for (const subscriber of subscribers)
+          subscriber(newValue, prevValue);
+      }
+    });
+    unsubscribes.push(unsub);
+  }
+  return {
+    get: () => currentValue,
+    set: () => {
+      throw Error("Cannot set a computed store");
+    },
+    subscribe: (subscriber) => {
+      subscribers.add(subscriber);
+      return () => {
+        subscribers.delete(subscriber);
+      };
+    },
+    update: () => {
+      throw Error("Cannot update a computed store");
+    },
+    reset: () => {
+      throw Error("Cannot reset a computed store");
+    },
+    destroy: () => {
+      for (const unsub of unsubscribes)
+        unsub();
+      subscribers.clear();
+    }
+  };
+}
+export function createAction(store, name, handler) {
+  return async (...params) => {
+    const currentState = store.get(), newState = await handler(currentState, ...params);
+    store.set(newState);
+    if (typeof window < "u")
+      window.__STX_DEVTOOLS__?.onAction?.(store.name || "unnamed", name, params);
+  };
+}
+export function createActions(store, actions) {
+  const result = {};
+  for (const [name, handler] of Object.entries(actions))
+    result[name] = createAction(store, name, handler);
+  return result;
+}
+export function createSelector(store, selector, options = {}) {
+  return computed([store], selector, options);
+}
+export function createMemoizedSelector(store, selector, deps) {
+  let cachedDeps, cachedResult;
+  return computed([store], (state) => {
+    const currentDeps = deps(state);
+    if (cachedDeps && cachedDeps.length === currentDeps.length) {
+      let changed = !1;
+      for (let i = 0;i < currentDeps.length; i++)
+        if (cachedDeps[i] !== currentDeps[i]) {
+          changed = !0;
+          break;
+        }
+      if (!changed && cachedResult !== void 0)
+        return cachedResult;
+    }
+    cachedDeps = currentDeps;
+    cachedResult = selector(state);
+    return cachedResult;
+  });
+}
+export function loggerMiddleware(name) {
+  return (_set, get) => (nextSet) => (value) => {
+    const prev = get();
+    console.group(`[stx-store${name ? `:${name}` : ""}] Update`);
+    console.log("Previous:", prev);
+    console.log("Next:", value);
+    console.groupEnd();
+    nextSet(value);
+  };
+}
+export function validationMiddleware(validate) {
+  return (_set, _get) => (nextSet) => (value) => {
+    const result = validate(value);
+    if (result === !0)
+      nextSet(value);
+    else if (typeof result === "string")
+      console.error(`[stx-store] Validation failed: ${result}`);
+    else
+      console.error("[stx-store] Validation failed");
+  };
+}
+export function immerMiddleware() {
+  return (_set, _get) => (nextSet) => (value) => {
+    const cloned = JSON.parse(JSON.stringify(value));
+    nextSet(cloned);
+  };
+}
+export function throttleMiddleware(ms) {
+  let lastCall = 0, pendingValue, timeout = null;
+  return (_set, _get) => (nextSet) => (value) => {
+    const now = Date.now();
+    if (now - lastCall >= ms) {
+      lastCall = now;
+      nextSet(value);
+    } else {
+      pendingValue = value;
+      if (!timeout)
+        timeout = setTimeout(() => {
+          if (pendingValue !== void 0) {
+            lastCall = Date.now();
+            nextSet(pendingValue);
+            pendingValue = void 0;
+          }
+          timeout = null;
+        }, ms - (now - lastCall));
+    }
+  };
+}
+export function useStore(nameOrStore) {
+  const store = typeof nameOrStore === "string" ? getStore(nameOrStore) : nameOrStore;
+  if (!store)
+    throw Error(`Store "${nameOrStore}" not found`);
+  return store.get();
+}
+export function createStoreDirective(storeName) {
+  const store = getStore(storeName);
+  if (!store)
+    throw Error(`Store "${storeName}" not found`);
+  return {
+    name: "store",
+    hasEndTag: !1,
+    handler: () => {
+      return JSON.stringify(store.get());
+    }
+  };
+}
+export function initDevTools() {
+  if (typeof window > "u")
+    return;
+  window.__STX_DEVTOOLS__ = {
+    stores: globalState.stores,
+    history: [],
+    onStoreChange(store, action, state) {
+      this.history.push({ store, action, state, timestamp: Date.now() });
+      if (this.history.length > 100)
+        this.history.shift();
+    },
+    onAction(store, action, _params) {
+      console.log(`[stx-devtools] ${store}.${action}`);
+    },
+    getState() {
+      const state = {};
+      for (const [name, store] of this.stores.entries())
+        state[name] = store.get();
+      return state;
+    },
+    getHistory() {
+      return this.history;
+    },
+    timeTravel(index) {
+      const entry = this.history[index];
+      if (entry) {
+        const store = getStore(entry.store);
+        if (store)
+          store.set(entry.state);
+      }
+    }
+  };
+}
+export function defineStore(id, setupOrOptions, extraOptions) {
+  if (typeof setupOrOptions === "function") {
+    if (typeof window < "u" && window.stx?.defineStore)
+      return window.stx.defineStore(id, setupOrOptions, extraOptions);
+    return setupOrOptions();
+  }
+  const options = setupOrOptions, {
+    state: initialState,
+    getters = {},
+    actions = {},
+    persist,
+    devtools = !0
+  } = options, resolvedInitialState = typeof initialState === "function" ? initialState() : initialState, persistOptions = persist === !0 ? { storage: "local", key: `stx-store:${id}` } : persist || void 0, store = createStore(resolvedInitialState, {
+    name: id,
+    persist: persistOptions,
+    devtools
+  }), storeProxy = new Proxy({}, {
+    get(_target, prop) {
+      const propStr = String(prop);
+      if (propStr === "$state")
+        return store.get();
+      if (propStr === "$subscribe")
+        return store.subscribe;
+      if (propStr === "$reset")
+        return store.reset;
+      if (propStr === "$patch")
+        return (partial) => {
+          if (typeof partial === "function") {
+            const draft = { ...store.get() };
+            partial(draft);
+            store.set(draft);
+          } else
+            store.update(partial);
+        };
+      if (propStr === "_store")
+        return store;
+      if (propStr === "$id")
+        return id;
+      if (propStr in getters)
+        return getters[propStr](store.get());
+      if (propStr in actions)
+        return (...args) => {
+          return actions[propStr].apply(storeProxy, args);
+        };
+      const state = store.get();
+      if (state && typeof state === "object" && propStr in state)
+        return state[propStr];
+      return;
+    },
+    set(_target, prop, value) {
+      const propStr = String(prop);
+      if (propStr.startsWith("$") || propStr === "_store")
+        return !1;
+      const state = store.get();
+      if (state && typeof state === "object") {
+        store.set({ ...state, [propStr]: value });
+        return !0;
+      }
+      return !1;
+    },
+    has(_target, prop) {
+      const propStr = String(prop), state = store.get();
+      return propStr.startsWith("$") || propStr === "_store" || propStr in getters || propStr in actions || state && typeof state === "object" && propStr in state;
+    },
+    ownKeys() {
+      const state = store.get();
+      return [
+        ...state && typeof state === "object" ? Object.keys(state) : [],
+        ...Object.keys(getters),
+        ...Object.keys(actions),
+        "$state",
+        "$subscribe",
+        "$reset",
+        "$patch",
+        "$id"
+      ];
+    },
+    getOwnPropertyDescriptor(_target, prop) {
+      return {
+        enumerable: !0,
+        configurable: !0,
+        get: () => this.get(_target, prop, storeProxy)
+      };
+    }
+  });
+  storeRegistry.set(id, storeProxy);
+  return storeProxy;
+}
+const storeRegistry = new Map;
+export function getDefinedStore(name) {
+  return storeRegistry.get(name);
+}
+export function getDefinedStoreNames() {
+  return Array.from(storeRegistry.keys());
+}
+export function hasDefinedStore(name) {
+  return storeRegistry.has(name);
+}
+export function generateStoreImportRuntime() {
+  return `
+// STX Store Runtime - extends stx global
+(function() {
+  if (typeof window === 'undefined') return;
+  var s = window.stx || {};
+
+  // Helper to wait for stores to be ready
+  s.waitForStore = function(storeName, timeout) {
+    timeout = timeout || 5000;
+    var start = Date.now();
+    return new Promise(function(resolve, reject) {
+      function check() {
+        var store = s.useStore ? s.useStore(storeName) : null;
+        if (store) {
+          resolve(store);
+        }
+else if (Date.now() - start > timeout) {
+          reject(new Error('Timeout waiting for store: '.concat(storeName)));
+        }
+else {
+          requestAnimationFrame(check);
+        }
+      }
+      check();
+    });
+  };
+
+  // Merge, never replace (#1804). s was seeded from window.stx above, so this
+  // keeps both any earlier keys and the object identity the waitForStore
+  // closure captured.
+  window.stx = Object.assign(window.stx || {}, s);
+})();
+`;
+}
+export function transformStoreImports(code) {
+  const storeRegex = /import\s*\{([^}]+)\}\s*from\s*['"](@stores|stx\/stores)['"]\s*;?\n?/g;
+  code = code.replace(storeRegex, (_match, imports) => {
+    return `const { ${imports.split(",").map((s) => s.trim()).filter(Boolean).join(", ")} } = window.__STX_STORES__
+`;
+  });
+  const composablesRegex = /import\s*\{([^}]+)\}\s*from\s*['"]@composables['"]\s*;?\n?/g;
+  code = code.replace(composablesRegex, (_match, imports) => {
+    return `const { ${imports.split(",").map((s) => s.trim()).filter(Boolean).join(", ")} } = window.__composables
+`;
+  });
+  return code;
+}
+export function registerStoresClient(stores) {
+  if (typeof window > "u")
+    return;
+  const w = window;
+  w.__STX_STORES__ = w.__STX_STORES__ || {};
+  for (const [name, store] of Object.entries(stores))
+    w.__STX_STORES__[name] = store;
+  window.dispatchEvent(new CustomEvent("stx:stores-ready", { detail: Object.keys(stores) }));
+}

package/dist/store-imports.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Store Import Transformation
+ *
+ * Transforms `import { x } from '@stores'` statements in client scripts
+ * into runtime lookups against the global store registry.
+ *
+ * @module store-imports
+ */
+/**
+ * Transform import statements from @stores to runtime code.
+ *
+ * Transforms:
+ * ```js
+ * import { appStore, chatStore } from '@stores'
+ * ```
+ *
+ * Into:
+ * ```js
+ * const { appStore, chatStore } = window.__STX_STORES__
+ * ```
+ *
+ * Also transforms @composables imports to window.__composables.
+ */
+export declare function transformStoreImports(code: string): string;
+/**
+ * Remove `import` statements from a store or composable module body.
+ *
+ * These files are concatenated into one browser IIFE, so their imports have to
+ * go: `state`, `derived` and `defineStore` are runtime globals rather than real
+ * modules, and leaving the statements in makes the transpiler emit `require()`
+ * calls that fail in the browser.
+ *
+ * The previous pattern was line-anchored (`^import\s+.*from …$`), so a
+ * multi-line specifier list survived it — and survived Bun's transpiler too,
+ * because `import` is legal at a module's top level. It only failed once the
+ * body had been wrapped in the shared IIFE, where an import is a SyntaxError
+ * that takes EVERY store in the bundle with it, reported as a misleading
+ * "Store not found" (stacksjs/stx#1859).
+ *
+ * `[^'"]` between `import` and `from` is what keeps a multi-line match from
+ * running past its own statement into the next one's specifier: the clause
+ * never contains a quote, and the module specifier always does.
+ *
+ * Shared by both loaders because they carried byte-identical copies, which is
+ * how one of them would have been fixed and the other left behind.
+ */
+export declare function stripModuleImports(code: string): string;

package/dist/store-imports.js

@@ -0,0 +1,16 @@
+export function transformStoreImports(code) {
+  const storeRegex = /import\s*\{([^}]+)\}\s*from\s*['"](@stores|stx\/stores)['"]\s*;?\n?/g;
+  code = code.replace(storeRegex, (_match, imports) => {
+    return `const { ${imports.split(",").map((s) => s.trim()).filter(Boolean).join(", ")} } = window.__STX_STORES__
+`;
+  });
+  const composablesRegex = /import\s*\{([^}]+)\}\s*from\s*['"]@composables['"]\s*;?\n?/g;
+  code = code.replace(composablesRegex, (_match, imports) => {
+    return `const { ${imports.split(",").map((s) => s.trim()).filter(Boolean).join(", ")} } = window.__composables
+`;
+  });
+  return code;
+}
+export function stripModuleImports(code) {
+  return code.replace(/^import\s+[^'"]*?from\s*['"][^'"]+['"]\s*;?[ \t]*$/gm, "").replace(/^import\s+['"][^'"]+['"]\s*;?[ \t]*$/gm, "");
+}

package/dist/store-loader.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Store Auto-Loader
+ *
+ * Discovers .ts files in storesDir, bundles them with Bun.build,
+ * and returns a <script> tag to inject into the page. Stores are
+ * registered before any <script client> blocks run, so useStore()
+ * always finds them.
+ *
+ * @module store-loader
+ */
+export declare function getStoreScript(storesDir?: string): Promise<string | null>;
+/**
+ * Clear the cached store script (for dev mode hot reload).
+ */
+export declare function clearStoreCache(): void;