yummies 7.11.0 → 7.13.0

package/complex.cjs

@@ -1,139 +1,286 @@
-"use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const createCounter = (processValue, initial = 0) => {
-  const update = (counter) => {
-    fn.value = processValue?.(counter) ?? counter;
-    return fn.value;
-  };
-  const increment = () => update(++fn.counter);
-  const decrement = () => update(--fn.counter);
-  const fn = increment;
-  fn.increment = increment;
-  fn.decrement = decrement;
-  fn.reset = () => {
-    fn.counter = initial;
-    fn.value = processValue?.(initial) ?? initial;
-  };
-  fn.reset();
-  return fn;
+//#region src/complex/counter.ts
+/**
+* Creates a callable counter object with increment, decrement and reset helpers.
+*
+* The returned function increments the internal numeric counter when called and
+* exposes both the raw counter value and an optionally transformed `value`.
+*
+* @template TValue Public value type returned by the counter.
+* @param processValue Optional mapper that transforms the numeric counter value.
+* @param initial Initial numeric counter value.
+* @returns Callable counter with state and control methods.
+*
+* @example
+* ```ts
+* const counter = createCounter();
+* counter.increment(); // 1
+* ```
+*
+* @example
+* ```ts
+* const idCounter = createCounter((value) => `id-${value}`, 10);
+* idCounter(); // 'id-11'
+* ```
+*/
+var createCounter = (processValue, initial = 0) => {
+	const update = (counter) => {
+		fn.value = processValue?.(counter) ?? counter;
+		return fn.value;
+	};
+	const increment = () => update(++fn.counter);
+	const decrement = () => update(--fn.counter);
+	const fn = increment;
+	fn.increment = increment;
+	fn.decrement = decrement;
+	fn.reset = () => {
+		fn.counter = initial;
+		fn.value = processValue?.(initial) ?? initial;
+	};
+	fn.reset();
+	return fn;
 };
-const createGlobalPoint = (accessSymbol) => {
-  if (accessSymbol == null) {
-    let storedValue;
-    return {
-      get: () => storedValue,
-      unset: () => {
-        storedValue = void 0;
-      },
-      set: (value) => {
-        storedValue = value;
-        return value;
-      }
-    };
-  }
-  const _globalThis = globalThis;
-  return {
-    get: () => _globalThis[accessSymbol],
-    unset: () => {
-      delete _globalThis[accessSymbol];
-    },
-    set: (value) => {
-      _globalThis[accessSymbol] = value;
-      return value;
-    }
-  };
+//#endregion
+//#region src/complex/global-point.ts
+/**
+* Creates a simple storage point that can live either in `globalThis` under a
+* provided key or in a local closure when no key is given.
+*
+* @template TValue Stored value type.
+* @param accessSymbol Optional global property name used for storage.
+* @returns Getter/setter API for the stored value.
+*
+* @example
+* ```ts
+* const point = createGlobalPoint<number>();
+* point.set(10);
+* ```
+*
+* @example
+* ```ts
+* const point = createGlobalPoint<string>('__token__');
+* point.get();
+* ```
+*/
+var createGlobalPoint = (accessSymbol) => {
+	if (accessSymbol == null) {
+		let storedValue;
+		return {
+			get: () => storedValue,
+			unset: () => {
+				storedValue = void 0;
+			},
+			set: (value) => {
+				storedValue = value;
+				return value;
+			}
+		};
+	}
+	const _globalThis = globalThis;
+	return {
+		get: () => _globalThis[accessSymbol],
+		unset: () => {
+			delete _globalThis[accessSymbol];
+		},
+		set: (value) => {
+			_globalThis[accessSymbol] = value;
+			return value;
+		}
+	};
 };
-const createGlobalConfig = (defaultValue, accessSymbol) => {
-  const globalPoint = createGlobalPoint(accessSymbol);
-  return globalPoint.get() || globalPoint.set(defaultValue);
+//#endregion
+//#region src/complex/global-config.ts
+/**
+* Creates or reuses a globally accessible config object.
+*
+* The config is stored in a global point identified by `accessSymbol`, or in a
+* local closure when no symbol is provided.
+*
+* @template T Config object type.
+* @param defaultValue Default value used when no config has been created yet.
+* @param accessSymbol Optional global key used to store the config.
+* @returns Existing or newly initialized global config object.
+*
+* @example
+* ```ts
+* const config = createGlobalConfig({ locale: 'en' }, '__app_config__');
+* ```
+*
+* @example
+* ```ts
+* const config = createGlobalConfig({ debug: false });
+* config.debug;
+* ```
+*/
+var createGlobalConfig = (defaultValue, accessSymbol) => {
+	const globalPoint = createGlobalPoint(accessSymbol);
+	return globalPoint.get() || globalPoint.set(defaultValue);
 };
-const createGlobalDynamicConfig = (processFn, accessSymbol) => {
-  const globalPoint = createGlobalPoint(accessSymbol);
-  const getValue = () => {
-    return globalPoint.get() ?? globalPoint.set(processFn(null, null));
-  };
-  return {
-    get: getValue,
-    set: globalPoint.set,
-    unset: globalPoint.unset,
-    update: (value) => {
-      const currentValue = getValue();
-      Object.assign(currentValue, processFn(value, currentValue));
-    }
-  };
+/**
+* Creates a mutable global config manager whose value is produced and updated
+* through a custom processor function.
+*
+* @template T Config object type.
+* @param processFn Function that builds the next config state from a partial change and current value.
+* @param accessSymbol Optional global key used to store the config.
+* @returns API for reading, replacing, resetting and partially updating the config.
+*
+* @example
+* ```ts
+* const config = createGlobalDynamicConfig(
+*   (change, current) => ({ theme: 'light', ...current, ...change }),
+*   '__theme__',
+* );
+* ```
+*
+* @example
+* ```ts
+* const config = createGlobalDynamicConfig((change, current) => ({ ...current, ...change }));
+* config.update({ locale: 'ru' });
+* ```
+*/
+var createGlobalDynamicConfig = (processFn, accessSymbol) => {
+	const globalPoint = createGlobalPoint(accessSymbol);
+	const getValue = () => {
+		return globalPoint.get() ?? globalPoint.set(processFn(null, null));
+	};
+	return {
+		get: getValue,
+		set: globalPoint.set,
+		unset: globalPoint.unset,
+		update: (value) => {
+			const currentValue = getValue();
+			Object.assign(currentValue, processFn(value, currentValue));
+		}
+	};
 };
-class ModulesFactory {
-  /**
-   * Creates a new module factory.
-   *
-   * @param config Factory strategy and predefined dependencies.
-   *
-   * @example
-   * ```ts
-   * const factory = new ModulesFactory({
-   *   factory: (Module, deps) => new Module(deps),
-   * });
-   * ```
-   *
-   * @example
-   * ```ts
-   * const factory = new ModulesFactory({
-   *   factory: (Module, deps) => new Module(deps),
-   *   deps: { api },
-   * });
-   * ```
-   */
-  constructor(config) {
-    this.config = config;
-  }
-  /**
-   * Creates an instance of the provided class by merging predefined and
-   * per-call dependencies.
-   *
-   * @template TInstance Instance type produced by the constructor.
-   * @template TDeps Full dependency object expected by the constructor.
-   * @param Constructor Class constructor receiving a single dependency object.
-   * @param args Additional dependencies merged over predefined ones.
-   * @returns Created class instance.
-   *
-   * @example
-   * ```ts
-   * const service = factory.create(UserService, { logger });
-   * ```
-   *
-   * @example
-   * ```ts
-   * const store = factory.create(UserStore);
-   * ```
-   */
-  create(Constructor, ...args) {
-    return this.config.factory(Constructor, {
-      ...this.config.deps,
-      ...args[0]
-    });
-  }
-}
-const createPubSub = () => {
-  const pubSub = ((...args) => {
-    pubSub.lastPub = args;
-    pubSub.subs.forEach((sub) => {
-      sub(...args);
-    });
-  });
-  pubSub.lastPub = void 0;
-  pubSub.subs = [];
-  pubSub.unsub = (sub) => {
-    pubSub.subs = pubSub.subs.filter((it) => it !== sub);
-  };
-  pubSub.sub = (sub) => {
-    pubSub.subs.push(sub);
-    return () => pubSub.unsub(sub);
-  };
-  return pubSub;
+//#endregion
+//#region src/complex/modules-factory.ts
+/**
+* Universal factory for creating class instances with predefined and per-call
+* dependencies.
+*
+* Works with classes whose constructor accepts a single dependency object.
+*
+* @template TPredefinedDeps Dependency shape that is always injected by the factory.
+*
+* @example
+* ```
+* const factory = new ModulesFactory({
+*   factory: (MyClass, deps) => new MyClass(deps),
+*   deps: { someDependency: new Dependency() }
+* });
+*
+* const instance = factory.create(MyClass, { extraDependency: new ExtraDependency() });
+* ```
+*
+* @example
+* ```ts
+* const factory = new ModulesFactory({
+*   factory: (Module, deps) => new Module(deps),
+* });
+* ```
+*
+* @example
+* ```ts
+* const service = factory.create(UserService, { api });
+* ```
+*/
+var ModulesFactory = class {
+	/**
+	* Creates a new module factory.
+	*
+	* @param config Factory strategy and predefined dependencies.
+	*
+	* @example
+	* ```ts
+	* const factory = new ModulesFactory({
+	*   factory: (Module, deps) => new Module(deps),
+	* });
+	* ```
+	*
+	* @example
+	* ```ts
+	* const factory = new ModulesFactory({
+	*   factory: (Module, deps) => new Module(deps),
+	*   deps: { api },
+	* });
+	* ```
+	*/
+	constructor(config) {
+		this.config = config;
+	}
+	/**
+	* Creates an instance of the provided class by merging predefined and
+	* per-call dependencies.
+	*
+	* @template TInstance Instance type produced by the constructor.
+	* @template TDeps Full dependency object expected by the constructor.
+	* @param Constructor Class constructor receiving a single dependency object.
+	* @param args Additional dependencies merged over predefined ones.
+	* @returns Created class instance.
+	*
+	* @example
+	* ```ts
+	* const service = factory.create(UserService, { logger });
+	* ```
+	*
+	* @example
+	* ```ts
+	* const store = factory.create(UserStore);
+	* ```
+	*/
+	create(Constructor, ...args) {
+		return this.config.factory(Constructor, {
+			...this.config.deps,
+			...args[0]
+		});
+	}
 };
+//#endregion
+//#region src/complex/pub-sub.ts
+/**
+* Creates a simple publish-subscribe dispatcher that stores the last published
+* arguments and allows subscription management.
+*
+* @template PubArgs Argument tuple delivered to subscribers.
+* @returns Callable publisher with subscribe and unsubscribe helpers.
+*
+* @example
+* ```ts
+* const pub = createPubSub<[string]>();
+* pub('ready');
+* ```
+*
+* @example
+* ```ts
+* const pub = createPubSub<[number]>();
+* const unsub = pub.sub((value) => console.log(value));
+* ```
+*/
+var createPubSub = () => {
+	const pubSub = ((...args) => {
+		pubSub.lastPub = args;
+		pubSub.subs.forEach((sub) => {
+			sub(...args);
+		});
+	});
+	pubSub.lastPub = void 0;
+	pubSub.subs = [];
+	pubSub.unsub = (sub) => {
+		pubSub.subs = pubSub.subs.filter((it) => it !== sub);
+	};
+	pubSub.sub = (sub) => {
+		pubSub.subs.push(sub);
+		return () => pubSub.unsub(sub);
+	};
+	return pubSub;
+};
+//#endregion
 exports.ModulesFactory = ModulesFactory;
 exports.createCounter = createCounter;
 exports.createGlobalConfig = createGlobalConfig;
 exports.createGlobalDynamicConfig = createGlobalDynamicConfig;
 exports.createPubSub = createPubSub;
-//# sourceMappingURL=complex.cjs.map
+
+//# sourceMappingURL=complex.cjs.map

package/complex.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"complex.cjs","sources":["../src/complex/counter.ts","../src/complex/global-point.ts","../src/complex/global-config.ts","../src/complex/modules-factory.ts","../src/complex/pub-sub.ts"],"sourcesContent":["export interface Counter<TValue = number> {\n  (): TValue;\n  counter: number;\n  value: TValue;\n  increment(): TValue;\n  decrement(): TValue;\n  reset(): void;\n}\n\n/**\n * @deprecated use {`Counter`}. Will be removed in next major release\n */\nexport interface CounterFn<TValue = number> extends Counter<TValue> {}\n\n/**\n * Creates a callable counter object with increment, decrement and reset helpers.\n *\n * The returned function increments the internal numeric counter when called and\n * exposes both the raw counter value and an optionally transformed `value`.\n *\n * @template TValue Public value type returned by the counter.\n * @param processValue Optional mapper that transforms the numeric counter value.\n * @param initial Initial numeric counter value.\n * @returns Callable counter with state and control methods.\n *\n * @example\n * ```ts\n * const counter = createCounter();\n * counter.increment(); // 1\n * ```\n *\n * @example\n * ```ts\n * const idCounter = createCounter((value) => `id-${value}`, 10);\n * idCounter(); // 'id-11'\n * ```\n */\nexport const createCounter = <TValue = number>(\n  processValue?: (value: number) => TValue,\n  initial: number = 0,\n): Counter<TValue> => {\n  const update = (counter: number) => {\n    fn.value = processValue?.(counter) ?? (counter as TValue);\n    return fn.value;\n  };\n\n  const increment = () => update(++fn.counter);\n  const decrement = () => update(--fn.counter);\n\n  const fn: Counter<TValue> = increment as any;\n\n  fn.increment = increment;\n  fn.decrement = decrement;\n\n  fn.reset = () => {\n    fn.counter = initial;\n    fn.value = processValue?.(initial) ?? (initial as TValue);\n  };\n\n  fn.reset();\n\n  return fn as Counter<TValue>;\n};\n","import type { AnyObject } from 'yummies/types';\n\nexport interface GlobalPoint<TValue> {\n  get(): TValue;\n  set(value: TValue): TValue;\n  unset(): void;\n}\n\n/**\n * Creates a simple storage point that can live either in `globalThis` under a\n * provided key or in a local closure when no key is given.\n *\n * @template TValue Stored value type.\n * @param accessSymbol Optional global property name used for storage.\n * @returns Getter/setter API for the stored value.\n *\n * @example\n * ```ts\n * const point = createGlobalPoint<number>();\n * point.set(10);\n * ```\n *\n * @example\n * ```ts\n * const point = createGlobalPoint<string>('__token__');\n * point.get();\n * ```\n */\nexport const createGlobalPoint = <TValue>(\n  accessSymbol?: keyof any,\n): GlobalPoint<TValue> => {\n  if (accessSymbol == null) {\n    let storedValue: TValue | undefined;\n\n    return {\n      get: (): TValue => storedValue!,\n      unset: () => {\n        storedValue = undefined;\n      },\n      set: (value: TValue): TValue => {\n        storedValue = value;\n        return value;\n      },\n    };\n  }\n\n  const _globalThis = globalThis as AnyObject;\n\n  return {\n    get: (): TValue => _globalThis[accessSymbol],\n    unset: () => {\n      delete _globalThis[accessSymbol];\n    },\n    set: (value: TValue): TValue => {\n      _globalThis[accessSymbol] = value;\n      return value;\n    },\n  };\n};\n","import type { AnyObject, Maybe } from 'yummies/types';\nimport { createGlobalPoint } from './global-point.js';\n\n/**\n * Creates or reuses a globally accessible config object.\n *\n * The config is stored in a global point identified by `accessSymbol`, or in a\n * local closure when no symbol is provided.\n *\n * @template T Config object type.\n * @param defaultValue Default value used when no config has been created yet.\n * @param accessSymbol Optional global key used to store the config.\n * @returns Existing or newly initialized global config object.\n *\n * @example\n * ```ts\n * const config = createGlobalConfig({ locale: 'en' }, '__app_config__');\n * ```\n *\n * @example\n * ```ts\n * const config = createGlobalConfig({ debug: false });\n * config.debug;\n * ```\n */\nexport const createGlobalConfig = <T extends AnyObject>(\n  defaultValue: T,\n  accessSymbol?: keyof any,\n): T => {\n  const globalPoint = createGlobalPoint<T>(accessSymbol);\n  return globalPoint.get() || globalPoint.set(defaultValue);\n};\n\nexport interface GlobalDynamicConfig<TValue extends AnyObject> {\n  get(): TValue;\n  set(value: TValue): TValue;\n  unset(): void;\n  update(value: Partial<TValue>): void;\n}\n\n/**\n * Creates a mutable global config manager whose value is produced and updated\n * through a custom processor function.\n *\n * @template T Config object type.\n * @param processFn Function that builds the next config state from a partial change and current value.\n * @param accessSymbol Optional global key used to store the config.\n * @returns API for reading, replacing, resetting and partially updating the config.\n *\n * @example\n * ```ts\n * const config = createGlobalDynamicConfig(\n *   (change, current) => ({ theme: 'light', ...current, ...change }),\n *   '__theme__',\n * );\n * ```\n *\n * @example\n * ```ts\n * const config = createGlobalDynamicConfig((change, current) => ({ ...current, ...change }));\n * config.update({ locale: 'ru' });\n * ```\n */\nexport const createGlobalDynamicConfig = <T extends AnyObject>(\n  processFn: (change: Maybe<Partial<T>>, current: Maybe<T>) => T,\n  accessSymbol?: keyof any,\n): GlobalDynamicConfig<T> => {\n  const globalPoint = createGlobalPoint<T>(accessSymbol);\n\n  const getValue = () => {\n    return globalPoint.get() ?? globalPoint.set(processFn(null, null))!;\n  };\n\n  return {\n    get: getValue,\n    set: globalPoint.set,\n    unset: globalPoint.unset,\n    update: (value: Partial<T>) => {\n      const currentValue = getValue();\n      Object.assign(currentValue, processFn(value, currentValue));\n    },\n  };\n};\n","import type { AnyObject, Class, EmptyObject, IsPartial } from 'yummies/types';\n\ntype ModuleLoaderConfig<TPredefinedDeps extends AnyObject = EmptyObject> = {\n  factory<TInstance, TDeps extends TPredefinedDeps>(\n    moduleClass: Class<TInstance, [TDeps]>,\n    deps: TDeps,\n  ): TInstance;\n} & (TPredefinedDeps extends EmptyObject\n  ? { deps?: TPredefinedDeps }\n  : { deps: TPredefinedDeps });\n\n/**\n * Universal factory for creating class instances with predefined and per-call\n * dependencies.\n *\n * Works with classes whose constructor accepts a single dependency object.\n *\n * @template TPredefinedDeps Dependency shape that is always injected by the factory.\n *\n * @example\n * ```\n * const factory = new ModulesFactory({\n *   factory: (MyClass, deps) => new MyClass(deps),\n *   deps: { someDependency: new Dependency() }\n * });\n *\n * const instance = factory.create(MyClass, { extraDependency: new ExtraDependency() });\n * ```\n *\n * @example\n * ```ts\n * const factory = new ModulesFactory({\n *   factory: (Module, deps) => new Module(deps),\n * });\n * ```\n *\n * @example\n * ```ts\n * const service = factory.create(UserService, { api });\n * ```\n */\nexport class ModulesFactory<TPredefinedDeps extends AnyObject = EmptyObject> {\n  /**\n   * Creates a new module factory.\n   *\n   * @param config Factory strategy and predefined dependencies.\n   *\n   * @example\n   * ```ts\n   * const factory = new ModulesFactory({\n   *   factory: (Module, deps) => new Module(deps),\n   * });\n   * ```\n   *\n   * @example\n   * ```ts\n   * const factory = new ModulesFactory({\n   *   factory: (Module, deps) => new Module(deps),\n   *   deps: { api },\n   * });\n   * ```\n   */\n  constructor(private config: ModuleLoaderConfig<TPredefinedDeps>) {}\n\n  /**\n   * Creates an instance of the provided class by merging predefined and\n   * per-call dependencies.\n   *\n   * @template TInstance Instance type produced by the constructor.\n   * @template TDeps Full dependency object expected by the constructor.\n   * @param Constructor Class constructor receiving a single dependency object.\n   * @param args Additional dependencies merged over predefined ones.\n   * @returns Created class instance.\n   *\n   * @example\n   * ```ts\n   * const service = factory.create(UserService, { logger });\n   * ```\n   *\n   * @example\n   * ```ts\n   * const store = factory.create(UserStore);\n   * ```\n   */\n  create<TInstance, TDeps extends TPredefinedDeps = TPredefinedDeps>(\n    Constructor: Class<TInstance, [TDeps]>,\n    ...args: IsPartial<Omit<TDeps, keyof TPredefinedDeps>> extends true\n      ? [extraDeps?: Omit<TDeps, keyof TPredefinedDeps>]\n      : [extraDeps: Omit<TDeps, keyof TPredefinedDeps>]\n  ) {\n    return this.config.factory(Constructor, {\n      ...this.config.deps!,\n      ...args[0],\n    } as any);\n  }\n}\n","export type SubFn<PubArgs extends any[] = any[]> = (...args: PubArgs) => void;\n\n/**\n * The Publish-Subscribe pattern, which allows objects to interact with each other\n * through an event system. Subscribers can subscribe to events and receive notifications\n * when these events occur. The last published data can be accessed through the `data` property.\n */\nexport interface PubSub<PubArgs extends any[] = any[]> {\n  (...args: PubArgs): void;\n\n  /**\n   * Last published arguments\n   */\n  lastPub: PubArgs | undefined;\n\n  /**\n   * An array of subscriber functions (sub) that will be called\n   * when an event is published. Each subscriber must match the type SubFn,\n   * taking the arguments that will be passed to it when the publisher calls pub.\n   */\n  subs: SubFn<PubArgs>[];\n\n  /**\n   * A function to unsubscribe from events. When a subscriber function (sub) is passed,\n   * it will be removed from the `subs` array, and will no longer receive notifications.\n   */\n  unsub(sub: SubFn<PubArgs>): void;\n  /**\n   * A function to subscribe to events. When a subscriber function (sub) is passed,\n   * it will be added to the `subs` array, and will receive notifications when the publisher calls pub.\n   * Returns a function that can be used to unsubscribe from events.\n   */\n  sub(sub: SubFn<PubArgs>): VoidFunction;\n}\n\n/**\n * Creates a simple publish-subscribe dispatcher that stores the last published\n * arguments and allows subscription management.\n *\n * @template PubArgs Argument tuple delivered to subscribers.\n * @returns Callable publisher with subscribe and unsubscribe helpers.\n *\n * @example\n * ```ts\n * const pub = createPubSub<[string]>();\n * pub('ready');\n * ```\n *\n * @example\n * ```ts\n * const pub = createPubSub<[number]>();\n * const unsub = pub.sub((value) => console.log(value));\n * ```\n */\nexport const createPubSub = <PubArgs extends any[] = any[]>() => {\n  const pubSub = ((...args: PubArgs) => {\n    pubSub.lastPub = args;\n    pubSub.subs.forEach((sub) => {\n      sub(...args);\n    });\n  }) as PubSub<PubArgs>;\n  pubSub.lastPub = undefined;\n\n  pubSub.subs = [];\n\n  pubSub.unsub = (sub: SubFn<PubArgs>) => {\n    pubSub.subs = pubSub.subs.filter((it) => it !== sub);\n  };\n  pubSub.sub = (sub: SubFn<PubArgs>) => {\n    pubSub.subs.push(sub);\n    return () => pubSub.unsub(sub);\n  };\n\n  return pubSub;\n};\n"],"names":[],"mappings":";;AAqCO,MAAM,gBAAgB,CAC3B,cACA,UAAkB,MACE;AACpB,QAAM,SAAS,CAAC,YAAoB;AAClC,OAAG,QAAQ,eAAe,OAAO,KAAM;AACvC,WAAO,GAAG;AAAA,EACZ;AAEA,QAAM,YAAY,MAAM,OAAO,EAAE,GAAG,OAAO;AAC3C,QAAM,YAAY,MAAM,OAAO,EAAE,GAAG,OAAO;AAE3C,QAAM,KAAsB;AAE5B,KAAG,YAAY;AACf,KAAG,YAAY;AAEf,KAAG,QAAQ,MAAM;AACf,OAAG,UAAU;AACb,OAAG,QAAQ,eAAe,OAAO,KAAM;AAAA,EACzC;AAEA,KAAG,MAAA;AAEH,SAAO;AACT;AClCO,MAAM,oBAAoB,CAC/B,iBACwB;AACxB,MAAI,gBAAgB,MAAM;AACxB,QAAI;AAEJ,WAAO;AAAA,MACL,KAAK,MAAc;AAAA,MACnB,OAAO,MAAM;AACX,sBAAc;AAAA,MAChB;AAAA,MACA,KAAK,CAAC,UAA0B;AAC9B,sBAAc;AACd,eAAO;AAAA,MACT;AAAA,IAAA;AAAA,EAEJ;AAEA,QAAM,cAAc;AAEpB,SAAO;AAAA,IACL,KAAK,MAAc,YAAY,YAAY;AAAA,IAC3C,OAAO,MAAM;AACX,aAAO,YAAY,YAAY;AAAA,IACjC;AAAA,IACA,KAAK,CAAC,UAA0B;AAC9B,kBAAY,YAAY,IAAI;AAC5B,aAAO;AAAA,IACT;AAAA,EAAA;AAEJ;ACjCO,MAAM,qBAAqB,CAChC,cACA,iBACM;AACN,QAAM,cAAc,kBAAqB,YAAY;AACrD,SAAO,YAAY,IAAA,KAAS,YAAY,IAAI,YAAY;AAC1D;AAgCO,MAAM,4BAA4B,CACvC,WACA,iBAC2B;AAC3B,QAAM,cAAc,kBAAqB,YAAY;AAErD,QAAM,WAAW,MAAM;AACrB,WAAO,YAAY,SAAS,YAAY,IAAI,UAAU,MAAM,IAAI,CAAC;AAAA,EACnE;AAEA,SAAO;AAAA,IACL,KAAK;AAAA,IACL,KAAK,YAAY;AAAA,IACjB,OAAO,YAAY;AAAA,IACnB,QAAQ,CAAC,UAAsB;AAC7B,YAAM,eAAe,SAAA;AACrB,aAAO,OAAO,cAAc,UAAU,OAAO,YAAY,CAAC;AAAA,IAC5D;AAAA,EAAA;AAEJ;ACzCO,MAAM,eAAgE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAqB3E,YAAoB,QAA6C;AAA7C,SAAA,SAAA;AAAA,EAA8C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAsBlE,OACE,gBACG,MAGH;AACA,WAAO,KAAK,OAAO,QAAQ,aAAa;AAAA,MACtC,GAAG,KAAK,OAAO;AAAA,MACf,GAAG,KAAK,CAAC;AAAA,IAAA,CACH;AAAA,EACV;AACF;ACzCO,MAAM,eAAe,MAAqC;AAC/D,QAAM,UAAU,IAAI,SAAkB;AACpC,WAAO,UAAU;AACjB,WAAO,KAAK,QAAQ,CAAC,QAAQ;AAC3B,UAAI,GAAG,IAAI;AAAA,IACb,CAAC;AAAA,EACH;AACA,SAAO,UAAU;AAEjB,SAAO,OAAO,CAAA;AAEd,SAAO,QAAQ,CAAC,QAAwB;AACtC,WAAO,OAAO,OAAO,KAAK,OAAO,CAAC,OAAO,OAAO,GAAG;AAAA,EACrD;AACA,SAAO,MAAM,CAAC,QAAwB;AACpC,WAAO,KAAK,KAAK,GAAG;AACpB,WAAO,MAAM,OAAO,MAAM,GAAG;AAAA,EAC/B;AAEA,SAAO;AACT;;;;;;"}
+{"version":3,"file":"complex.cjs","names":[],"sources":["../src/complex/counter.ts","../src/complex/global-point.ts","../src/complex/global-config.ts","../src/complex/modules-factory.ts","../src/complex/pub-sub.ts"],"sourcesContent":["/**\n * ---header-docs-section---\n * # yummies/complex\n *\n * ## Description\n *\n * Callable **counter** objects with increment, decrement, and reset for UI steppers, pagination,\n * and id generators. Values can be mapped on read so the public API stays typed while the internal\n * tick stays numeric. This file is the `counter` slice of the broader `yummies/complex` entry point.\n *\n * ## Usage\n *\n * ```ts\n * import { createCounter } from \"yummies/complex\";\n * ```\n */\n\nexport interface Counter<TValue = number> {\n  (): TValue;\n  counter: number;\n  value: TValue;\n  increment(): TValue;\n  decrement(): TValue;\n  reset(): void;\n}\n\n/**\n * @deprecated use {`Counter`}. Will be removed in next major release\n */\nexport interface CounterFn<TValue = number> extends Counter<TValue> {}\n\n/**\n * Creates a callable counter object with increment, decrement and reset helpers.\n *\n * The returned function increments the internal numeric counter when called and\n * exposes both the raw counter value and an optionally transformed `value`.\n *\n * @template TValue Public value type returned by the counter.\n * @param processValue Optional mapper that transforms the numeric counter value.\n * @param initial Initial numeric counter value.\n * @returns Callable counter with state and control methods.\n *\n * @example\n * ```ts\n * const counter = createCounter();\n * counter.increment(); // 1\n * ```\n *\n * @example\n * ```ts\n * const idCounter = createCounter((value) => `id-${value}`, 10);\n * idCounter(); // 'id-11'\n * ```\n */\nexport const createCounter = <TValue = number>(\n  processValue?: (value: number) => TValue,\n  initial: number = 0,\n): Counter<TValue> => {\n  const update = (counter: number) => {\n    fn.value = processValue?.(counter) ?? (counter as TValue);\n    return fn.value;\n  };\n\n  const increment = () => update(++fn.counter);\n  const decrement = () => update(--fn.counter);\n\n  const fn: Counter<TValue> = increment as any;\n\n  fn.increment = increment;\n  fn.decrement = decrement;\n\n  fn.reset = () => {\n    fn.counter = initial;\n    fn.value = processValue?.(initial) ?? (initial as TValue);\n  };\n\n  fn.reset();\n\n  return fn as Counter<TValue>;\n};\n","/**\n * ---header-docs-section---\n * # yummies/complex\n *\n * ## Description\n *\n * Minimal **global or scoped storage** with `get` / `set` / `unset` semantics. When an access symbol\n * is provided the value lives on `globalThis`; otherwise it is isolated in a closure. Handy for\n * bridging non-React singletons, test doubles, or legacy globals without `window.foo =` sprawl.\n *\n * ## Usage\n *\n * ```ts\n * import { createGlobalPoint } from \"yummies/complex\";\n * ```\n */\n\nimport type { AnyObject } from 'yummies/types';\n\nexport interface GlobalPoint<TValue> {\n  get(): TValue;\n  set(value: TValue): TValue;\n  unset(): void;\n}\n\n/**\n * Creates a simple storage point that can live either in `globalThis` under a\n * provided key or in a local closure when no key is given.\n *\n * @template TValue Stored value type.\n * @param accessSymbol Optional global property name used for storage.\n * @returns Getter/setter API for the stored value.\n *\n * @example\n * ```ts\n * const point = createGlobalPoint<number>();\n * point.set(10);\n * ```\n *\n * @example\n * ```ts\n * const point = createGlobalPoint<string>('__token__');\n * point.get();\n * ```\n */\nexport const createGlobalPoint = <TValue>(\n  accessSymbol?: keyof any,\n): GlobalPoint<TValue> => {\n  if (accessSymbol == null) {\n    let storedValue: TValue | undefined;\n\n    return {\n      get: (): TValue => storedValue!,\n      unset: () => {\n        storedValue = undefined;\n      },\n      set: (value: TValue): TValue => {\n        storedValue = value;\n        return value;\n      },\n    };\n  }\n\n  const _globalThis = globalThis as AnyObject;\n\n  return {\n    get: (): TValue => _globalThis[accessSymbol],\n    unset: () => {\n      delete _globalThis[accessSymbol];\n    },\n    set: (value: TValue): TValue => {\n      _globalThis[accessSymbol] = value;\n      return value;\n    },\n  };\n};\n","/**\n * ---header-docs-section---\n * # yummies/complex\n *\n * ## Description\n *\n * **Singleton-style config** backed by either `globalThis` (keyed by symbol) or a module closure.\n * Use for app-wide feature flags, bootstrapped locale, or SSR-safe defaults without prop-drilling.\n * Pairs with `createGlobalPoint` for other global handles in the same `yummies/complex` package.\n *\n * ## Usage\n *\n * ```ts\n * import { createGlobalConfig } from \"yummies/complex\";\n * ```\n */\n\nimport type { AnyObject, Maybe } from 'yummies/types';\nimport { createGlobalPoint } from './global-point.js';\n\n/**\n * Creates or reuses a globally accessible config object.\n *\n * The config is stored in a global point identified by `accessSymbol`, or in a\n * local closure when no symbol is provided.\n *\n * @template T Config object type.\n * @param defaultValue Default value used when no config has been created yet.\n * @param accessSymbol Optional global key used to store the config.\n * @returns Existing or newly initialized global config object.\n *\n * @example\n * ```ts\n * const config = createGlobalConfig({ locale: 'en' }, '__app_config__');\n * ```\n *\n * @example\n * ```ts\n * const config = createGlobalConfig({ debug: false });\n * config.debug;\n * ```\n */\nexport const createGlobalConfig = <T extends AnyObject>(\n  defaultValue: T,\n  accessSymbol?: keyof any,\n): T => {\n  const globalPoint = createGlobalPoint<T>(accessSymbol);\n  return globalPoint.get() || globalPoint.set(defaultValue);\n};\n\nexport interface GlobalDynamicConfig<TValue extends AnyObject> {\n  get(): TValue;\n  set(value: TValue): TValue;\n  unset(): void;\n  update(value: Partial<TValue>): void;\n}\n\n/**\n * Creates a mutable global config manager whose value is produced and updated\n * through a custom processor function.\n *\n * @template T Config object type.\n * @param processFn Function that builds the next config state from a partial change and current value.\n * @param accessSymbol Optional global key used to store the config.\n * @returns API for reading, replacing, resetting and partially updating the config.\n *\n * @example\n * ```ts\n * const config = createGlobalDynamicConfig(\n *   (change, current) => ({ theme: 'light', ...current, ...change }),\n *   '__theme__',\n * );\n * ```\n *\n * @example\n * ```ts\n * const config = createGlobalDynamicConfig((change, current) => ({ ...current, ...change }));\n * config.update({ locale: 'ru' });\n * ```\n */\nexport const createGlobalDynamicConfig = <T extends AnyObject>(\n  processFn: (change: Maybe<Partial<T>>, current: Maybe<T>) => T,\n  accessSymbol?: keyof any,\n): GlobalDynamicConfig<T> => {\n  const globalPoint = createGlobalPoint<T>(accessSymbol);\n\n  const getValue = () => {\n    return globalPoint.get() ?? globalPoint.set(processFn(null, null))!;\n  };\n\n  return {\n    get: getValue,\n    set: globalPoint.set,\n    unset: globalPoint.unset,\n    update: (value: Partial<T>) => {\n      const currentValue = getValue();\n      Object.assign(currentValue, processFn(value, currentValue));\n    },\n  };\n};\n","/**\n * ---header-docs-section---\n * # yummies/complex\n *\n * ## Description\n *\n * **Dependency-injection style factory** for classes that take a single deps object in their\n * constructor. Merges predefined singletons with per-call overrides so feature modules can be\n * constructed consistently in apps that avoid heavyweight DI containers.\n *\n * ## Usage\n *\n * ```ts\n * import { ModulesFactory } from \"yummies/complex\";\n * ```\n */\n\nimport type { AnyObject, Class, EmptyObject, IsPartial } from 'yummies/types';\n\ntype ModuleLoaderConfig<TPredefinedDeps extends AnyObject = EmptyObject> = {\n  factory<TInstance, TDeps extends TPredefinedDeps>(\n    moduleClass: Class<TInstance, [TDeps]>,\n    deps: TDeps,\n  ): TInstance;\n} & (TPredefinedDeps extends EmptyObject\n  ? { deps?: TPredefinedDeps }\n  : { deps: TPredefinedDeps });\n\n/**\n * Universal factory for creating class instances with predefined and per-call\n * dependencies.\n *\n * Works with classes whose constructor accepts a single dependency object.\n *\n * @template TPredefinedDeps Dependency shape that is always injected by the factory.\n *\n * @example\n * ```\n * const factory = new ModulesFactory({\n *   factory: (MyClass, deps) => new MyClass(deps),\n *   deps: { someDependency: new Dependency() }\n * });\n *\n * const instance = factory.create(MyClass, { extraDependency: new ExtraDependency() });\n * ```\n *\n * @example\n * ```ts\n * const factory = new ModulesFactory({\n *   factory: (Module, deps) => new Module(deps),\n * });\n * ```\n *\n * @example\n * ```ts\n * const service = factory.create(UserService, { api });\n * ```\n */\nexport class ModulesFactory<TPredefinedDeps extends AnyObject = EmptyObject> {\n  /**\n   * Creates a new module factory.\n   *\n   * @param config Factory strategy and predefined dependencies.\n   *\n   * @example\n   * ```ts\n   * const factory = new ModulesFactory({\n   *   factory: (Module, deps) => new Module(deps),\n   * });\n   * ```\n   *\n   * @example\n   * ```ts\n   * const factory = new ModulesFactory({\n   *   factory: (Module, deps) => new Module(deps),\n   *   deps: { api },\n   * });\n   * ```\n   */\n  constructor(private config: ModuleLoaderConfig<TPredefinedDeps>) {}\n\n  /**\n   * Creates an instance of the provided class by merging predefined and\n   * per-call dependencies.\n   *\n   * @template TInstance Instance type produced by the constructor.\n   * @template TDeps Full dependency object expected by the constructor.\n   * @param Constructor Class constructor receiving a single dependency object.\n   * @param args Additional dependencies merged over predefined ones.\n   * @returns Created class instance.\n   *\n   * @example\n   * ```ts\n   * const service = factory.create(UserService, { logger });\n   * ```\n   *\n   * @example\n   * ```ts\n   * const store = factory.create(UserStore);\n   * ```\n   */\n  create<TInstance, TDeps extends TPredefinedDeps = TPredefinedDeps>(\n    Constructor: Class<TInstance, [TDeps]>,\n    ...args: IsPartial<Omit<TDeps, keyof TPredefinedDeps>> extends true\n      ? [extraDeps?: Omit<TDeps, keyof TPredefinedDeps>]\n      : [extraDeps: Omit<TDeps, keyof TPredefinedDeps>]\n  ) {\n    return this.config.factory(Constructor, {\n      ...this.config.deps!,\n      ...args[0],\n    } as any);\n  }\n}\n","/**\n * ---header-docs-section---\n * # yummies/complex\n *\n * ## Description\n *\n * Tiny **publish–subscribe** bus: subscribers register callbacks, publishers broadcast arguments, and\n * the last payload remains readable for late subscribers. Simpler than full event emitters when you\n * only need in-memory fan-out inside a feature or view-model layer.\n *\n * ## Usage\n *\n * ```ts\n * import { createPubSub } from \"yummies/complex\";\n * ```\n */\n\nexport type SubFn<PubArgs extends any[] = any[]> = (...args: PubArgs) => void;\n\n/**\n * The Publish-Subscribe pattern, which allows objects to interact with each other\n * through an event system. Subscribers can subscribe to events and receive notifications\n * when these events occur. The last published data can be accessed through the `data` property.\n */\nexport interface PubSub<PubArgs extends any[] = any[]> {\n  (...args: PubArgs): void;\n\n  /**\n   * Last published arguments\n   */\n  lastPub: PubArgs | undefined;\n\n  /**\n   * An array of subscriber functions (sub) that will be called\n   * when an event is published. Each subscriber must match the type SubFn,\n   * taking the arguments that will be passed to it when the publisher calls pub.\n   */\n  subs: SubFn<PubArgs>[];\n\n  /**\n   * A function to unsubscribe from events. When a subscriber function (sub) is passed,\n   * it will be removed from the `subs` array, and will no longer receive notifications.\n   */\n  unsub(sub: SubFn<PubArgs>): void;\n  /**\n   * A function to subscribe to events. When a subscriber function (sub) is passed,\n   * it will be added to the `subs` array, and will receive notifications when the publisher calls pub.\n   * Returns a function that can be used to unsubscribe from events.\n   */\n  sub(sub: SubFn<PubArgs>): VoidFunction;\n}\n\n/**\n * Creates a simple publish-subscribe dispatcher that stores the last published\n * arguments and allows subscription management.\n *\n * @template PubArgs Argument tuple delivered to subscribers.\n * @returns Callable publisher with subscribe and unsubscribe helpers.\n *\n * @example\n * ```ts\n * const pub = createPubSub<[string]>();\n * pub('ready');\n * ```\n *\n * @example\n * ```ts\n * const pub = createPubSub<[number]>();\n * const unsub = pub.sub((value) => console.log(value));\n * ```\n */\nexport const createPubSub = <PubArgs extends any[] = any[]>() => {\n  const pubSub = ((...args: PubArgs) => {\n    pubSub.lastPub = args;\n    pubSub.subs.forEach((sub) => {\n      sub(...args);\n    });\n  }) as PubSub<PubArgs>;\n  pubSub.lastPub = undefined;\n\n  pubSub.subs = [];\n\n  pubSub.unsub = (sub: SubFn<PubArgs>) => {\n    pubSub.subs = pubSub.subs.filter((it) => it !== sub);\n  };\n  pubSub.sub = (sub: SubFn<PubArgs>) => {\n    pubSub.subs.push(sub);\n    return () => pubSub.unsub(sub);\n  };\n\n  return pubSub;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAsDA,IAAa,iBACX,cACA,UAAkB,MACE;CACpB,MAAM,UAAU,YAAoB;AAClC,KAAG,QAAQ,eAAe,QAAQ,IAAK;AACvC,SAAO,GAAG;;CAGZ,MAAM,kBAAkB,OAAO,EAAE,GAAG,QAAQ;CAC5C,MAAM,kBAAkB,OAAO,EAAE,GAAG,QAAQ;CAE5C,MAAM,KAAsB;AAE5B,IAAG,YAAY;AACf,IAAG,YAAY;AAEf,IAAG,cAAc;AACf,KAAG,UAAU;AACb,KAAG,QAAQ,eAAe,QAAQ,IAAK;;AAGzC,IAAG,OAAO;AAEV,QAAO;;;;;;;;;;;;;;;;;;;;;;;;ACjCT,IAAa,qBACX,iBACwB;AACxB,KAAI,gBAAgB,MAAM;EACxB,IAAI;AAEJ,SAAO;GACL,WAAmB;GACnB,aAAa;AACX,kBAAc,KAAA;;GAEhB,MAAM,UAA0B;AAC9B,kBAAc;AACd,WAAO;;GAEV;;CAGH,MAAM,cAAc;AAEpB,QAAO;EACL,WAAmB,YAAY;EAC/B,aAAa;AACX,UAAO,YAAY;;EAErB,MAAM,UAA0B;AAC9B,eAAY,gBAAgB;AAC5B,UAAO;;EAEV;;;;;;;;;;;;;;;;;;;;;;;;;;AChCH,IAAa,sBACX,cACA,iBACM;CACN,MAAM,cAAc,kBAAqB,aAAa;AACtD,QAAO,YAAY,KAAK,IAAI,YAAY,IAAI,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;AAiC3D,IAAa,6BACX,WACA,iBAC2B;CAC3B,MAAM,cAAc,kBAAqB,aAAa;CAEtD,MAAM,iBAAiB;AACrB,SAAO,YAAY,KAAK,IAAI,YAAY,IAAI,UAAU,MAAM,KAAK,CAAC;;AAGpE,QAAO;EACL,KAAK;EACL,KAAK,YAAY;EACjB,OAAO,YAAY;EACnB,SAAS,UAAsB;GAC7B,MAAM,eAAe,UAAU;AAC/B,UAAO,OAAO,cAAc,UAAU,OAAO,aAAa,CAAC;;EAE9D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACxCH,IAAa,iBAAb,MAA6E;;;;;;;;;;;;;;;;;;;;;CAqB3E,YAAY,QAAqD;AAA7C,OAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;CAsBpB,OACE,aACA,GAAG,MAGH;AACA,SAAO,KAAK,OAAO,QAAQ,aAAa;GACtC,GAAG,KAAK,OAAO;GACf,GAAG,KAAK;GACT,CAAQ;;;;;;;;;;;;;;;;;;;;;;;;ACvCb,IAAa,qBAAoD;CAC/D,MAAM,WAAW,GAAG,SAAkB;AACpC,SAAO,UAAU;AACjB,SAAO,KAAK,SAAS,QAAQ;AAC3B,OAAI,GAAG,KAAK;IACZ;;AAEJ,QAAO,UAAU,KAAA;AAEjB,QAAO,OAAO,EAAE;AAEhB,QAAO,SAAS,QAAwB;AACtC,SAAO,OAAO,OAAO,KAAK,QAAQ,OAAO,OAAO,IAAI;;AAEtD,QAAO,OAAO,QAAwB;AACpC,SAAO,KAAK,KAAK,IAAI;AACrB,eAAa,OAAO,MAAM,IAAI;;AAGhC,QAAO"}

package/complex.d.ts

@@ -1,5 +1,21 @@
 import { AnyObject, Maybe, EmptyObject, Class, IsPartial } from 'yummies/types';
 
+/**
+ * ---header-docs-section---
+ * # yummies/complex
+ *
+ * ## Description
+ *
+ * Callable **counter** objects with increment, decrement, and reset for UI steppers, pagination,
+ * and id generators. Values can be mapped on read so the public API stays typed while the internal
+ * tick stays numeric. This file is the `counter` slice of the broader `yummies/complex` entry point.
+ *
+ * ## Usage
+ *
+ * ```ts
+ * import { createCounter } from "yummies/complex";
+ * ```
+ */
 interface Counter<TValue = number> {
     (): TValue;
     counter: number;
@@ -38,6 +54,23 @@ interface CounterFn<TValue = number> extends Counter<TValue> {
  */
 declare const createCounter: <TValue = number>(processValue?: (value: number) => TValue, initial?: number) => Counter<TValue>;
 
+/**
+ * ---header-docs-section---
+ * # yummies/complex
+ *
+ * ## Description
+ *
+ * **Singleton-style config** backed by either `globalThis` (keyed by symbol) or a module closure.
+ * Use for app-wide feature flags, bootstrapped locale, or SSR-safe defaults without prop-drilling.
+ * Pairs with `createGlobalPoint` for other global handles in the same `yummies/complex` package.
+ *
+ * ## Usage
+ *
+ * ```ts
+ * import { createGlobalConfig } from "yummies/complex";
+ * ```
+ */
+
 /**
  * Creates or reuses a globally accessible config object.
  *
@@ -92,6 +125,23 @@ interface GlobalDynamicConfig<TValue extends AnyObject> {
  */
 declare const createGlobalDynamicConfig: <T extends AnyObject>(processFn: (change: Maybe<Partial<T>>, current: Maybe<T>) => T, accessSymbol?: keyof any) => GlobalDynamicConfig<T>;
 
+/**
+ * ---header-docs-section---
+ * # yummies/complex
+ *
+ * ## Description
+ *
+ * **Dependency-injection style factory** for classes that take a single deps object in their
+ * constructor. Merges predefined singletons with per-call overrides so feature modules can be
+ * constructed consistently in apps that avoid heavyweight DI containers.
+ *
+ * ## Usage
+ *
+ * ```ts
+ * import { ModulesFactory } from "yummies/complex";
+ * ```
+ */
+
 type ModuleLoaderConfig<TPredefinedDeps extends AnyObject = EmptyObject> = {
     factory<TInstance, TDeps extends TPredefinedDeps>(moduleClass: Class<TInstance, [TDeps]>, deps: TDeps): TInstance;
 } & (TPredefinedDeps extends EmptyObject ? {
@@ -175,6 +225,22 @@ declare class ModulesFactory<TPredefinedDeps extends AnyObject = EmptyObject> {
     create<TInstance, TDeps extends TPredefinedDeps = TPredefinedDeps>(Constructor: Class<TInstance, [TDeps]>, ...args: IsPartial<Omit<TDeps, keyof TPredefinedDeps>> extends true ? [extraDeps?: Omit<TDeps, keyof TPredefinedDeps>] : [extraDeps: Omit<TDeps, keyof TPredefinedDeps>]): TInstance;
 }
 
+/**
+ * ---header-docs-section---
+ * # yummies/complex
+ *
+ * ## Description
+ *
+ * Tiny **publish–subscribe** bus: subscribers register callbacks, publishers broadcast arguments, and
+ * the last payload remains readable for late subscribers. Simpler than full event emitters when you
+ * only need in-memory fan-out inside a feature or view-model layer.
+ *
+ * ## Usage
+ *
+ * ```ts
+ * import { createPubSub } from "yummies/complex";
+ * ```
+ */
 type SubFn<PubArgs extends any[] = any[]> = (...args: PubArgs) => void;
 /**
  * The Publish-Subscribe pattern, which allows objects to interact with each other