storion 0.8.3 → 0.10.0

package/dist/effect-C6h0PDDI.js

@@ -1,446 +0,0 @@
-import { e as emitter } from "./emitter-j4rC71vY.js";
-import { i as isPromiseLike } from "./isPromiseLike-bFkfHAbm.js";
-class StorionError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "StorionError";
-  }
-}
-class SetupPhaseError extends StorionError {
-  constructor(method, hint) {
-    super(
-      `${method}() can only be called during setup phase. Do not call ${method}() inside actions or async callbacks.` + (hint ? ` ${hint}` : "")
-    );
-    this.name = "SetupPhaseError";
-  }
-}
-class LifetimeMismatchError extends StorionError {
-  constructor(parentName, childName, operation) {
-    super(
-      `Lifetime mismatch: Store "${parentName}" (keepAlive) cannot ${operation} store "${childName}" (autoDispose). A long-lived store cannot ${operation} a store that may be disposed. Either change "${parentName}" to autoDispose, or change "${childName}" to keepAlive.`
-    );
-    this.name = "LifetimeMismatchError";
-  }
-}
-class AsyncFunctionError extends StorionError {
-  constructor(context, hint) {
-    super(`${context} must be synchronous. ${hint}`);
-    this.name = "AsyncFunctionError";
-  }
-}
-class StoreDisposedError extends StorionError {
-  constructor(storeId) {
-    super(`Cannot call action on disposed store: ${storeId}`);
-    this.name = "StoreDisposedError";
-  }
-}
-class InvalidActionError extends StorionError {
-  constructor(actionName, actualType) {
-    super(
-      `Action "${actionName}" must be a function, got ${actualType}. If using focus(), destructure it and return the getter/setter separately: const [get, set] = focus("path"); return { get, set };`
-    );
-    this.name = "InvalidActionError";
-  }
-}
-class HooksContextError extends StorionError {
-  constructor(method, requiredContext) {
-    super(
-      `${method}() must be called inside ${requiredContext}. It requires an active tracking context.`
-    );
-    this.name = "HooksContextError";
-  }
-}
-class ProviderMissingError extends StorionError {
-  constructor(hook, provider) {
-    super(`${hook} must be used within a ${provider}`);
-    this.name = "ProviderMissingError";
-  }
-}
-class LocalStoreDependencyError extends StorionError {
-  constructor(storeName, dependencyCount) {
-    super(
-      `Local store must not have dependencies, but "${storeName}" has ${dependencyCount} dependencies. Use useStore() with a global container for stores with dependencies.`
-    );
-    this.name = "LocalStoreDependencyError";
-  }
-}
-class EffectRefreshError extends StorionError {
-  constructor() {
-    super("Effect is already running, cannot refresh");
-    this.name = "EffectRefreshError";
-  }
-}
-let globalHooks = {
-  scheduleNotification(notify) {
-    notify();
-  },
-  scheduleEffect(runEffect) {
-    runEffect();
-  }
-};
-function getHooks() {
-  return globalHooks;
-}
-function hasReadHook() {
-  return globalHooks.onRead !== void 0;
-}
-function hasWriteHook() {
-  return globalHooks.onWrite !== void 0;
-}
-function withHooks(hooksOrSetup, fn, onFinish) {
-  const prev = globalHooks;
-  if (typeof hooksOrSetup === "function") {
-    globalHooks = {
-      ...globalHooks,
-      ...hooksOrSetup(prev)
-    };
-  } else {
-    globalHooks = { ...prev, ...hooksOrSetup };
-  }
-  try {
-    return fn();
-  } finally {
-    globalHooks = prev;
-    onFinish == null ? void 0 : onFinish();
-  }
-}
-function trackRead(storeId, prop, value, subscribe) {
-  var _a;
-  const key = `${storeId}.${prop}`;
-  (_a = globalHooks.onRead) == null ? void 0 : _a.call(globalHooks, { key, value, subscribe });
-}
-function trackWrite(storeId, prop, next, prev) {
-  var _a;
-  const key = `${storeId}.${prop}`;
-  (_a = globalHooks.onWrite) == null ? void 0 : _a.call(globalHooks, { key, next, prev });
-}
-function untrack(fn) {
-  return withHooks({ onRead: void 0, onWrite: void 0 }, fn);
-}
-function scheduleNotification(notify, key) {
-  globalHooks.scheduleNotification(notify, key);
-}
-function batch(fn) {
-  const pending = /* @__PURE__ */ new Map();
-  return withHooks(
-    (current) => ({
-      ...current,
-      scheduleNotification: (notify, key) => {
-        const actualKey = key ?? notify;
-        pending.set(actualKey, notify);
-      }
-    }),
-    fn,
-    // Flush on finish
-    () => {
-      for (const notify of pending.values()) {
-        notify();
-      }
-    }
-  );
-}
-function createEffectContext(nth, onRefresh) {
-  let cleanupEmitter = null;
-  let abortController = null;
-  let isStale = false;
-  const runCleanups = () => {
-    if (isStale) return;
-    isStale = true;
-    if (abortController) {
-      abortController.abort();
-      abortController = null;
-    }
-    if (cleanupEmitter && cleanupEmitter.size > 0) {
-      cleanupEmitter.emitAndClearLifo();
-    }
-  };
-  function wrapPromise(promise) {
-    return new Promise((resolve, reject) => {
-      promise.then(
-        (value) => {
-          if (!isStale) {
-            resolve(value);
-          }
-        },
-        (error) => {
-          if (!isStale) {
-            reject(error);
-          }
-        }
-      );
-    });
-  }
-  const context = {
-    nth,
-    get signal() {
-      if (!abortController) {
-        abortController = new AbortController();
-      }
-      return abortController.signal;
-    },
-    onCleanup(listener) {
-      if (!cleanupEmitter) {
-        cleanupEmitter = emitter();
-      }
-      return cleanupEmitter.on(listener);
-    },
-    safe(promiseOrCallback) {
-      if (promiseOrCallback instanceof Promise) {
-        return wrapPromise(promiseOrCallback);
-      }
-      return (...args) => {
-        if (!isStale) {
-          const result = promiseOrCallback(
-            ...args
-          );
-          if (isPromiseLike(result)) {
-            return wrapPromise(result);
-          }
-          return result;
-        }
-        return void 0;
-      };
-    },
-    refresh() {
-      if (!isStale) {
-        onRefresh();
-      }
-    }
-  };
-  return Object.assign(context, { _runCleanups: runCleanups });
-}
-function resolveErrorStrategy(effectOptions) {
-  return (effectOptions == null ? void 0 : effectOptions.onError) ?? "keepAlive";
-}
-function getRetryDelay(config, attempt) {
-  if (typeof config.delay === "function") {
-    return config.delay(attempt);
-  }
-  return config.delay ?? 100 * Math.pow(2, attempt);
-}
-function effect(fn, options) {
-  let currentContext = null;
-  let subscriptionEmitter = null;
-  let isStarted = false;
-  let isRunning = false;
-  let isDisposed = false;
-  let runGeneration = 0;
-  let retryCount = 0;
-  let retryTimeout = null;
-  let errorStrategy = "keepAlive";
-  let onErrorCallback = null;
-  let prevTrackedDeps = /* @__PURE__ */ new Map();
-  let prevSubscriptionEmitter = null;
-  let trackedDeps = /* @__PURE__ */ new Map();
-  const writtenProps = /* @__PURE__ */ new Set();
-  let newTrackedDeps = null;
-  const getSubscriptionEmitter = () => {
-    if (!subscriptionEmitter) {
-      subscriptionEmitter = emitter();
-    }
-    return subscriptionEmitter;
-  };
-  const clearSubscriptions = () => {
-    if (subscriptionEmitter && subscriptionEmitter.size > 0) {
-      subscriptionEmitter.emitAndClear();
-    }
-  };
-  const areDepsChanged = (prev, next) => {
-    if (prev.size !== next.size) return true;
-    for (const key of next.keys()) {
-      if (!prev.has(key)) return true;
-    }
-    return false;
-  };
-  const subscribeToTrackedDeps = () => {
-    for (const [key, dep] of trackedDeps) {
-      if (writtenProps.has(key)) continue;
-      const unsub = dep.subscribe(() => {
-        scheduleNotification(execute, fn);
-      });
-      getSubscriptionEmitter().on(unsub);
-    }
-  };
-  const handleError = (error) => {
-    onErrorCallback == null ? void 0 : onErrorCallback(error);
-    if (errorStrategy === "failFast") {
-      throw error;
-    }
-    if (errorStrategy === "keepAlive") {
-      console.error("Effect error (keepAlive):", error);
-      if (prevSubscriptionEmitter && prevSubscriptionEmitter.size > 0) {
-        trackedDeps = new Map(prevTrackedDeps);
-        subscriptionEmitter = prevSubscriptionEmitter;
-        prevSubscriptionEmitter = null;
-        return;
-      }
-      if (newTrackedDeps && newTrackedDeps.size > 0) {
-        trackedDeps = newTrackedDeps;
-      }
-      subscribeToTrackedDeps();
-      return;
-    }
-    if (typeof errorStrategy === "function") {
-      const retry = () => {
-        retryCount++;
-        execute();
-      };
-      errorStrategy({ error, retry, retryCount });
-      return;
-    }
-    const retryConfig = errorStrategy;
-    if (retryCount < retryConfig.maxRetries) {
-      const delay = getRetryDelay(retryConfig, retryCount);
-      retryCount++;
-      retryTimeout = setTimeout(() => {
-        retryTimeout = null;
-        execute();
-      }, delay);
-    } else {
-      console.error(
-        `Effect failed after ${retryConfig.maxRetries} retries:`,
-        error
-      );
-    }
-  };
-  let cachedHooks = null;
-  const getTrackingHooks = (current) => {
-    if (!cachedHooks) {
-      cachedHooks = {
-        ...current,
-        onRead: (event) => {
-          var _a;
-          (_a = current.onRead) == null ? void 0 : _a.call(current, event);
-          if (!newTrackedDeps.has(event.key)) {
-            newTrackedDeps.set(event.key, {
-              key: event.key,
-              value: event.value,
-              subscribe: event.subscribe
-            });
-          }
-        },
-        onWrite: (event) => {
-          var _a;
-          (_a = current.onWrite) == null ? void 0 : _a.call(current, event);
-          writtenProps.add(event.key);
-        },
-        scheduleNotification: current.scheduleNotification,
-        scheduleEffect: current.scheduleEffect
-      };
-    }
-    return cachedHooks;
-  };
-  const execute = () => {
-    if (isDisposed || isRunning) return;
-    isRunning = true;
-    let shouldRefresh = false;
-    const currentGeneration = ++runGeneration;
-    try {
-      currentContext == null ? void 0 : currentContext._runCleanups();
-      currentContext = null;
-      if (subscriptionEmitter && subscriptionEmitter.size > 0) {
-        prevTrackedDeps = new Map(trackedDeps);
-        prevSubscriptionEmitter = subscriptionEmitter;
-        subscriptionEmitter = null;
-      }
-      newTrackedDeps = /* @__PURE__ */ new Map();
-      writtenProps.clear();
-      let lazyContext = null;
-      if (fn.length) {
-        lazyContext = createEffectContext(currentGeneration, () => {
-          if (isRunning) {
-            throw new EffectRefreshError();
-          }
-          execute();
-        });
-      }
-      withHooks(getTrackingHooks, () => {
-        const result = fn(lazyContext);
-        if (result !== null && result !== void 0 && typeof result.then === "function") {
-          throw new AsyncFunctionError(
-            "Effect function",
-            "Use ctx.safe(promise) for async operations instead of returning a Promise."
-          );
-        }
-        if (lazyContext && lazyContext.refresh === result) {
-          shouldRefresh = true;
-        }
-      });
-      currentContext = lazyContext;
-      retryCount = 0;
-      const depsChanged = areDepsChanged(trackedDeps, newTrackedDeps);
-      if (depsChanged) {
-        if (prevSubscriptionEmitter && prevSubscriptionEmitter.size > 0) {
-          prevSubscriptionEmitter.emitAndClear();
-        }
-        trackedDeps = newTrackedDeps;
-        subscribeToTrackedDeps();
-      } else {
-        if (prevSubscriptionEmitter) {
-          subscriptionEmitter = prevSubscriptionEmitter;
-        }
-      }
-      prevTrackedDeps.clear();
-      prevSubscriptionEmitter = null;
-    } catch (error) {
-      if (error instanceof EffectRefreshError) {
-        throw error;
-      }
-      handleError(error);
-    } finally {
-      isRunning = false;
-    }
-    if (shouldRefresh) {
-      execute();
-    }
-  };
-  const dispose = () => {
-    if (isDisposed) return;
-    isDisposed = true;
-    runGeneration++;
-    if (retryTimeout) {
-      clearTimeout(retryTimeout);
-      retryTimeout = null;
-    }
-    currentContext == null ? void 0 : currentContext._runCleanups();
-    currentContext = null;
-    clearSubscriptions();
-    if (prevSubscriptionEmitter && prevSubscriptionEmitter.size > 0) {
-      prevSubscriptionEmitter.emitAndClear();
-    }
-  };
-  const start = (runOptions) => {
-    if (isStarted) return;
-    isStarted = true;
-    errorStrategy = resolveErrorStrategy(options);
-    onErrorCallback = (runOptions == null ? void 0 : runOptions.onError) ?? null;
-    execute();
-  };
-  getHooks().scheduleEffect((runOptions) => {
-    start(runOptions);
-    return dispose;
-  });
-  return dispose;
-}
-export {
-  AsyncFunctionError as A,
-  EffectRefreshError as E,
-  HooksContextError as H,
-  InvalidActionError as I,
-  LocalStoreDependencyError as L,
-  ProviderMissingError as P,
-  StorionError as S,
-  SetupPhaseError as a,
-  batch as b,
-  LifetimeMismatchError as c,
-  StoreDisposedError as d,
-  effect as e,
-  hasWriteHook as f,
-  trackWrite as g,
-  hasReadHook as h,
-  getHooks as i,
-  scheduleNotification as s,
-  trackRead as t,
-  untrack as u,
-  withHooks as w
-};

package/dist/isPromiseLike-bFkfHAbm.js

@@ -1,6 +0,0 @@
-function isPromiseLike(value) {
-  return typeof value === "object" && value !== null && "then" in value && typeof value.then === "function";
-}
-export {
-  isPromiseLike as i
-};

package/dist/react/useLocalStore.d.ts

@@ -1,48 +0,0 @@
-import { ActionsBase, StateBase, StoreInstance, StoreSpec } from '../types';
-
-/**
- * Result type for useLocalStore.
- * Returns [state, actions, utilities] tuple.
- */
-export type LocalStoreResult<TState extends StateBase, TActions extends ActionsBase> = readonly [
-    Readonly<TState>,
-    TActions,
-    Pick<StoreInstance<TState, TActions>, "dirty" | "reset">
-];
-/**
- * Create a component-local store instance.
- *
- * The store is created when the component mounts and disposed when it unmounts.
- * Each component instance gets its own isolated store.
- *
- * @example
- * ```tsx
- * const formSpec = store({
- *   name: "form",
- *   state: { name: "", email: "" },
- *   setup({ state }) {
- *     return {
- *       setName: (name: string) => { state.name = name; },
- *       setEmail: (email: string) => { state.email = email; },
- *     };
- *   },
- * });
- *
- * function ContactForm() {
- *   const form = useLocalStore(formSpec);
- *   // Each ContactForm instance has its own form state
- *   return (
- *     <input
- *       value={form.state.name}
- *       onChange={(e) => form.actions.setName(e.target.value)}
- *     />
- *   );
- * }
- * ```
- *
- * @param spec - Store specification (must not have dependencies)
- * @returns Store instance scoped to this component
- * @throws Error if the store has dependencies on other stores
- */
-export declare function useLocalStore<TState extends StateBase, TActions extends ActionsBase>(spec: StoreSpec<TState, TActions>): LocalStoreResult<TState, TActions>;
-//# sourceMappingURL=useLocalStore.d.ts.map

package/dist/react/useLocalStore.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"useLocalStore.d.ts","sourceRoot":"","sources":["../../src/react/useLocalStore.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAIH,OAAO,EACL,WAAW,EACX,SAAS,EAET,aAAa,EACb,SAAS,EACV,MAAM,UAAU,CAAC;AAIlB;;;GAGG;AACH,MAAM,MAAM,gBAAgB,CAC1B,MAAM,SAAS,SAAS,EACxB,QAAQ,SAAS,WAAW,IAC1B,SAAS;IACX,QAAQ,CAAC,MAAM,CAAC;IAChB,QAAQ;IACR,IAAI,CAAC,aAAa,CAAC,MAAM,EAAE,QAAQ,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC;CACzD,CAAC;AASF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,aAAa,CAC3B,MAAM,SAAS,SAAS,EACxB,QAAQ,SAAS,WAAW,EAC5B,IAAI,EAAE,SAAS,CAAC,MAAM,EAAE,QAAQ,CAAC,GAAG,gBAAgB,CAAC,MAAM,EAAE,QAAQ,CAAC,CA8CvE"}