storion 0.7.10 → 0.8.1

package/dist/storion.js

@@ -1,496 +1,46 @@
-import { a as isSpec, S as STORION_TYPE } from "./is-KT6PknjJ.js";
-import { g, b, f, d, e, j, i, h, c } from "./is-KT6PknjJ.js";
-import { t as tryDispose, r as resolveEquality, u as unwrapFn, a as shallowEqual } from "./store-C3dmtJ4u.js";
-import { d as d2, e as e2, i as i2, s, b as b2, w } from "./store-C3dmtJ4u.js";
-import { e as emitter, u as untrack, g as getHooks, H as HooksContextError, w as withHooks } from "./emitter-XwTUpyGv.js";
-import { A, E, I, c as c2, L, P, a, d as d3, S, b as b3 } from "./emitter-XwTUpyGv.js";
-import { e as e3 } from "./effect-ByI1oRBq.js";
-function extractDisplayName(factory) {
-  if (isSpec(factory)) {
-    return factory.displayName;
-  }
-  if (typeof factory.displayName === "string" && factory.displayName) {
-    return factory.displayName;
-  }
-  if (factory.name && factory.name !== "") {
-    return factory.name;
-  }
-  return void 0;
-}
-function createResolver(options = {}) {
-  const {
-    middleware = [],
-    parent,
-    invokeResolver: invokeResolverOption
-  } = options;
-  const cache2 = /* @__PURE__ */ new Map();
-  const overrides = /* @__PURE__ */ new Map();
-  const resolve = (factory) => overrides.get(factory) ?? factory;
-  const invoke = (factory, resolverForCtx) => {
-    const isStoreSpec = isSpec(factory);
-    const displayName = extractDisplayName(factory);
-    const chain = middleware.reduceRight(
-      (next, mw) => () => {
-        if (isStoreSpec) {
-          const ctx = {
-            type: "store",
-            factory,
-            resolver: resolverForCtx,
-            next,
-            displayName,
-            spec: factory
-          };
-          return mw(ctx);
-        } else {
-          const ctx = {
-            type: "factory",
-            factory,
-            resolver: resolverForCtx,
-            next,
-            displayName
-          };
-          return mw(ctx);
-        }
-      },
-      () => factory(resolverForCtx)
-    );
-    return chain();
-  };
-  const resolver = {
-    get(factory) {
-      if (cache2.has(factory)) {
-        return cache2.get(factory);
-      }
-      if (parent && overrides.size === 0 && parent.has(factory)) {
-        return parent.get(factory);
-      }
-      const instance = invoke(
-        resolve(factory),
-        invokeResolverOption ?? resolver
-      );
-      cache2.set(factory, instance);
-      return instance;
-    },
-    create(factory, ...args) {
-      const resolverForCtx = invokeResolverOption ?? resolver;
-      if (args.length > 0) {
-        return factory(resolverForCtx, ...args);
-      }
-      return invoke(resolve(factory), resolverForCtx);
-    },
-    set(factory, override) {
-      overrides.set(factory, override);
-      cache2.delete(factory);
-    },
-    has(factory) {
-      const inParent = parent && overrides.size === 0 && parent.has(factory);
-      return cache2.has(factory) || (inParent ?? false);
-    },
-    tryGet(factory) {
-      if (cache2.has(factory)) {
-        return cache2.get(factory);
-      }
-      if (parent && overrides.size === 0) {
-        return parent.tryGet(factory);
-      }
-      return void 0;
-    },
-    delete(factory) {
-      const instance = cache2.get(factory);
-      if (instance) {
-        tryDispose(instance);
-        cache2.delete(factory);
-        return true;
-      }
-      return false;
-    },
-    clear() {
-      for (const instance of cache2.values()) {
-        tryDispose(instance);
-      }
-      cache2.clear();
-    },
-    scope(scopeOptions = {}) {
-      return createResolver({
-        middleware: scopeOptions.middleware ?? middleware,
-        parent: resolver,
-        ...scopeOptions
-      });
-    }
-  };
-  return resolver;
-}
-function when(predicate, middleware) {
-  return (ctx) => {
-    if (predicate(ctx.factory)) {
-      return middleware(ctx);
-    }
-    return ctx.next();
-  };
-}
-function createLoggingMiddleware(prefix = "Resolver") {
-  return (ctx) => {
-    const name = ctx.factory.name || "anonymous";
-    console.log(`[${prefix}] Creating: ${name}`);
-    const start = performance.now();
-    const result = ctx.next();
-    const duration = (performance.now() - start).toFixed(2);
-    console.log(`[${prefix}] Created: ${name} (${duration}ms)`);
-    return result;
-  };
-}
-function createValidationMiddleware(validate) {
-  return (ctx) => {
-    const result = ctx.next();
-    validate(result, ctx.factory);
-    return result;
-  };
-}
-let defaultMiddlewareConfig = {};
-const container = function(options = {}) {
-  const middleware = [
-    ...defaultMiddlewareConfig.pre ?? [],
-    ...options.middleware ?? [],
-    ...defaultMiddlewareConfig.post ?? []
-  ];
-  const instancesById = /* @__PURE__ */ new Map();
-  const creationOrder = [];
-  const createEmitter = emitter();
-  const disposeEmitter = emitter();
-  const parent = options._parent;
-  let containerApi;
-  const internalResolver = createResolver({
-    middleware,
-    parent,
-    get invokeResolver() {
-      return containerApi;
-    }
-  });
-  function trackStore(spec, instance) {
-    instancesById.set(instance.id, instance);
-    creationOrder.push(spec);
-    if (typeof instance.onDispose === "function") {
-      instance.onDispose(() => {
-        disposeEmitter.emit(instance);
-        instancesById.delete(instance.id);
-        internalResolver.delete(spec);
-        const index = creationOrder.indexOf(spec);
-        if (index !== -1) {
-          creationOrder.splice(index, 1);
-        }
-      });
-    }
-    createEmitter.emit(instance);
-  }
-  containerApi = {
-    [STORION_TYPE]: "container",
-    // Get by ID or factory/spec
-    get(specOrIdOrFactory) {
-      if (typeof specOrIdOrFactory === "string") {
-        return instancesById.get(specOrIdOrFactory);
-      }
-      const wasCached = internalResolver.has(specOrIdOrFactory);
-      const instance = untrack(() => internalResolver.get(specOrIdOrFactory));
-      if (!wasCached && isSpec(specOrIdOrFactory)) {
-        trackStore(specOrIdOrFactory, instance);
-      }
-      return instance;
-    },
-    create(specOrFactory, ...args) {
-      const instance = untrack(
-        () => internalResolver.create(specOrFactory, ...args)
-      );
-      if (isSpec(specOrFactory)) {
-        const storeInstance = instance;
-        instancesById.set(storeInstance.id, storeInstance);
-        if (typeof storeInstance.onDispose === "function") {
-          storeInstance.onDispose(() => {
-            disposeEmitter.emit(storeInstance);
-            instancesById.delete(storeInstance.id);
-          });
-        }
-      }
-      return instance;
-    },
-    set(spec, override) {
-      const existing = internalResolver.tryGet(spec);
-      tryDispose(existing);
-      internalResolver.set(spec, override);
-    },
-    has(spec) {
-      return internalResolver.has(spec);
-    },
-    tryGet(spec) {
-      return internalResolver.tryGet(spec);
-    },
-    delete(spec) {
-      const instance = internalResolver.tryGet(spec);
-      if (instance) {
-        tryDispose(instance);
-        return true;
-      }
-      return false;
-    },
-    clear() {
-      const specs = [...creationOrder].reverse();
-      for (const spec of specs) {
-        const instance = internalResolver.tryGet(spec);
-        tryDispose(instance);
-      }
-      internalResolver.clear();
-      instancesById.clear();
-      creationOrder.length = 0;
-    },
-    dispose(spec) {
-      return containerApi.delete(spec);
-    },
-    scope(scopeOptions = {}) {
-      return container({
-        middleware: scopeOptions.middleware ?? middleware,
-        _parent: containerApi
-      });
-    },
-    onCreate: createEmitter.on,
-    onDispose: disposeEmitter.on
-  };
-  return containerApi;
-};
-const defaultsFn = (config = {}) => {
-  defaultMiddlewareConfig = {
-    pre: [...defaultMiddlewareConfig.pre ?? [], ...config.pre ?? []],
-    post: [...defaultMiddlewareConfig.post ?? [], ...config.post ?? []]
-  };
-};
-defaultsFn.clear = () => {
-  defaultMiddlewareConfig = {};
-};
-container.defaults = defaultsFn;
-let pickIdCounter = 0;
-function pick(selector, equality) {
-  var _a;
-  const parentHooks = getHooks();
-  if (!parentHooks.onRead) {
-    throw new HooksContextError("pick", "an effect or useStore selector");
-  }
-  const equalityFn = resolveEquality(equality);
-  const currentReads = [];
-  const evaluate = () => {
-    currentReads.length = 0;
-    const value = withHooks(
-      {
-        onRead: (event) => {
-          currentReads.push(event);
-        }
-      },
-      selector
-    );
-    return value;
-  };
-  let currentValue = evaluate();
-  if (!currentReads.length) {
-    return currentValue;
-  }
-  const pickKey = `pick:${++pickIdCounter}`;
-  const subscribe = (listener) => {
-    const onCleanup = emitter();
-    const setupSubscriptions = () => {
-      for (const read of currentReads) {
-        const unsub = read.subscribe(handleChange);
-        onCleanup.on(unsub);
-      }
-    };
-    const clearSubscriptions = () => {
-      onCleanup.emitAndClear();
-    };
-    const handleChange = () => {
-      try {
-        const prevValue = currentValue;
-        clearSubscriptions();
-        currentValue = evaluate();
-        setupSubscriptions();
-        if (!equalityFn(prevValue, currentValue)) {
-          listener();
-        }
-      } catch (error) {
-        clearSubscriptions();
-        listener();
-      }
-    };
-    setupSubscriptions();
-    return clearSubscriptions;
-  };
-  (_a = parentHooks.onRead) == null ? void 0 : _a.call(parentHooks, {
-    key: pickKey,
-    value: currentValue,
-    subscribe
-  });
-  return currentValue;
-}
-function patternToPredicate(pattern) {
-  if (pattern instanceof RegExp) {
-    return (name) => pattern.test(name);
-  }
-  const startsWithWildcard = pattern.startsWith("*");
-  const endsWithWildcard = pattern.endsWith("*");
-  if (startsWithWildcard && endsWithWildcard) {
-    const substr = pattern.slice(1, -1);
-    return (name) => name.includes(substr);
-  }
-  if (startsWithWildcard) {
-    const suffix = pattern.slice(1);
-    return (name) => name.endsWith(suffix);
-  }
-  if (endsWithWildcard) {
-    const prefix = pattern.slice(0, -1);
-    return (name) => name.startsWith(prefix);
-  }
-  return (name) => name === pattern;
-}
-function patternsToPredicate(patterns) {
-  if (Array.isArray(patterns)) {
-    const predicates = patterns.map(patternToPredicate);
-    return (ctx) => ctx.displayName !== void 0 && predicates.some((p) => p(ctx.displayName));
-  }
-  const predicate = patternToPredicate(patterns);
-  return (ctx) => ctx.displayName !== void 0 && predicate(ctx.displayName);
-}
-function compose(...middlewares) {
-  if (middlewares.length === 0) {
-    return (ctx) => ctx.next();
-  }
-  if (middlewares.length === 1) {
-    return middlewares[0];
-  }
-  return (ctx) => {
-    let index = 0;
-    const executeNext = () => {
-      if (index >= middlewares.length) {
-        return ctx.next();
-      }
-      const currentMiddleware = middlewares[index];
-      index++;
-      const wrappedCtx = ctx.type === "store" ? { ...ctx, next: executeNext } : { ...ctx, next: executeNext };
-      return currentMiddleware(wrappedCtx);
-    };
-    return executeNext();
-  };
-}
-function applyFor(predicateOrPatterns, middleware) {
-  const predicate = typeof predicateOrPatterns === "function" ? predicateOrPatterns : patternsToPredicate(predicateOrPatterns);
-  const composedMiddleware = Array.isArray(middleware) ? compose(...middleware) : middleware;
-  return (ctx) => {
-    if (predicate(ctx)) {
-      return composedMiddleware(ctx);
-    }
-    return ctx.next();
-  };
-}
-function applyExcept(predicateOrPatterns, middleware) {
-  const matchPredicate = typeof predicateOrPatterns === "function" ? predicateOrPatterns : patternsToPredicate(predicateOrPatterns);
-  const invertedPredicate = (ctx) => !matchPredicate(ctx);
-  return applyFor(invertedPredicate, middleware);
-}
-function forStores(storeMiddleware) {
-  return (ctx) => {
-    if (ctx.type === "store") {
-      return storeMiddleware(ctx);
-    }
-    return ctx.next();
-  };
-}
-const DEFAULT_KEY = {};
-const cache = /* @__PURE__ */ new Map();
-function getKeyCache(key) {
-  let keyCache = cache.get(key);
-  if (!keyCache) {
-    keyCache = /* @__PURE__ */ new WeakMap();
-    cache.set(key, keyCache);
-  }
-  return keyCache;
-}
-function trigger(keyOrFn, fnOrDepsOrOptions, depsOrFirstArg, ...restArgs) {
-  let key;
-  let fn;
-  let deps;
-  let equality;
-  let args;
-  if (typeof fnOrDepsOrOptions === "function") {
-    key = keyOrFn;
-    fn = fnOrDepsOrOptions;
-    deps = depsOrFirstArg ?? [];
-    args = restArgs;
-  } else if (Array.isArray(fnOrDepsOrOptions)) {
-    key = DEFAULT_KEY;
-    fn = keyOrFn;
-    deps = fnOrDepsOrOptions;
-    args = depsOrFirstArg !== void 0 ? [depsOrFirstArg, ...restArgs] : [];
-  } else {
-    const options = fnOrDepsOrOptions ?? {};
-    key = options.key ?? DEFAULT_KEY;
-    fn = keyOrFn;
-    deps = options.deps ?? [];
-    equality = options.equality ? resolveEquality(options.equality) : void 0;
-    args = depsOrFirstArg !== void 0 ? [depsOrFirstArg, ...restArgs] : [];
-  }
-  const cacheKey = unwrapFn(fn);
-  const keyCache = getKeyCache(key);
-  const cached = keyCache.get(cacheKey);
-  const eq = equality ?? (cached == null ? void 0 : cached.equality) ?? shallowEqual;
-  if (cached && eq(cached.deps, deps)) {
-    return cached.result;
-  }
-  const result = fn(...args);
-  keyCache.set(cacheKey, { deps, result, equality });
-  return result;
-}
-trigger.clear = (key) => {
-  cache.delete(key);
-};
-trigger.clearAll = () => {
-  cache.clear();
-};
+import { S, n, m, c, l, u, q, o, g, a, h, d, f, k, i, e, j, b, z, p, t, s, v, w, y, A, x } from "./index-OPaTR3zq.js";
+import { A as A2, E, H, I, c as c2, L, P, a as a2, d as d2, S as S2, b as b2, e as e2, u as u2 } from "./effect-C6h0PDDI.js";
+import { m as m2 } from "./meta-40r-AZfe.js";
 export {
-  A as AsyncFunctionError,
+  A2 as AsyncFunctionError,
   E as EffectRefreshError,
-  HooksContextError,
+  H as HooksContextError,
   I as InvalidActionError,
   c2 as LifetimeMismatchError,
   L as LocalStoreDependencyError,
   P as ProviderMissingError,
-  STORION_TYPE,
-  a as SetupPhaseError,
-  d3 as StoreDisposedError,
-  S as StorionError,
-  applyExcept,
-  applyFor,
-  b3 as batch,
-  compose,
-  container,
-  createLoggingMiddleware,
-  createResolver,
-  createValidationMiddleware,
-  d2 as deepEqual,
-  e3 as effect,
-  e2 as equality,
-  forStores,
+  S as STORION_TYPE,
+  a2 as SetupPhaseError,
+  d2 as StoreDisposedError,
+  S2 as StorionError,
+  n as applyExcept,
+  m as applyFor,
+  b2 as batch,
+  c as container,
+  l as createResolver,
+  u as deepEqual,
+  e2 as effect,
+  q as equality,
+  o as forStores,
   g as getKind,
-  b as is,
-  f as isAction,
+  a as is,
+  h as isAction,
   d as isContainer,
-  e as isFocus,
-  j as isSelectorContext,
-  isSpec,
-  i as isStore,
-  h as isStoreContext,
-  c as isStorion,
-  i2 as isWrappedFn,
-  pick,
-  shallowEqual,
+  f as isFocus,
+  k as isSelectorContext,
+  i as isSpec,
+  e as isStore,
+  j as isStoreContext,
+  b as isStorion,
+  z as isWrappedFn,
+  m2 as meta,
+  p as pick,
+  t as shallowEqual,
   s as store,
-  b2 as strictEqual,
-  trigger,
-  untrack,
-  unwrapFn,
-  when,
-  w as wrapFn
+  v as strictEqual,
+  w as trigger,
+  u2 as untrack,
+  y as unwrapFn,
+  A as withMeta,
+  x as wrapFn
 };