storion 0.4.0 → 0.6.0

package/dist/{store-Yv-9gPVf.js → store-DS-4XdM6.js}

@@ -1729,6 +1729,28 @@ function resolveEquality(e) {
 function equality(shorthand) {
   return resolveEquality(shorthand);
 }
+function tryDispose(value) {
+  if (isDisposable(value)) {
+    const dispose = value.dispose;
+    if (Array.isArray(dispose)) {
+      for (const item of dispose) {
+        if (typeof item === "function") {
+          item();
+        } else {
+          tryDispose(item);
+        }
+      }
+    } else if (typeof dispose === "function") {
+      dispose();
+    }
+  }
+}
+function isDisposable(value) {
+  return (typeof value === "object" || typeof value === "function") && !!value && "dispose" in value;
+}
+function willDispose(value) {
+  return () => tryDispose(value);
+}
 function getAtPath(obj, segments) {
   let current2 = obj;
   for (const key of segments) {
@@ -1864,18 +1886,16 @@ function createStoreContext(options) {
         actions: instance.actions
       });
     },
-    // Implementation handles both StoreSpec and Factory overloads
-    create(specOrFactory) {
+    // Implementation handles StoreSpec, Factory, and parameterized Factory overloads
+    create(specOrFactory, ...args) {
       if (!isSetupPhase()) {
         throw new Error(
           `create() can only be called during setup phase. Do not call create() inside actions or async callbacks. Declare all child stores at the top of your setup function.`
         );
       }
       if (!isSpec(specOrFactory)) {
-        const instance2 = specOrFactory(resolver);
-        if (instance2 && typeof instance2.dispose === "function") {
-          onDispose == null ? void 0 : onDispose(instance2.dispose);
-        }
+        const instance2 = specOrFactory(resolver, ...args);
+        onDispose == null ? void 0 : onDispose(willDispose(instance2));
         return instance2;
       }
       const childSpec = specOrFactory;
@@ -1888,7 +1908,7 @@ function createStoreContext(options) {
         );
       }
       const instance = resolver.create(childSpec);
-      onDispose == null ? void 0 : onDispose(instance.dispose);
+      onDispose == null ? void 0 : onDispose(willDispose(instance));
       return instance;
     },
     update: createUpdateFn(update),
@@ -1898,6 +1918,9 @@ function createStoreContext(options) {
     reset() {
       reset();
     },
+    onDispose(callback) {
+      onDispose == null ? void 0 : onDispose(callback);
+    },
     mixin(mixin, ...args) {
       if (!isSetupPhase()) {
         throw new Error(
@@ -2632,6 +2655,7 @@ function createStoreInstance(spec, resolver, instanceOptions = {}) {
   return instance;
 }
 export {
+  scheduleNotification as A,
   STORION_TYPE as S,
   is$1 as a,
   isStorion as b,
@@ -2657,6 +2681,6 @@ export {
   unwrapFn as v,
   withHooks as w,
   isWrappedFn as x,
-  getHooks as y,
-  scheduleNotification as z
+  tryDispose as y,
+  getHooks as z
 };

package/dist/storion.js

@@ -1,201 +1,5 @@
-import { e as emitter, i as isSpec, S as STORION_TYPE, u as untrack, y as getHooks, w as withHooks, r as resolveEquality, z as scheduleNotification, v as unwrapFn, o as shallowEqual } from "./store-Yv-9gPVf.js";
-import { m, p, n, g, a, j, d, h, l, f, k, b, x, s, q, t } from "./store-Yv-9gPVf.js";
-let defaultMiddlewareConfig = {};
-const container = function(options = {}) {
-  const middleware = [
-    ...defaultMiddlewareConfig.pre ?? [],
-    ...options.middleware ?? [],
-    ...defaultMiddlewareConfig.post ?? []
-  ];
-  const cache2 = /* @__PURE__ */ new Map();
-  const factoryCache = /* @__PURE__ */ new Map();
-  const instancesById = /* @__PURE__ */ new Map();
-  const overrides = /* @__PURE__ */ new Map();
-  const factoryOverrides = /* @__PURE__ */ new Map();
-  const creationOrder = [];
-  const createEmitter = emitter();
-  const disposeEmitter = emitter();
-  const creating = /* @__PURE__ */ new Set();
-  const creatingFactories = /* @__PURE__ */ new Set();
-  const parent = options._parent;
-  const resolve = (spec) => overrides.get(spec) ?? spec;
-  function buildMiddlewareChain() {
-    return (spec) => {
-      let index = 0;
-      const executeNext = () => {
-        if (index >= middleware.length) {
-          return spec(containerApi);
-        }
-        const currentMiddleware = middleware[index];
-        index++;
-        const ctx = {
-          spec,
-          factory: spec,
-          resolver: containerApi,
-          next: executeNext,
-          displayName: spec.displayName
-        };
-        return currentMiddleware(ctx);
-      };
-      return executeNext();
-    };
-  }
-  const createWithMiddleware = buildMiddlewareChain();
-  function createInstance(spec) {
-    const instance = untrack(() => createWithMiddleware(spec));
-    if (typeof instance.onDispose === "function") {
-      instance.onDispose(() => {
-        disposeEmitter.emit(instance);
-        cache2.delete(spec);
-        instancesById.delete(instance.id);
-        const index = creationOrder.indexOf(spec);
-        if (index !== -1) {
-          creationOrder.splice(index, 1);
-        }
-      });
-    }
-    return instance;
-  }
-  const containerApi = {
-    [STORION_TYPE]: "container",
-    // ========================================================================
-    // Resolver Methods
-    // ========================================================================
-    // Implementation handles multiple overloads
-    get(specOrIdOrFactory) {
-      if (typeof specOrIdOrFactory === "string") {
-        return instancesById.get(specOrIdOrFactory);
-      }
-      if (!isSpec(specOrIdOrFactory)) {
-        const factory = specOrIdOrFactory;
-        if (factoryCache.has(factory)) {
-          return factoryCache.get(factory);
-        }
-        if (parent && factoryOverrides.size === 0 && "tryGet" in parent && typeof parent.tryGet === "function") {
-          const parentInstance = parent.tryGet(factory);
-          if (parentInstance !== void 0) {
-            return parentInstance;
-          }
-        }
-        if (creatingFactories.has(factory)) {
-          const name = factory.name || "anonymous";
-          throw new Error(
-            `Circular dependency detected: factory "${name}" is being created while already in creation stack.`
-          );
-        }
-        creatingFactories.add(factory);
-        try {
-          const mapped = factoryOverrides.get(factory) ?? factory;
-          const instance = mapped(containerApi);
-          factoryCache.set(factory, instance);
-          return instance;
-        } finally {
-          creatingFactories.delete(factory);
-        }
-      }
-      const spec = specOrIdOrFactory;
-      if (cache2.has(spec)) {
-        return cache2.get(spec);
-      }
-      if (parent && overrides.size === 0 && parent.has(spec)) {
-        return parent.get(spec);
-      }
-      if (creating.has(spec)) {
-        const name = spec.displayName ?? "unknown";
-        throw new Error(
-          `Circular dependency detected: "${name}" is being created while already in creation stack.`
-        );
-      }
-      creating.add(spec);
-      try {
-        const mapped = resolve(spec);
-        const instance = createInstance(mapped);
-        cache2.set(spec, instance);
-        instancesById.set(instance.id, instance);
-        creationOrder.push(spec);
-        createEmitter.emit(instance);
-        return instance;
-      } finally {
-        creating.delete(spec);
-      }
-    },
-    // Implementation handles both StoreSpec and Factory overloads
-    create(specOrFactory) {
-      if (!isSpec(specOrFactory)) {
-        const factory = specOrFactory;
-        const mapped2 = factoryOverrides.get(factory) ?? factory;
-        return mapped2(containerApi);
-      }
-      const mapped = resolve(specOrFactory);
-      return createInstance(mapped);
-    },
-    set(spec, override) {
-      overrides.set(spec, override);
-      const existing = cache2.get(spec);
-      if (existing) {
-        existing.dispose();
-      }
-    },
-    has(spec) {
-      const inParent = parent && overrides.size === 0 && parent.has(spec);
-      return cache2.has(spec) || (inParent ?? false);
-    },
-    tryGet(spec) {
-      if (cache2.has(spec)) {
-        return cache2.get(spec);
-      }
-      if (parent && overrides.size === 0) {
-        return parent.tryGet(spec);
-      }
-      return void 0;
-    },
-    delete(spec) {
-      const instance = cache2.get(spec);
-      if (instance) {
-        instance.dispose();
-        return true;
-      }
-      return false;
-    },
-    // ========================================================================
-    // Container-Specific Methods
-    // ========================================================================
-    clear() {
-      const specs = [...creationOrder].reverse();
-      for (const spec of specs) {
-        const instance = cache2.get(spec);
-        if (instance) {
-          instance.dispose();
-        }
-      }
-      cache2.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;
+import { y as tryDispose, i as isSpec, e as emitter, u as untrack, S as STORION_TYPE, z as getHooks, w as withHooks, r as resolveEquality, A as scheduleNotification, v as unwrapFn, o as shallowEqual } from "./store-DS-4XdM6.js";
+import { m, p, n, g, a, j, d, h, l, f, k, b, x, s, q, t } from "./store-DS-4XdM6.js";
 function extractDisplayName(factory) {
   if (isSpec(factory)) {
     return factory.displayName;
@@ -209,20 +13,41 @@ function extractDisplayName(factory) {
   return void 0;
 }
 function createResolver(options = {}) {
-  const { middleware = [], parent } = 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, resolver2) => {
+  const invoke = (factory, resolverForCtx) => {
+    const isStoreSpec = isSpec(factory);
     const displayName = extractDisplayName(factory);
     const chain = middleware.reduceRight(
-      (next, mw) => () => mw({
-        factory,
-        resolver: resolver2,
-        next,
-        displayName
-      }),
-      () => factory(resolver2)
+      (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();
   };
@@ -234,12 +59,19 @@ function createResolver(options = {}) {
       if (parent && overrides.size === 0 && parent.has(factory)) {
         return parent.get(factory);
       }
-      const instance = invoke(resolve(factory), resolver);
+      const instance = invoke(
+        resolve(factory),
+        invokeResolverOption ?? resolver
+      );
       cache2.set(factory, instance);
       return instance;
     },
-    create(factory) {
-      return invoke(resolve(factory), resolver);
+    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);
@@ -261,9 +93,7 @@ function createResolver(options = {}) {
     delete(factory) {
       const instance = cache2.get(factory);
       if (instance) {
-        if (instance && typeof instance === "object" && "dispose" in instance && typeof instance.dispose === "function") {
-          instance.dispose();
-        }
+        tryDispose(instance);
         cache2.delete(factory);
         return true;
       }
@@ -271,9 +101,7 @@ function createResolver(options = {}) {
     },
     clear() {
       for (const instance of cache2.values()) {
-        if (instance && typeof instance === "object" && "dispose" in instance && typeof instance.dispose === "function") {
-          instance.dispose();
-        }
+        tryDispose(instance);
       }
       cache2.clear();
     },
@@ -313,6 +141,125 @@ function createValidationMiddleware(validate) {
     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;
@@ -672,10 +619,10 @@ function patternToPredicate(pattern) {
 function patternsToPredicate(patterns) {
   if (Array.isArray(patterns)) {
     const predicates = patterns.map(patternToPredicate);
-    return (ctx) => predicates.some((p2) => p2(ctx.displayName));
+    return (ctx) => ctx.displayName !== void 0 && predicates.some((p2) => p2(ctx.displayName));
   }
   const predicate = patternToPredicate(patterns);
-  return (ctx) => predicate(ctx.displayName);
+  return (ctx) => ctx.displayName !== void 0 && predicate(ctx.displayName);
 }
 function compose(...middlewares) {
   if (middlewares.length === 0) {
@@ -692,10 +639,7 @@ function compose(...middlewares) {
       }
       const currentMiddleware = middlewares[index];
       index++;
-      const wrappedCtx = {
-        ...ctx,
-        next: executeNext
-      };
+      const wrappedCtx = ctx.type === "store" ? { ...ctx, next: executeNext } : { ...ctx, next: executeNext };
       return currentMiddleware(wrappedCtx);
     };
     return executeNext();
@@ -705,17 +649,8 @@ function applyFor(predicateOrPatterns, middleware) {
   const predicate = typeof predicateOrPatterns === "function" ? predicateOrPatterns : patternsToPredicate(predicateOrPatterns);
   const composedMiddleware = Array.isArray(middleware) ? compose(...middleware) : middleware;
   return (ctx) => {
-    if (isSpec(ctx.factory)) {
-      const spec = ctx.factory;
-      const storeMiddlewareCtx = {
-        ...ctx,
-        spec
-      };
-      if (predicate(storeMiddlewareCtx)) {
-        return composedMiddleware(
-          storeMiddlewareCtx
-        );
-      }
+    if (predicate(ctx)) {
+      return composedMiddleware(ctx);
     }
     return ctx.next();
   };
@@ -725,6 +660,14 @@ function applyExcept(predicateOrPatterns, middleware) {
   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) {
@@ -789,6 +732,7 @@ export {
   p as deepEqual,
   effect,
   n as equality,
+  forStores,
   g as getKind,
   a as is,
   j as isAction,

package/dist/test/util.d.ts

@@ -0,0 +1,2 @@
+export declare function fake<T>(): T | undefined;
+//# sourceMappingURL=util.d.ts.map

package/dist/test/util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../../src/test/util.ts"],"names":[],"mappings":"AAAA,wBAAgB,IAAI,CAAC,CAAC,KAAK,CAAC,GAAG,SAAS,CAEvC"}