vivth 1.4.10 → 1.5.1

package/generated/types/src/class/Paths.d.mts

@@ -0,0 +1,95 @@
+/**
+ * @description
+ * - class helpers to define pathReference;
+ * - is a singleton;
+ * - most of functionality need to access `Paths.root`, if you get warning, you can instantiate `Paths` before running anything;
+ */
+export class Paths {
+    /**
+     * @type {Paths|undefined}
+     */
+    static #instance: Paths | undefined;
+    /**
+     * @description
+     * - MIGHT THROW AN ERROR;
+     * >- most `vivth` modules uses this value, so you need to instantiate Paths by all means before using them;
+     * - reference for rootPath
+     * - `Paths` needed to be instantiated via:
+     * >- `Paths` constructor;
+     * >- `Setup.paths` constructor;
+     * @type {string}
+     */
+    static get root(): string;
+    /**
+     * @description
+     * - replace path separator to forward slash `/`;
+     * - remove repeating `./`;
+     * @param {string} path
+     * @returns {string}
+     * @example
+     * import { Paths } from 'vivth/neutral';
+     *
+     * Paths.normalize('file:\\D:\\myFile.mjs'); //  "file://D://myFile.mjs"
+     */
+    static normalize: (path: string) => string;
+    /**
+     * @description
+     * - replace path separator to `sep`;
+     * @param {string} path
+     * @returns {string}
+     * @example
+     * import { Paths } from 'vivth/neutral';
+     *
+     * Paths.nativeSep('path//myFile.mjs'); //  "path\myFile.mjs" OR "path/myFile.mjs" depending on sep value;
+     */
+    static nativeSep: (path: string) => string;
+    /**
+     * @description
+     * - normalized then starts with forward slash `/`;
+     * @param {string} path
+     * @returns {`/${string}`}
+     * @example
+     * import { Paths } from 'vivth/neutral';
+     *
+     * Paths.normalizesForRoot('path\\myFile.mjs'); //  "/path/myFile.mjs"
+     */
+    static normalizeForRoot: (path: string) => `/${string}`;
+    /**
+     * @description
+     * - convert path to diskAbsolute and normalized to be using forward slash;
+     * - usefull for arguments for `methods` OR `functions` that needs to be absolute disk path, regardles if path is relative to project root, or already absolute path;
+     * @param {string} path
+     * @returns {string}
+     * @example
+     * import { Paths } from 'vivth/neutral';
+     *
+     * Paths.normalizesForRoot('\\path\\myFile.mjs'); //  "D://something/path/myFile.mjs"
+     */
+    static diskAbsolute: (path: string) => string;
+    /**
+     * @description
+     * @param {Object} options
+     * @param {string} options.root
+     * - browser:
+     * ```js
+     * location.origin
+     * ```
+     * - node/bun compatible:
+     * ```js
+     * import process from 'node:process';
+     * process.env.INIT_CWD ?? process.cwd()
+     * ```
+     * - other: you need to check your JSRuntime for the rootPath reference;
+     * @example
+     * import { Paths } from 'vivth/neutral';
+     *
+     * new Paths({
+     * 	// root: location.origin,
+     * 	// root: process.env.INIT_CWD ?? process.cwd(),
+     * })
+     */
+    constructor({ root }: {
+        root: string;
+    });
+    #private;
+}

package/generated/types/src/class/Prettivy.d.mts

@@ -0,0 +1,26 @@
+/**
+ * @description
+ * - `prettier` wrapper with option inference from path;
+ */
+export class Prettivy {
+    static #q: QChannel<import("../typehints/AnyButUndefined.mjs").AnyButUndefined> & {
+        [x: symbol]: QChannel<import("../typehints/AnyButUndefined.mjs").AnyButUndefined>;
+    };
+    /**
+     * @param {string} path
+     */
+    constructor(path: string);
+    /**
+     * @type {string}
+     */
+    path: string;
+    getOptions: () => Promise<import("prettier").Options | null | undefined>;
+    options: import("prettier").Options | null | undefined;
+    /**
+     * @param {string} contentBeforePrettified
+     * @returns {Promise<string>}
+     */
+    format: (contentBeforePrettified: string) => Promise<string>;
+    #private;
+}
+import { QChannel } from './QChannel.mjs';

package/{types → generated/types}/src/class/QChannel.d.mts

@@ -1,13 +1,17 @@
+/**
+ * @typedef { import('../typehints/VivthCleanup.mjs').VivthCleanup } VivthCleanup
+ */
 /**
  * @description
  * - class for `Queue` handling;
  * @template {AnyButUndefined} DEFINEDANY
+ * @implements {VivthCleanup}
  */
-export class QChannel<DEFINEDANY extends import("../types/AnyButUndefined.mjs").AnyButUndefined> {
+export class QChannel<DEFINEDANY extends import("../typehints/AnyButUndefined.mjs").AnyButUndefined> implements VivthCleanup {
     /**
-     * @typedef {import('../types/AnyButUndefined.mjs').AnyButUndefined} AnyButUndefined
-     * @typedef {import('../types/QCBReturn.mjs').QCBReturn} QCBReturn
-     * @typedef {import('../types/QCBFIFOReturn.mjs').QCBFIFOReturn} QCBFIFOReturn
+     * @typedef {import('../typehints/AnyButUndefined.mjs').AnyButUndefined} AnyButUndefined
+     * @typedef {import('../typehints/QCBReturn.mjs').QCBReturn} QCBReturn
+     * @typedef {import('../typehints/QCBFIFOReturn.mjs').QCBFIFOReturn} QCBFIFOReturn
      */
     /**
      * @description
@@ -16,16 +20,16 @@ export class QChannel<DEFINEDANY extends import("../types/AnyButUndefined.mjs").
      * @returns {typeof QChannel}
      * - usefull for Queue primitive on multiple library but single reference, like the Web by making the `Map` on `window` object;
      * @example
-     * import { QChannel } from 'vivth';
+     * import { QChannel } from 'vivth/neutral';
      *
      * const myMappedQref = (window['myMappedQref'] = new Map());
      * export const MyQClass = QChannel.setup(myMappedQref);
      */
-    static setup: (uniqueMap: Map<import("../types/AnyButUndefined.mjs").AnyButUndefined, [Promise<any>, {}]>) => typeof QChannel;
+    static setup: (uniqueMap: Map<import("../typehints/AnyButUndefined.mjs").AnyButUndefined, [Promise<any>, {}]>) => typeof QChannel;
     /**
      * @type {Map<AnyButUndefined, [Promise<any>, {}]>}
      */
-    static "__#private@#uniquePromiser": Map<import("../types/AnyButUndefined.mjs").AnyButUndefined, [Promise<any>, {}]>;
+    static #uniquePromiser: Map<import("../typehints/AnyButUndefined.mjs").AnyButUndefined, [Promise<any>, {}]>;
     /**
      * - ensures that each id has only one task running at a time.
      * - calls with the same id will wait for the previous call to finish.
@@ -33,7 +37,7 @@ export class QChannel<DEFINEDANY extends import("../types/AnyButUndefined.mjs").
      * @param {QChannel<any>} instance
      * @returns {Promise<QCBReturn>} Resolves when it's safe to proceed for the given id, returning a cleanup function
      */
-    static "__#private@#uniqueCB": (id: import("../types/AnyButUndefined.mjs").AnyButUndefined, instance: QChannel<any>) => Promise<import("../types/QCBReturn.mjs").QCBReturn>;
+    static #uniqueCB: (id: import("../typehints/AnyButUndefined.mjs").AnyButUndefined, instance: QChannel<any>) => Promise<import("../typehints/QCBReturn.mjs").QCBReturn>;
     /**
      * @description
      * - first in first out handler
@@ -49,7 +53,7 @@ export class QChannel<DEFINEDANY extends import("../types/AnyButUndefined.mjs").
          * // blocks all `FIFO` called using this method and QChannel.fifoCallback;
          * resume();
          */
-        key: () => Promise<import("../types/QCBFIFOReturn.mjs").QCBFIFOReturn>;
+        key: () => Promise<import("../typehints/QCBFIFOReturn.mjs").QCBFIFOReturn>;
         /**
          * @static fifo
          * @description
@@ -64,7 +68,7 @@ export class QChannel<DEFINEDANY extends import("../types/AnyButUndefined.mjs").
          */
         callback: <RESULT>(asyncCallback: () => Promise<RESULT>) => ReturnType<typeof TryAsync<RESULT>>;
     } & {
-        "vivth:unwrapLazy;": () => {
+        [x: symbol]: {
             /**
              * @static fifo
              * @description
@@ -75,7 +79,7 @@ export class QChannel<DEFINEDANY extends import("../types/AnyButUndefined.mjs").
              * // blocks all `FIFO` called using this method and QChannel.fifoCallback;
              * resume();
              */
-            key: () => Promise<import("../types/QCBFIFOReturn.mjs").QCBFIFOReturn>;
+            key: () => Promise<import("../typehints/QCBFIFOReturn.mjs").QCBFIFOReturn>;
             /**
              * @static fifo
              * @description
@@ -94,21 +98,23 @@ export class QChannel<DEFINEDANY extends import("../types/AnyButUndefined.mjs").
     /**
      * @param {string} name
      * - only used as helper for logging, and has nothing to do with runtime behaviour;
+     * @param {boolean} [log]
      */
-    constructor(name: string);
+    constructor(name: string, log?: boolean);
+    vivthCleanup: () => Promise<void>;
     name: string;
     /**
      * @description
      * - disable queue;
      * - when `closed`, `isLastOnQ` will allways return `false`;
-     * @returns {void}
+     * @type {()=>void}
      */
     close: () => void;
     /**
      * @description
      * - enable queue;
      * - when `opened`, `isLastOnQ` will evaluate whether calls are actually the last of queue;
-     * @returns {void}
+     * @type {()=>void}
      */
     open: () => void;
     /**
@@ -134,7 +140,7 @@ export class QChannel<DEFINEDANY extends import("../types/AnyButUndefined.mjs").
      * }
      * handler();
      */
-    key: (keyID: DEFINEDANY) => Promise<import("../types/QCBReturn.mjs").QCBReturn>;
+    key: (keyID: DEFINEDANY) => Promise<import("../typehints/QCBReturn.mjs").QCBReturn>;
     /**
      * @description
      * - `callbackBlock` with error as value:
@@ -154,9 +160,11 @@ export class QChannel<DEFINEDANY extends import("../types/AnyButUndefined.mjs").
      * 	// 	return;
      * 	// }
      * 	// code
+     * 	// return result
      * })
      */
-    callback<RESULT>(keyID: DEFINEDANY, asyncCallback: (options: Omit<import("../types/QCBReturn.mjs").QCBReturn, "resume">) => Promise<RESULT>): ReturnType<typeof TryAsync<RESULT>>;
+    callback<RESULT>(keyID: DEFINEDANY, asyncCallback: (options: Omit<import("../typehints/QCBReturn.mjs").QCBReturn, "resume">) => Promise<RESULT>): ReturnType<typeof TryAsync<RESULT>>;
     #private;
 }
+export type VivthCleanup = import("../typehints/VivthCleanup.mjs").VivthCleanup;
 import { TryAsync } from '../function/TryAsync.mjs';

package/generated/types/src/class/SafeExit.d.mts

@@ -0,0 +1,69 @@
+/**
+ * @description
+ * - class helper for describing how to Safely Response on exit events
+ * - singleton;
+ * - most of functionality might need to access `SafeExit.instance.exiting`, if you get warning, you can instantiate `SafeExit` before running anything;
+ */
+export class SafeExit {
+    /**
+     * @description
+     * - only accessible after instantiation;
+     * @type {SafeExit|undefined}
+     */
+    static instance: SafeExit | undefined;
+    /**
+     * @description
+     * @param {...NodeJS.Signals} eventNames
+     * - `beforeExit` is auto included;
+     * - example:
+     * ```js
+     *  ['SIGINT', 'SIGTERM'] // both are automatically added
+     * ```
+     * @example
+     * import process from 'node:process';
+     * import { SafeExit } from 'vivth/node';
+     *
+     * new SafeExit('SIGINT', 'SIGTERM', ...eventNames);
+     */
+    constructor(...eventNames: NodeJS.Signals[]);
+    /**
+     * @type {Set<()=>Promise<void>>}
+     */
+    safeCleanUpCBs: Set<() => Promise<void>>;
+    /**
+     * @description
+     * - `SafeExit` ${eventName}.Callback registration;
+     * - `onEventName` all callbacks are called simultanousely using `await Promise.all`;
+     * >- for sequential event you need to put them in a single callback;
+     * @param {()=>(Promise<void>)} safeExitCallback
+     * @returns {{removeCallback:()=>void}}
+     * @example
+     * import { SafeExit } from 'vivth/node';
+     *
+     * const exitCallback = async () => {
+     * 	// code
+     * }
+     * SafeExit.instance.addCallback(exitCallback);
+     */
+    addCallback: (safeExitCallback: () => (Promise<void>)) => {
+        removeCallback: () => void;
+    };
+    /**
+     * @description
+     * - optional exit event removal;
+     * - the callbacks will be removed from registered via `addCallback` exiting;
+     * @param {()=>(Promise<void>)} cb
+     * @example
+     * import { SafeExit } from 'vivth/node';
+     *
+     * const exitCallback () => {
+     * 	// code
+     * }
+     * SafeExit.instance.addCallback(exitCallback);
+     * // somewhere else
+     * SafeExit.instance.removeCallback(exitCallback);
+     */
+    removeCallback: (cb: () => (Promise<void>)) => void;
+    triggerExit: () => Promise<void>;
+    #private;
+}

package/{types → generated/types}/src/class/Setup.d.mts

@@ -7,27 +7,16 @@ export class Setup {
      * @description
      * - proxy `SafeExit_instance` for Setup
      * @example
-     * import { Setup, Console } from 'vivth';
+     * import { Setup } from 'vivth/node';
      *
-     * new Setup.safeExit({
-     * 	// eventNames are blank by default, you need to manually name them all;
-     * 	// 'exit' will be omited, as it might cause async callbacks failed to execute;
-     * 	eventNames: ['SIGINT', 'SIGTERM', ...eventNames],
-     * 	terminator : () => process.exit(0),
-     * 	listener : (eventName) => {
-     * 			process.once(eventName, function () {
-     * 				SafeExit.instance?.exiting.correction(true);
-     * 				Console.log(`safe exit via "${eventName}"`);
-     * 			});
-     * 	}
-     * });
+     * new Setup.safeExit('SIGINT', 'SIGTERM', ...eventNames);
      */
     static safeExit: typeof SafeExit;
     /**
      * @description
      * - proxy `Paths_instance` for Setup;
      * @example
-     * import { Setup } from 'vivth';
+     * import { Setup } from 'vivth/node';
      *
      * new Setup.paths({
      * 	root: location.origin, // browser example
@@ -38,7 +27,7 @@ export class Setup {
      * @description
      * - proxy `WorkerMainThread_instance` for Setup;
      * @example
-     * import { Setup } from 'vivth';
+     * import { Setup } from 'vivth/node';
      * import { Worker } from 'node:worker_threads';
      *
      * Setup.workerMain({
@@ -60,7 +49,7 @@ export class Setup {
      * - correct `parentPort` reference when needed;
      * - export to create new reference to be use to create new WorkerThread instance;
      * @example
-     * import { Setup } from 'vivth';
+     * import { Setup } from 'vivth/node';
      * import { parentPort } from 'node:worker_threads';
      *
      * export const MyWorkerThreadRef = Setup.workerThread({parentPort});
@@ -68,8 +57,32 @@ export class Setup {
      * // you need to call this method;
      */
     static workerThread: typeof WorkerThread.setup;
+    /**
+     * @description
+     * - setup envMode into `developement`('default') or `production`;
+     * @example
+     * import { Setup } from 'vivth/node';
+     *
+     * Setup.enforceEnvMode('prod');
+     *
+     * // default behaviour, technically only need to be call for reactive functionality;
+     * Setup.enforceEnvMode('dev');
+     */
+    static enforceEnvMode: (mode: EnvModeType) => void;
+    /**
+     * @description
+     * - setup `vivth `preffered encoding;
+     * @example
+     * import { Setup } from 'vivth/node';
+     *
+     * Setup.preferrence({ encoding: 'utf-8' });
+     */
+    static preferrence: ({ encoding }: {
+        encoding: (typeof Preferrence)["encoding"];
+    }) => void;
 }
 import { SafeExit } from './SafeExit.mjs';
 import { Paths } from './Paths.mjs';
 import { WorkerMainThread } from './WorkerMainThread.mjs';
 import { WorkerThread } from './WorkerThread.mjs';
+import { Preferrence } from '../common/Preferrence.mjs';

package/{types → generated/types}/src/class/Signal.d.mts

@@ -1,3 +1,6 @@
+/**
+ * @typedef { import('../typehints/VivthCleanup.mjs').VivthCleanup } VivthCleanup
+ */
 /**
  * @type {Set<Signal<any>>}
  */
@@ -6,22 +9,29 @@ export const setOFSignals: Set<Signal<any>>;
  * @description
  * - a class for creating effect to signals;
  * @template VALUE
+ * @implements {VivthCleanup}
  */
-export class Signal<VALUE> {
+export class Signal<VALUE> implements VivthCleanup {
     /**
      * @param {Signal<any>} signalInstance
+     * @param {(error:Error|undefined)=>void} [afterCompletion]
+     * @returns {Promise<void>}
      */
-    static "__#private@#notify": (signalInstance: Signal<any>) => void;
+    static #notify: (signalInstance: Signal<any>, afterCompletion?: (error: Error | undefined) => void) => Promise<void>;
     /**
      * @description
      * - create a `Signal`;
      * @param {VALUE} value
+     * @param {(data:DataLog<VALUE>)=>void} [performanceChangesReport]
+     * - callback independent from effect;
+     * >- it will always be called when there's value change;
      * @example
-     * import { Signal, Effect } from  'vivth';
+     * import { Signal, Effect } from 'vivth/neutral';
      *
      * const count = new Signal(0);
      */
-    constructor(value: VALUE);
+    constructor(value: VALUE, performanceChangesReport?: (data: DataLog<VALUE>) => void);
+    vivthCleanup: () => Promise<void>;
     /**
      * @description
      * - subsrcibers reference of this instance;
@@ -39,9 +49,10 @@ export class Signal<VALUE> {
          * @description
          * - manually notify on non primitive value or value that have depths;
          * @param {(options:{signalInstance:Signal<VALUE>})=>Promise<void>} [callback]
-         * @returns {void}
+         * @param {(error:Error|undefined)=>Promise<void>} [afterCompletion]
+         * @returns {Promise<void>}
          * @example
-         * import { Signal } from 'vivth';
+         * import { Signal } from 'vivth/neutral';
          *
          * // for deep signal like array or object you can:
          * const arraySignal = new Signal([1,2]);
@@ -57,9 +68,9 @@ export class Signal<VALUE> {
          */
         notify: (callback?: (options: {
             signalInstance: Signal<VALUE>;
-        }) => Promise<void>) => void;
+        }) => Promise<void>, afterCompletion?: (error: Error | undefined) => Promise<void>) => Promise<void>;
     } & {
-        "vivth:unwrapLazy;": () => {
+        [x: symbol]: {
             /**
              * @instance subscribers
              * @description
@@ -72,9 +83,10 @@ export class Signal<VALUE> {
              * @description
              * - manually notify on non primitive value or value that have depths;
              * @param {(options:{signalInstance:Signal<VALUE>})=>Promise<void>} [callback]
-             * @returns {void}
+             * @param {(error:Error|undefined)=>Promise<void>} [afterCompletion]
+             * @returns {Promise<void>}
              * @example
-             * import { Signal } from 'vivth';
+             * import { Signal } from 'vivth/neutral';
              *
              * // for deep signal like array or object you can:
              * const arraySignal = new Signal([1,2]);
@@ -90,7 +102,7 @@ export class Signal<VALUE> {
              */
             notify: (callback?: (options: {
                 signalInstance: Signal<VALUE>;
-            }) => Promise<void>) => void;
+            }) => Promise<void>, afterCompletion?: (error: Error | undefined) => Promise<void>) => Promise<void>;
         };
     };
     /**
@@ -121,7 +133,7 @@ export class Signal<VALUE> {
          */
         ref: () => void;
     } & {
-        "vivth:unwrapLazy;": () => {
+        [x: symbol]: {
             /**
              * @instance remove
              * @description
@@ -157,7 +169,7 @@ export class Signal<VALUE> {
      * - assign new value then automatically notify all subscribers;
      * @type {VALUE}
      * @example
-     * import { Signal } from  'vivth';
+     * import { Signal } from 'vivth/neutral';
      *
      * const count = new Signal(0);
      * count.value++;
@@ -170,7 +182,7 @@ export class Signal<VALUE> {
      * - value after change;
      * @returns {VALUE}
      * @example
-     * import { Signal, Effect, Derived } from  'vivth';
+     * import { Signal, Effect, Derived } from 'vivth/neutral';
      *
      * const count = new Signal(0);
      * count.value; // not reactive
@@ -178,11 +190,13 @@ export class Signal<VALUE> {
      * new Effect(async ({ subscribe }) =>{
      * 	const countValue = subscribe(count).value; // reactive
      * })
-     * const oneMoreThanCount = new Derived(async ({ subscribe }) =>{
+     * const oneMoreThanCount = new Derived(async function({ subscribe }){
      * 	return subscribe(count).value + 1; // reactive
      * })
      */
     get value(): VALUE;
     #private;
 }
+export type VivthCleanup = import("../typehints/VivthCleanup.mjs").VivthCleanup;
 import { Effect } from './Effect.mjs';
+import { DataLog } from './DataLog.mjs';

package/generated/types/src/class/SignalCollection.d.mts

@@ -0,0 +1,96 @@
+/**
+ * @typedef {import('../typehints/VivthCleanup.mjs').VivthCleanup} VivthCleanup
+ */
+/**
+ * @description
+ * - class helper for creating Collection of `Signals` for Object of Signals to be subscribed to(on `Effect`/`Derived`) collectively as signals;
+ * >- uses as `Facade` Pattern;
+ * @template {Record<string, import('./Signal.mjs').Signal<any>>} SIGNALS
+ * @implements {VivthCleanup}
+ */
+export class SignalCollection<SIGNALS extends Record<string, import("./Signal.mjs").Signal<any>>> implements VivthCleanup {
+    /**
+     * @description
+     * - creates instance of `SignalCollection`, by referencing to named Signal;
+     * @param {SIGNALS} signalsObject
+     * @example
+     * import { Signal, Derived, SignalCollection } from 'vivth/neutral';
+     *
+     * const a = new Signal('a');
+     * const b = new Signal('b');
+     * const c = new Derived(async ({ subscribe }) => {
+     * 	return `${subscribe(b).value}_b`;
+     * });
+     *
+     * const f = new SignalCollection({ a, c });
+     */
+    constructor(signalsObject: SIGNALS);
+    vivthCleanup: () => Promise<void>;
+    /**
+     * @description
+     * - accessor for signals, to be subscribed to;
+     * @param {import('./Effect.mjs').Effect["options"]["subscribe"]} [subscribe]
+     * @returns {SIGNALS}
+     * @example
+     * import { Signal, Derived, Effect, SignalCollection } from 'vivth/neutral';
+     *
+     * const a = new Signal('a');
+     * const b = new Signal('b');
+     * const c = new Derived(async ({ subscribe }) => {
+     * 	return `${subscribe(b).value}_b`;
+     * });
+     *
+     * const f = new SignalCollection({ a, c });
+     *
+     * new Effect(async ({ subscribe, isLastCalled }) => {
+     * 	const {
+     * 		a: { value: aa }, // aa is safely desctructured and auto subscribed
+     * 		c: { value: cc }, // cc is safely desctructured and auto subscribed
+     * 	} = f.signals(subscribe);
+     * 	if(!await isLastCalled(100)) {
+     * 		return; // impertaive debounce
+     * 	}
+     * });
+     *
+     * const d = new Derived(async function({ subscribe, isLastCalled }) {
+     * 	const {
+     * 		a: { value: aa }, // aa is safely desctructured and auto subscribed
+     * 		c: { value: cc }, // cc is safely desctructured and auto subscribed
+     * 	} = f.signals(subscribe);
+     * 	if(!await isLastCalled(100)) {
+     * 		return this.dontUpdate; // impertaive debounce
+     * 	}
+     * 	// return something;
+     * });
+     */
+    signals: (subscribe?: import("./Effect.mjs").Effect["options"]["subscribe"]) => SIGNALS;
+    /**
+     * @description
+     * - is looping synchronously;
+     * >- will not await any async block;
+     * - use for operation that doesn't need the value:
+     * >- unsub from the signal;
+     * @template {keyof SIGNALS} K
+     * @param {(key: K,
+     * signal: SIGNALS[K]
+     * )=>void} callback
+     * @returns {void}
+     * @example
+     * import { Signal, Derived, Effect, SignalCollection } from 'vivth/neutral';
+     *
+     * const a = new Signal('a');
+     * const b = new Signal('b');
+     * const c = new Derived(async ({ subscribe }) => {
+     * 	return `${subscribe(b).value}_b`;
+     * });
+     *
+     * const f = new SignalCollection({ a, c });
+     *
+     * f.forInSignals((key, signal)=>{
+     * 	// code
+     * })
+     */
+    forInSignals<K extends keyof SIGNALS>(callback: (key: K, signal: SIGNALS[K]) => void): void;
+    #private;
+}
+export type VivthCleanup = import("../typehints/VivthCleanup.mjs").VivthCleanup;

package/{types → generated/types}/src/class/WalkThrough.d.mts

@@ -10,7 +10,7 @@ export class WalkThrough {
      * @param {(...any:any[])=>void} callback
      * @returns {void}
      */
-    static "__#private@#handler": (iterator: Iterator<any, any, any>, callback: (...any: any[]) => void) => void;
+    static #handler: (iterator: Iterator<any, any, any>, callback: (...any: any[]) => void) => void;
     /**
      * @description
      * - method helper to WalkThrough `Set`;
@@ -19,7 +19,7 @@ export class WalkThrough {
      * @param {(value:VAL)=>void} callback
      * @returns {void}
      * @example
-     * import { WalkThrough } from 'vivth';
+     * import { WalkThrough } from 'vivth/neutral';
      *
      * WalkThrough.set(setOfSomething, (value) => {
      * 	// code
@@ -34,7 +34,7 @@ export class WalkThrough {
      * @param {(res:[key: KEY, value: VAL]) => void} callback
      * @returns {void}
      * @example
-     * import { WalkThrough } from 'vivth';
+     * import { WalkThrough } from 'vivth/neutral';
      *
      * WalkThrough.map(mapOfSomething, ([key, value]) => {
      * 	// code
@@ -49,26 +49,11 @@ export class WalkThrough {
      * @param {(res:[value: VAL, index: number]) => void} callback
      * @returns {void}
      * @example
-     * import { WalkThrough } from 'vivth';
+     * import { WalkThrough } from 'vivth/neutral';
      *
      * WalkThrough.array(arrayOfSomething, ([value, index]) => {
      * 	// code
      * })
      */
     static array<VAL>(arrayInstance: VAL[], callback: (res: [value: VAL, index: number]) => void): void;
-    /**
-     * @description
-     * - method helper to WalkThrough `Generator`;
-     * @template T
-     * @param {Generator<T, any, any>} generatorInstance
-     * @param {(value: T) => void} callback
-     * @returns {void}
-     * @example
-     * import { WalkThrough } from 'vivth';
-     *
-     * WalkThrough.generator(generatorOfSomething, (value) => {
-     * 	// code
-     * })
-     */
-    static generator<T>(generatorInstance: Generator<T, any, any>, callback: (value: T) => void): void;
 }