storion 0.7.10 → 0.8.0

package/dist/{store-C3dmtJ4u.js → index-CIFKRy71.js}

@@ -1,5 +1,37 @@
-import { a as isSpec, S as STORION_TYPE } from "./is-KT6PknjJ.js";
-import { a as SetupPhaseError, c as LifetimeMismatchError, e as emitter, w as withHooks, I as InvalidActionError, h as hasReadHook, t as trackRead, f as hasWriteHook, i as trackWrite, d as StoreDisposedError, s as scheduleNotification, b as batch } from "./emitter-XwTUpyGv.js";
+import { a as SetupPhaseError, c as LifetimeMismatchError, w as withHooks, I as InvalidActionError, h as hasReadHook, t as trackRead, f as hasWriteHook, g as trackWrite, d as StoreDisposedError, s as scheduleNotification, b as batch, u as untrack, i as getHooks, H as HooksContextError } from "./effect-C6h0PDDI.js";
+import { e as emitter } from "./emitter-j4rC71vY.js";
+import "./meta-u3yOx5Kh.js";
+const STORION_TYPE = Symbol("STORION");
+function is$1(value, kind) {
+  return value !== null && (typeof value === "object" || typeof value === "function") && STORION_TYPE in value && value[STORION_TYPE] === kind;
+}
+function isStorion(value) {
+  return value !== null && (typeof value === "object" || typeof value === "function") && STORION_TYPE in value && typeof value[STORION_TYPE] === "string";
+}
+function getKind(value) {
+  return value[STORION_TYPE];
+}
+function isSpec(value) {
+  return is$1(value, "store.spec");
+}
+function isContainer(value) {
+  return is$1(value, "container");
+}
+function isStore(value) {
+  return is$1(value, "store");
+}
+function isFocus(value) {
+  return is$1(value, "focus");
+}
+function isStoreContext(value) {
+  return is$1(value, "store.context");
+}
+function isSelectorContext(value) {
+  return is$1(value, "selector.context");
+}
+function isAction(value) {
+  return is$1(value, "store.action");
+}
 var NOTHING = Symbol.for("immer-nothing");
 var DRAFTABLE = Symbol.for("immer-draftable");
 var DRAFT_STATE = Symbol.for("immer-state");
@@ -1201,8 +1233,8 @@ function arraySome$1(array, predicate) {
   return false;
 }
 var _arraySome = arraySome$1;
-function cacheHas$1(cache, key) {
-  return cache.has(key);
+function cacheHas$1(cache2, key) {
+  return cache2.has(key);
 }
 var _cacheHas = cacheHas$1;
 var SetCache = _SetCache, arraySome = _arraySome, cacheHas = _cacheHas;
@@ -2004,10 +2036,12 @@ function store(options) {
       {}
     );
   };
+  const metaEntries = Array.isArray(options.meta) ? options.meta : options.meta ? [options.meta] : [];
   Object.defineProperties(spec, {
     [STORION_TYPE]: { value: "store.spec", enumerable: false },
     displayName: { value: displayName, enumerable: true, writable: false },
-    options: { value: options, enumerable: true, writable: false }
+    options: { value: options, enumerable: true, writable: false },
+    meta: { value: metaEntries, enumerable: true, writable: false }
   });
   return spec;
 }
@@ -2211,11 +2245,12 @@ function createStoreInstance(spec, resolver, instanceOptions = {}) {
       }
       return { ...currentState };
     },
-    hydrate(data) {
+    hydrate(data, hydrateOptions) {
       const denormalizer = options.denormalize;
       const newState = denormalizer ? denormalizer(data) : data;
+      const force = (hydrateOptions == null ? void 0 : hydrateOptions.force) ?? false;
       for (const key of Object.keys(newState)) {
-        if (currentState[key] !== initialState[key]) {
+        if (!force && currentState[key] !== initialState[key]) {
           continue;
         }
         const oldValue = currentState[key];
@@ -2338,7 +2373,10 @@ function createStoreInstance(spec, resolver, instanceOptions = {}) {
           scheduledEffects.push(runEffect);
         }
       }),
-      () => options.setup(setupContext)
+      () => {
+        var _a2;
+        return ((_a2 = options.setup) == null ? void 0 : _a2.call(options, setupContext)) ?? {};
+      }
     );
   } catch (error) {
     disposeEffectsEmitter.emitAndClear();
@@ -2415,16 +2453,539 @@ function createStoreInstance(spec, resolver, instanceOptions = {}) {
   instanceActions = wrappedActions;
   return instance;
 }
+function createMetaQuery(entries) {
+  const entryArray = Array.isArray(entries) ? entries : entries ? [entries] : [];
+  const single = (type) => {
+    const result = { store: void 0, fields: {} };
+    for (const entry of entryArray) {
+      if (entry.type !== type) continue;
+      if (entry.fields && entry.fields.length > 0) {
+        for (const field of entry.fields) {
+          const fieldKey = field;
+          if (!(fieldKey in result.fields)) {
+            result.fields[fieldKey] = entry.value;
+          }
+        }
+      } else {
+        if (result.store === void 0) {
+          result.store = entry.value;
+        }
+      }
+    }
+    return result;
+  };
+  const all = (type) => {
+    const result = { store: [], fields: {} };
+    for (const entry of entryArray) {
+      if (entry.type !== type) continue;
+      if (entry.fields && entry.fields.length > 0) {
+        for (const field of entry.fields) {
+          const fieldKey = field;
+          let arr = result.fields[fieldKey];
+          if (!arr) {
+            arr = [];
+            result.fields[fieldKey] = arr;
+          }
+          arr.push(entry.value);
+        }
+      } else {
+        result.store.push(entry.value);
+      }
+    }
+    return result;
+  };
+  const any = (...types) => {
+    return entryArray.some((entry) => types.includes(entry.type));
+  };
+  const query = Object.assign(
+    (type) => single(type),
+    { single, all, any }
+  );
+  return query;
+}
+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 meta = createMetaQuery(factory.meta);
+    const chain = middleware.reduceRight(
+      (next, mw) => () => {
+        if (isStoreSpec) {
+          const ctx = {
+            type: "store",
+            factory,
+            resolver: resolverForCtx,
+            next,
+            displayName,
+            spec: factory,
+            meta
+          };
+          return mw(ctx);
+        } else {
+          const ctx = {
+            type: "factory",
+            factory,
+            resolver: resolverForCtx,
+            next,
+            displayName,
+            meta
+          };
+          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 ?? [],
+    ...Array.isArray(options.middleware) ? options.middleware : options.middleware ? [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, equality2) {
+  var _a;
+  const parentHooks = getHooks();
+  if (!parentHooks.onRead) {
+    throw new HooksContextError("pick", "an effect or useStore selector");
+  }
+  const equalityFn = resolveEquality(equality2);
+  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) {
+  const composedMiddleware = Array.isArray(storeMiddleware) ? compose(...storeMiddleware) : storeMiddleware;
+  return (ctx) => {
+    if (ctx.type === "store") {
+      return composedMiddleware(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 equality2;
+  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 ?? [];
+    equality2 = 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 eq2 = equality2 ?? (cached == null ? void 0 : cached.equality) ?? shallowEqual;
+  if (cached && eq2(cached.deps, deps)) {
+    return cached.result;
+  }
+  const result = fn(...args);
+  keyCache.set(cacheKey, { deps, result, equality: equality2 });
+  return result;
+}
+trigger.clear = (key) => {
+  cache.delete(key);
+};
+trigger.clearAll = () => {
+  cache.clear();
+};
+function withMeta(factory, meta) {
+  return Object.assign(factory, {
+    meta: Array.isArray(meta) ? meta : [meta]
+  });
+}
 export {
-  shallowEqual as a,
-  strictEqual as b,
-  createStoreInstance as c,
-  deepEqual as d,
-  equality as e,
-  isWrappedFn as i,
+  wrapFn as A,
+  unwrapFn as B,
+  isWrappedFn as C,
+  withMeta as D,
+  STORION_TYPE as S,
+  is$1 as a,
+  isStorion as b,
+  container as c,
+  isContainer as d,
+  isStore as e,
+  isFocus as f,
+  getKind as g,
+  isAction as h,
+  isSpec as i,
+  isStoreContext as j,
+  isSelectorContext as k,
+  createResolver as l,
+  createLoggingMiddleware as m,
+  createValidationMiddleware as n,
+  applyFor as o,
+  pick as p,
+  applyExcept as q,
   resolveEquality as r,
   store as s,
-  tryDispose as t,
-  unwrapFn as u,
-  wrapFn as w
+  forStores as t,
+  equality as u,
+  shallowEqual as v,
+  when as w,
+  deepEqual as x,
+  strictEqual as y,
+  trigger as z
 };

package/dist/index.d.ts

@@ -3,7 +3,7 @@
  *
  * @packageDocumentation
  */
-export { STORION_TYPE, type StorionKind, type StorionObject, type StateBase, type ActionsBase, type Equality, type EqualityMap, type Lifetime, type DispatchEvent, type ActionDispatchEvent, type ReactiveAction, type ReactiveActions, type StoreMeta, type StoreSpec, type StoreContext, type StoreMixin, type StoreOptions, type StoreInstance, type StoreContainer, type ContainerOptions, type StoreMiddleware, type SelectorContext, type SelectorMixin, type Selector, type StoreTuple, type StableResult, type PickEquality, type StatePath, type PathValue, type Focus, type FocusOptions, type FocusChangeEvent, type NonNullish, type Factory, type Middleware, type MiddlewareContext, type Resolver, type ResolverOptions, } from './types';
+export { STORION_TYPE, type StorionKind, type StorionObject, type StateBase, type ActionsBase, type Equality, type EqualityMap, type Lifetime, type DispatchEvent, type ActionDispatchEvent, type ReactiveAction, type ReactiveActions, type StoreSpec, type StoreContext, type StoreMixin, type StoreOptions, type StoreInstance, type StoreContainer, type ContainerOptions, type StoreMiddleware, type SelectorContext, type SelectorMixin, type Selector, type StoreTuple, type StableResult, type PickEquality, type StatePath, type PathValue, type Focus, type FocusOptions, type FocusChangeEvent, type NonNullish, type Factory, type Middleware, type MiddlewareContext, type Resolver, type ResolverOptions, type MetaType, type MetaInfo, } from './types';
 export { is, isStorion, getKind, isSpec, isContainer, isStore, isFocus, isAction, isStoreContext, isSelectorContext, } from './is';
 export { store } from './core/store';
 export { container } from './core/container';
@@ -11,9 +11,11 @@ export { batch, untrack } from './core/tracking';
 export { createResolver, when, createLoggingMiddleware, createValidationMiddleware, } from './core/createResolver';
 export { pick } from './core/pick';
 export { effect, type EffectFn, type EffectContext, type EffectOptions, type EffectErrorStrategy, type EffectErrorContext, type EffectRetryConfig, } from './core/effect';
-export { applyFor, applyExcept, compose, forStores, type SpecPattern, } from './core/middleware';
+export { applyFor, applyExcept, forStores, type SpecPattern, } from './core/middleware';
 export { equality, shallowEqual, deepEqual, strictEqual, } from './core/equality';
 export { trigger, type TriggerOptions } from './trigger';
 export { wrapFn as wrapFn, unwrapFn, isWrappedFn } from './core/fnWrapper';
 export { StorionError, SetupPhaseError, LifetimeMismatchError, AsyncFunctionError, StoreDisposedError, InvalidActionError, HooksContextError, ProviderMissingError, LocalStoreDependencyError, EffectRefreshError, } from './errors';
+export { meta } from './meta/meta';
+export { withMeta } from './meta/withMeta';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EACL,YAAY,EACZ,KAAK,WAAW,EAChB,KAAK,aAAa,EAClB,KAAK,SAAS,EACd,KAAK,WAAW,EAChB,KAAK,QAAQ,EACb,KAAK,WAAW,EAChB,KAAK,QAAQ,EACb,KAAK,aAAa,EAClB,KAAK,mBAAmB,EACxB,KAAK,cAAc,EACnB,KAAK,eAAe,EACpB,KAAK,SAAS,EACd,KAAK,SAAS,EACd,KAAK,YAAY,EACjB,KAAK,UAAU,EACf,KAAK,YAAY,EACjB,KAAK,aAAa,EAClB,KAAK,cAAc,EACnB,KAAK,gBAAgB,EACrB,KAAK,eAAe,EACpB,KAAK,eAAe,EACpB,KAAK,aAAa,EAClB,KAAK,QAAQ,EACb,KAAK,UAAU,EACf,KAAK,YAAY,EACjB,KAAK,YAAY,EAEjB,KAAK,SAAS,EACd,KAAK,SAAS,EACd,KAAK,KAAK,EACV,KAAK,YAAY,EACjB,KAAK,gBAAgB,EACrB,KAAK,UAAU,EAEf,KAAK,OAAO,EACZ,KAAK,UAAU,EACf,KAAK,iBAAiB,EACtB,KAAK,QAAQ,EACb,KAAK,eAAe,GACrB,MAAM,SAAS,CAAC;AAGjB,OAAO,EACL,EAAE,EACF,SAAS,EACT,OAAO,EACP,MAAM,EACN,WAAW,EACX,OAAO,EACP,OAAO,EACP,QAAQ,EACR,cAAc,EACd,iBAAiB,GAClB,MAAM,MAAM,CAAC;AAGd,OAAO,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AACrC,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAC7C,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAGjD,OAAO,EACL,cAAc,EACd,IAAI,EACJ,uBAAuB,EACvB,0BAA0B,GAC3B,MAAM,uBAAuB,CAAC;AAG/B,OAAO,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AAEnC,OAAO,EACL,MAAM,EACN,KAAK,QAAQ,EACb,KAAK,aAAa,EAClB,KAAK,aAAa,EAClB,KAAK,mBAAmB,EACxB,KAAK,kBAAkB,EACvB,KAAK,iBAAiB,GACvB,MAAM,eAAe,CAAC;AAGvB,OAAO,EACL,QAAQ,EACR,WAAW,EACX,OAAO,EACP,SAAS,EACT,KAAK,WAAW,GACjB,MAAM,mBAAmB,CAAC;AAG3B,OAAO,EACL,QAAQ,EACR,YAAY,EACZ,SAAS,EACT,WAAW,GACZ,MAAM,iBAAiB,CAAC;AAGzB,OAAO,EAAE,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,WAAW,CAAC;AAGzD,OAAO,EAAE,MAAM,IAAI,MAAM,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAG3E,OAAO,EACL,YAAY,EACZ,eAAe,EACf,qBAAqB,EACrB,kBAAkB,EAClB,kBAAkB,EAClB,kBAAkB,EAClB,iBAAiB,EACjB,oBAAoB,EACpB,yBAAyB,EACzB,kBAAkB,GACnB,MAAM,UAAU,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EACL,YAAY,EACZ,KAAK,WAAW,EAChB,KAAK,aAAa,EAClB,KAAK,SAAS,EACd,KAAK,WAAW,EAChB,KAAK,QAAQ,EACb,KAAK,WAAW,EAChB,KAAK,QAAQ,EACb,KAAK,aAAa,EAClB,KAAK,mBAAmB,EACxB,KAAK,cAAc,EACnB,KAAK,eAAe,EACpB,KAAK,SAAS,EACd,KAAK,YAAY,EACjB,KAAK,UAAU,EACf,KAAK,YAAY,EACjB,KAAK,aAAa,EAClB,KAAK,cAAc,EACnB,KAAK,gBAAgB,EACrB,KAAK,eAAe,EACpB,KAAK,eAAe,EACpB,KAAK,aAAa,EAClB,KAAK,QAAQ,EACb,KAAK,UAAU,EACf,KAAK,YAAY,EACjB,KAAK,YAAY,EAEjB,KAAK,SAAS,EACd,KAAK,SAAS,EACd,KAAK,KAAK,EACV,KAAK,YAAY,EACjB,KAAK,gBAAgB,EACrB,KAAK,UAAU,EAEf,KAAK,OAAO,EACZ,KAAK,UAAU,EACf,KAAK,iBAAiB,EACtB,KAAK,QAAQ,EACb,KAAK,eAAe,EAEpB,KAAK,QAAQ,EACb,KAAK,QAAQ,GACd,MAAM,SAAS,CAAC;AAGjB,OAAO,EACL,EAAE,EACF,SAAS,EACT,OAAO,EACP,MAAM,EACN,WAAW,EACX,OAAO,EACP,OAAO,EACP,QAAQ,EACR,cAAc,EACd,iBAAiB,GAClB,MAAM,MAAM,CAAC;AAGd,OAAO,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AACrC,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAC7C,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAGjD,OAAO,EACL,cAAc,EACd,IAAI,EACJ,uBAAuB,EACvB,0BAA0B,GAC3B,MAAM,uBAAuB,CAAC;AAG/B,OAAO,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AAEnC,OAAO,EACL,MAAM,EACN,KAAK,QAAQ,EACb,KAAK,aAAa,EAClB,KAAK,aAAa,EAClB,KAAK,mBAAmB,EACxB,KAAK,kBAAkB,EACvB,KAAK,iBAAiB,GACvB,MAAM,eAAe,CAAC;AAGvB,OAAO,EACL,QAAQ,EACR,WAAW,EACX,SAAS,EACT,KAAK,WAAW,GACjB,MAAM,mBAAmB,CAAC;AAG3B,OAAO,EACL,QAAQ,EACR,YAAY,EACZ,SAAS,EACT,WAAW,GACZ,MAAM,iBAAiB,CAAC;AAGzB,OAAO,EAAE,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,WAAW,CAAC;AAGzD,OAAO,EAAE,MAAM,IAAI,MAAM,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAG3E,OAAO,EACL,YAAY,EACZ,eAAe,EACf,qBAAqB,EACrB,kBAAkB,EAClB,kBAAkB,EAClB,kBAAkB,EAClB,iBAAiB,EACjB,oBAAoB,EACpB,yBAAyB,EACzB,kBAAkB,GACnB,MAAM,UAAU,CAAC;AAGlB,OAAO,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AACnC,OAAO,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/isPromiseLike-bFkfHAbm.js

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

package/dist/meta/createMetaQuery.d.ts

@@ -0,0 +1,10 @@
+import { MetaEntry, MetaQuery } from '../types';
+
+/**
+ * Creates a MetaQuery object for querying store metadata.
+ *
+ * @param entries - Array of MetaEntry objects from store options
+ * @returns MetaQuery interface with single/all/any methods
+ */
+export declare function createMetaQuery(entries: undefined | MetaEntry | MetaEntry[]): MetaQuery;
+//# sourceMappingURL=createMetaQuery.d.ts.map

package/dist/meta/createMetaQuery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createMetaQuery.d.ts","sourceRoot":"","sources":["../../src/meta/createMetaQuery.ts"],"names":[],"mappings":"AAAA,OAAO,EAAwB,SAAS,EAAY,SAAS,EAAE,MAAM,UAAU,CAAC;AAEhF;;;;;GAKG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,SAAS,GAAG,SAAS,GAAG,SAAS,EAAE,GAC3C,SAAS,CAiFX"}

package/dist/meta/index.d.ts

@@ -0,0 +1,4 @@
+export { meta } from './meta';
+export { createMetaQuery } from './createMetaQuery';
+export { withMeta } from './withMeta';
+//# sourceMappingURL=index.d.ts.map