vivth 1.4.10 → 1.5.0

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

@@ -0,0 +1,36 @@
+/**
+ * @typedef {import('../typehints/VivthCleanup.mjs').VivthCleanup} VivthCleanup
+ */
+/**
+ * @description
+ * - wrapper for `watcher` via `esbuild.context`;
+ * - watcher cleanup is automatically registered to `SafeExit`;
+ * @template {import('esbuild').BuildOptions} O
+ * @implements {VivthCleanup}
+ */
+export class EsWatcher<O extends import("esbuild").BuildOptions> implements VivthCleanup {
+    /**
+     * @description
+     * @param {Partial<O>} buildOptions
+     * @param {import('esbuild').WatchOptions} [watchOptions]
+     * @example
+     * import { EsWatcher } from 'vivth/node';
+     *
+     * const { context, remove } = new EsWatcher({
+     *  ...esbuildOptions,
+     * });
+     */
+    constructor(buildOptions: Partial<O>, watchOptions?: import("esbuild").WatchOptions);
+    /**
+     * @description
+     * - Promise of `BuildContext`;
+     * @type {Promise<import('esbuild').BuildContext<O>>}
+     */
+    ctx: Promise<import("esbuild").BuildContext<O>>;
+    /**
+     * @type {()=>Promise<void>}
+     */
+    vivthCleanup: () => Promise<void>;
+    rebuild: () => Promise<import("esbuild").BuildResult<O>>;
+}
+export type VivthCleanup = import("../typehints/VivthCleanup.mjs").VivthCleanup;

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

@@ -1,38 +1,40 @@
+/**
+ * @typedef { import('../typehints/VivthCleanup.mjs').VivthCleanup } VivthCleanup
+ */
 /**
  * @description
  * - Signal implementation for `CustomEvent`, to dispatch and listen;
  * - it's based on string as key, so it can be listened/dispatched even without direct instance reference;
- * @template {IsListSignal} ISLIST
- * - boolean;
+ * @template {any} TYPE
+ * @implements {VivthCleanup}
  */
-export class EventSignal<ISLIST extends boolean> {
+export class EventSignal<TYPE extends unknown> implements VivthCleanup {
     /**
-     * @typedef {import('../types/IsListSignal.mjs').IsListSignal} IsListSignal
+     * @type {QChannel<string>}
      */
+    static #q: QChannel<string>;
     /**
-     * @description
      * - `Map` of `EventSignal`, using the `stringName` of the `EventSignal_instance` as `key`;
      * @type {Map<string, EventSignal<any>>}
      */
-    static map: Map<string, EventSignal<any>>;
-    /**
-     * @type {QChannel<string>}
-     */
-    static "__#private@#qChannelEventSignal": QChannel<string>;
+    static #map: Map<string, EventSignal<any>>;
     /**
      * @description
      * - the constructor it self is set to `private`;
      * - it's globally queued:
      * >- the `Promise` nature is to prevent race condition on creating the instance;
      * @param {string} stringName
-     * @param {IsListSignal} [isList_]
      * @returns {Promise<EventSignal<any>>}
      * @example
-     * import { EventSignal } from 'vivth';
+     * import { EventSignal, Trace } from 'vivth/neutral';
      *
      * const myEventSignal = await EventSignal.get('dataEvent');
+     * // recommendation
+     * const myEventSignalGenerator = async (name) => {
+     * 	return await EventSignal.get(`myEventSignalGenerator:${name}`);
+     * }
      */
-    static get: (stringName: string, isList_?: boolean) => Promise<EventSignal<any>>;
+    static get: (stringName: string) => Promise<EventSignal<any>>;
     /**
      * @description
      * - methods of this static property is lazily created;
@@ -47,7 +49,7 @@ export class EventSignal<ISLIST extends boolean> {
          * @param {import('./Effect.mjs').Effect} effectInstance
          * @returns {void}
          * @example
-         * import { EventSignal } from 'vivth';
+         * import { EventSignal } from 'vivth/neutral';
          *
          * EventSignal.remove.subscriber('yourEventSignalName', myEffectInstance);
          */
@@ -59,7 +61,7 @@ export class EventSignal<ISLIST extends boolean> {
          * @param {string} name
          * @returns {void}
          * @example
-         * import { EventSignal } from 'vivth';
+         * import { EventSignal } from 'vivth/neutral';
          *
          * EventSignal.remove.allSubscribers('yourEventSignalName');
          */
@@ -71,13 +73,13 @@ export class EventSignal<ISLIST extends boolean> {
          * @param {string} name
          * @returns {void}
          * @example
-         * import { EventSignal } from 'vivth';
+         * import { EventSignal } from 'vivth/neutral';
          *
          * EventSignal.remove.refs('yourEventSignalName');
          */
         refs: (name: string) => void;
     } & {
-        "vivth:unwrapLazy;": () => {
+        [x: symbol]: {
             /**
              * @static remove
              * @description
@@ -86,7 +88,7 @@ export class EventSignal<ISLIST extends boolean> {
              * @param {import('./Effect.mjs').Effect} effectInstance
              * @returns {void}
              * @example
-             * import { EventSignal } from 'vivth';
+             * import { EventSignal } from 'vivth/neutral';
              *
              * EventSignal.remove.subscriber('yourEventSignalName', myEffectInstance);
              */
@@ -98,7 +100,7 @@ export class EventSignal<ISLIST extends boolean> {
              * @param {string} name
              * @returns {void}
              * @example
-             * import { EventSignal } from 'vivth';
+             * import { EventSignal } from 'vivth/neutral';
              *
              * EventSignal.remove.allSubscribers('yourEventSignalName');
              */
@@ -110,7 +112,7 @@ export class EventSignal<ISLIST extends boolean> {
              * @param {string} name
              * @returns {void}
              * @example
-             * import { EventSignal } from 'vivth';
+             * import { EventSignal } from 'vivth/neutral';
              *
              * EventSignal.remove.refs('yourEventSignalName');
              */
@@ -120,21 +122,21 @@ export class EventSignal<ISLIST extends boolean> {
     /**
      * @private
      * @param {string} name
-     * @param {ISLIST} [isList]
      */
     private constructor();
+    vivthCleanup: () => Promise<void>;
     /**
      * @type {string}
      */
     name: string;
     /**
      * @description
-     * - is [Signal](#signal) or [ListSignal](#listsignal) instance, depending on the `isList` argument;
+     * - is [Signal](#signal) instance;
      * - if needed to pass along the messages, it can be used as `dispatcher` and `listener` at the same time;
      * - is `lazily` created;
-     * @type {Signal<any>|ListSignal<any>}
+     * @type {Signal<TYPE>}
      * @example
-     * import { EventSignal, Effect, Console } from 'vivth';
+     * import { EventSignal, Effect, Console } from 'vivth/neutral';
      *
      * const myEventSignal = await EventSignal.get('dataEvent', false);
      *
@@ -145,15 +147,15 @@ export class EventSignal<ISLIST extends boolean> {
      * })
      * myEventSignal.dispatch.value = 'hey';
      */
-    dispatch: Signal<any> | ListSignal<any>;
+    dispatcher: Signal<TYPE>;
     /**
      * @description
-     * - is [Derived](#derived) or [ListDerived](#listderived) instance, depending on the `isList` argument;
+     * - is [Derived](#derived);
      * - can be used as listener when passed down value shouldn't be modified manually;
      * - is `lazily` created along with `dispatch`, if `listen` is accessed first, then `dispatch` will also be created automatically;
-     * @type {Derived<any>|ListDerived<any>}
+     * @type {Derived<TYPE>}
      * @example
-     * import { EventSignal, Effect, Console } from 'vivth';
+     * import { EventSignal, Effect, Console } from 'vivth/neutral';
      *
      * const myEventSignal = await EventSignal.get('dataEvent', false);
      *
@@ -164,7 +166,7 @@ export class EventSignal<ISLIST extends boolean> {
      * })
      * myEventSignal.dispatch.value = 'hey';
      */
-    listen: Derived<any> | ListDerived<any>;
+    listener: Derived<TYPE>;
     remove: {
         /**
          * @instance remove
@@ -173,7 +175,7 @@ export class EventSignal<ISLIST extends boolean> {
          * @param {import('./Effect.mjs').Effect} effectInstance
          * @returns {void}
          * @example
-         * import { EventSignal, Effect, Console } from 'vivth';
+         * import { EventSignal, Effect, Console } from 'vivth/neutral';
          *
          * const myEventSignal = await EventSignal.get('dataEvent', false);
          *
@@ -191,7 +193,7 @@ export class EventSignal<ISLIST extends boolean> {
          * - remove allSubscribers from the `EventSignal_instance`;
          * @type  {()=>void}
          * @example
-         * import { EventSignal, Effect, Console } from 'vivth';
+         * import { EventSignal, Effect, Console } from 'vivth/neutral';
          *
          * const myEventSignal = await EventSignal.get('dataEvent', false);
          *
@@ -209,7 +211,7 @@ export class EventSignal<ISLIST extends boolean> {
          * - remove reference of the `proxySignals` of the `EventSignal_instance`;
          * @type {()=>void}
          * @example
-         * import { EventSignal, Effect, Console } from 'vivth';
+         * import { EventSignal, Effect, Console } from 'vivth/neutral';
          *
          * const myEventSignal = await EventSignal.get('dataEvent', false);
          *
@@ -222,7 +224,7 @@ export class EventSignal<ISLIST extends boolean> {
          */
         ref: () => void;
     } & {
-        "vivth:unwrapLazy;": () => {
+        [x: symbol]: {
             /**
              * @instance remove
              * @description
@@ -230,7 +232,7 @@ export class EventSignal<ISLIST extends boolean> {
              * @param {import('./Effect.mjs').Effect} effectInstance
              * @returns {void}
              * @example
-             * import { EventSignal, Effect, Console } from 'vivth';
+             * import { EventSignal, Effect, Console } from 'vivth/neutral';
              *
              * const myEventSignal = await EventSignal.get('dataEvent', false);
              *
@@ -248,7 +250,7 @@ export class EventSignal<ISLIST extends boolean> {
              * - remove allSubscribers from the `EventSignal_instance`;
              * @type  {()=>void}
              * @example
-             * import { EventSignal, Effect, Console } from 'vivth';
+             * import { EventSignal, Effect, Console } from 'vivth/neutral';
              *
              * const myEventSignal = await EventSignal.get('dataEvent', false);
              *
@@ -266,7 +268,7 @@ export class EventSignal<ISLIST extends boolean> {
              * - remove reference of the `proxySignals` of the `EventSignal_instance`;
              * @type {()=>void}
              * @example
-             * import { EventSignal, Effect, Console } from 'vivth';
+             * import { EventSignal, Effect, Console } from 'vivth/neutral';
              *
              * const myEventSignal = await EventSignal.get('dataEvent', false);
              *
@@ -280,10 +282,8 @@ export class EventSignal<ISLIST extends boolean> {
             ref: () => void;
         };
     };
-    #private;
 }
+export type VivthCleanup = import("../typehints/VivthCleanup.mjs").VivthCleanup;
 import { Signal } from './Signal.mjs';
-import { ListSignal } from './ListSignal.mjs';
 import { Derived } from './Derived.mjs';
-import { ListDerived } from './ListDerived.mjs';
 import { QChannel } from './QChannel.mjs';

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

@@ -0,0 +1,110 @@
+/**
+ * @typedef {import('../typehints/VivthCleanup.mjs').VivthCleanup} VivthCleanup
+ */
+/**
+ * @description
+ * - class helper for chokidar abstraction to watch and iterate paths;
+ * - this class assume `Paths` and `SafeExit` to be instantiated;
+ * @template {any} PASSEDVALUE
+ * @implements {VivthCleanup}
+ */
+export class FSDirArchWatcher<PASSEDVALUE extends unknown> implements VivthCleanup {
+    /**
+     * @description
+     * @param {string[]} watchPaths
+     * @param {Object} options
+     * @param {FSDirArchWatcher<PASSEDVALUE>["eachHandler"]} options.each
+     * - throw to `ignore` OR `delete` path from the result passed to `.full`;
+     * @param {FSDirArchWatcher<PASSEDVALUE>["fullHandler"]} options.full
+     * @param {number} [options.debounce]
+     * - debounce on calling `fullHandler`;
+     * @param {import('chokidar').ChokidarOptions} [options.chokidarOptions]
+     * - `ChokidarOptions`;
+     * @example
+     * import { FSDirArchWatcher, IsSameFile } from "vivth/node";
+     *
+     * const settingFile = '/fsrouter.setting.mjs';
+     *
+     * new FSDirArchWatcher(['/routers/', '/fsrouter.setting.mjs'], {
+     * 	// debounce: 100,
+     * 	each: async (eventName, path, stats) => {
+     * 		// this callback is queued already;
+     * 		// path are already `Paths.normalized`;
+     * 		if(IsSameFile(path, settingFile)){
+     * 			// code;
+     * 		}
+     * 		switch (eventName) {
+     * 			case 'add':
+     * 			case 'change':
+     * 				// structure route here and return;
+     * 				// a throwed call, will delete from sharedMap;
+     * 				return {};
+     * 			default:
+     * 				// only for imperative handler when needed;
+     * 				// or you can just throw here;
+     * 				return {};
+     * 		}
+     * 		// only non throwed call of path is registered to sharedMap;
+     * 		// throwed call of path is unregistered from sharedMap;
+     * 	},
+     * 	full:async (sharedMap) => {
+     * 		// this callback is queued already;
+     * 		// loop through returned from loop then write to a file;
+     * 	},
+     * })
+     */
+    constructor(watchPaths: string[], { chokidarOptions, each: eachHandler, full: fullHandler, debounce }: {
+        each: FSDirArchWatcher<PASSEDVALUE>["eachHandler"];
+        full: FSDirArchWatcher<PASSEDVALUE>["fullHandler"];
+        debounce?: number | undefined;
+        chokidarOptions?: Partial<{
+            persistent: boolean;
+            ignoreInitial: boolean;
+            followSymlinks: boolean;
+            cwd?: string;
+            usePolling: boolean;
+            interval: number;
+            binaryInterval: number;
+            alwaysStat?: boolean;
+            depth?: number;
+            ignorePermissionErrors: boolean;
+            atomic: boolean | number;
+        } & {
+            ignored: import("chokidar").Matcher | import("chokidar").Matcher[];
+            awaitWriteFinish: boolean | Partial<import("chokidar").AWF>;
+        }> | undefined;
+    });
+    /**
+     * @description
+     * - callback to handle each path;
+     * @type {(
+     *  eventName: import('chokidar/handler.js').EventName,
+     *  path: import('chokidar/handler.js').Path,
+     *  stats?: import('node:fs').Stats,
+     *  ) => Promise<PASSEDVALUE>
+     * }
+     */
+    eachHandler: (eventName: import("chokidar/handler.js").EventName, path: import("chokidar/handler.js").Path, stats?: import("node:fs").Stats) => Promise<PASSEDVALUE>;
+    /**
+     * @description
+     * - callback to handle all registered path;
+     * - debounced to only handle last changes on full registry with:
+     * >- `options.debounce`;
+     * >- `QChannel` `isLastOnQ`;
+     * @type {(
+     * 		alphabeticallySortedSharedValue: {
+     * 			map: Map<string, PASSEDVALUE>,
+     * 			array: Array<[path: string, PASSEDVALUE]>,
+     * 		}
+     * 	) => Promise<void>
+     * }
+     */
+    fullHandler: (alphabeticallySortedSharedValue: {
+        map: Map<string, PASSEDVALUE>;
+        array: Array<[path: string, PASSEDVALUE]>;
+    }) => Promise<void>;
+    watcher: import("chokidar").FSWatcher;
+    vivthCleanup: () => Promise<void>;
+    #private;
+}
+export type VivthCleanup = import("../typehints/VivthCleanup.mjs").VivthCleanup;

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

@@ -6,24 +6,33 @@ export class FileSafe {
     /**
      * @description
      * - method to safely detects whether filePaths exist;
-     * - uses fs/promises access under the hood;
+     * - uses `'node:fs/promises'.access` under the hood;
      * - also returning promise of result & error as value;
      * @param {string} filePath
-     * @returns {ReturnType<typeof TryAsync<true>>}
+     * @returns {Promise<boolean>}
      * @example
      * import { join } from 'node:path';
-     * import { FileSafe, Paths } from 'vivth';
+     * import { FileSafe } from 'vivth/node';
+     * import { Paths } from 'vivth/neutral';
      *
-     * const [, error] = await FileSafe.exist(
+     * const isExist = await FileSafe.exist(
      * 	join(Paths.root, '/some/path.mjs'),
      * );
-     * if (!error) {
-     * 	// file exists
-     * } else {
-     * 	// file not exists
-     * }
      */
-    static exist: (filePath: string) => ReturnType<typeof TryAsync<true>>;
+    static exist: (filePath: string) => Promise<boolean>;
+    /**
+     * @param { Parameters<writeFile>[1] } string
+     * @returns { string }
+     */
+    static #normalize: (string: Parameters<typeof writeFile>[1]) => string;
+    /**
+     * @param {Parameters<FileSafe.write>[0]} outFile
+     * @param {Parameters<FileSafe.write>[1]} content
+     * @param {Parameters<FileSafe.write>[2]} [options]
+     * @param {Parameters<FileSafe.write>[3]} [checkFuzySame]
+     * @returns {Promise<boolean>}
+     */
+    static #validToOverWrite: (outFile: Parameters<(outFile: Parameters<typeof writeFile>[0], content: Parameters<typeof writeFile>[1], options?: Parameters<typeof writeFile>[2], checkFuzySame?: boolean) => ReturnType<typeof TryAsync<void>>>[0], content: Parameters<(outFile: Parameters<typeof writeFile>[0], content: Parameters<typeof writeFile>[1], options?: Parameters<typeof writeFile>[2], checkFuzySame?: boolean) => ReturnType<typeof TryAsync<void>>>[1], options?: Parameters<(outFile: Parameters<typeof writeFile>[0], content: Parameters<typeof writeFile>[1], options?: Parameters<typeof writeFile>[2], checkFuzySame?: boolean) => ReturnType<typeof TryAsync<void>>>[2], checkFuzySame?: Parameters<(outFile: Parameters<typeof writeFile>[0], content: Parameters<typeof writeFile>[1], options?: Parameters<typeof writeFile>[2], checkFuzySame?: boolean) => ReturnType<typeof TryAsync<void>>>[3]) => Promise<boolean>;
     /**
      * @description
      * - method to create file safely by recursively mkdir the dirname of the outFile;
@@ -31,10 +40,14 @@ export class FileSafe {
      * @param {Parameters<writeFile>[0]} outFile
      * @param {Parameters<writeFile>[1]} content
      * @param {Parameters<writeFile>[2]} [options]
+     * @param {boolean} [checkFuzySame]
+     * - true: check while normalize consecutive whitespace into singel white space;
+     * - false(default): check absolute value;
      * @returns {ReturnType<typeof TryAsync<void>>}
      * @example
      * import { join } from 'node:path';
-     * import { FileSafe, Paths } from 'vivth';
+     * import { FileSafe } from 'vivth/node';
+     * import { Paths } from 'vivth/neutral';
      *
      * const [, errorWrite] = await FileSafe.write(
      * 	join(Paths.root, '/some/path.mjs'),
@@ -42,7 +55,7 @@ export class FileSafe {
      * 	{ encoding: 'utf-8' }
      * );
      */
-    static write: (outFile: Parameters<typeof writeFile>[0], content: Parameters<typeof writeFile>[1], options?: Parameters<typeof writeFile>[2]) => ReturnType<typeof TryAsync<void>>;
+    static write: (outFile: Parameters<typeof writeFile>[0], content: Parameters<typeof writeFile>[1], options?: Parameters<typeof writeFile>[2], checkFuzySame?: boolean) => ReturnType<typeof TryAsync<void>>;
     /**
      * @description
      * - method to copy file/dir safely by recursively mkdir the dirname of the dest;
@@ -53,7 +66,8 @@ export class FileSafe {
      * @returns {ReturnType<typeof TryAsync<void>>}
      * @example
      * import { join } from 'node:path';
-     * import { FileSafe, Paths } from 'vivth';
+     * import { FileSafe } from 'vivth/node';
+     * import { Paths } from 'vivth/neutral';
      *
      * const [, errorWrite] = await FileSafe.copy(
      * 	join(Paths.root, '/some/path.mjs'),
@@ -71,7 +85,8 @@ export class FileSafe {
      * @returns {ReturnType<typeof TryAsync<void>>}
      * @example
      * import { join } from 'node:path';
-     * import { FileSafe, Paths } from 'vivth';
+     * import { FileSafe} from 'vivth/node';
+     * import { Paths } from 'vivth/neutral';
      *
      * const [, errorRename] = await FileSafe.rename(
      * 	join(Paths.root, 'some/path'),
@@ -97,14 +112,15 @@ export class FileSafe {
      * @returns {ReturnType<typeof TryAsync<string|undefined>>}
      * @example
      * import { join } from 'node:path';
-     * import { FileSafe, Paths } from 'vivth';
+     * import { FileSafe } from 'vivth/node';
+     * import { Paths } from 'vivth/neutral';
      *
      * const [str, errorMkDir] = await FileSafe.mkdir(join(Paths.root, '/some/path/example'));
      */
     static mkdir: (outDir: Parameters<typeof mkdir>[0]) => ReturnType<typeof TryAsync<string | undefined>>;
 }
-import { TryAsync } from '../function/TryAsync.mjs';
 import { writeFile } from 'node:fs/promises';
+import { TryAsync } from '../function/TryAsync.mjs';
 import { copyFile } from 'node:fs/promises';
 import { rename } from 'node:fs/promises';
 import { rm } from 'node:fs/promises';

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

@@ -0,0 +1,57 @@
+/**
+ * @description
+ * - is collections of safe `.forEach` wrapper;
+ * >- via [TrySync](#trysync);
+ */
+export class ForEach {
+    static #handler: (iter: any, handler: any) => any[];
+    /**
+     * @description
+     * - static method helper for `array` to be iterate safely;
+     * @template T, R
+     * @param {T[]} array
+     * @param {(value: T, index: number, array: T[]) => R} handler
+     * @returns {Array<ReturnType<typeof TrySync<R>>>}
+     * @example
+     * import { Foreach } from 'vivth/neutral';
+     *
+     * const arr = ['a','b'];
+     * ForEach(arr, (string, i, arr_)=>{
+     * 	// unsafe Code
+     * });
+     */
+    static array<T, R>(array: T[], handler: (value: T, index: number, array: T[]) => R): Array<ReturnType<typeof TrySync<R>>>;
+    /**
+     * @description
+     * - static method helper for `set` to be iterate safely;
+     * @template T, R
+     * @param {Set<T>} set
+     * @param {(value: T, value2: T, set: Set<T>) => R} handler
+     * @returns {Array<ReturnType<typeof TrySync<R>>>}
+     * @example
+     * import { Foreach } from 'vivth/neutral';
+     *
+     * const set = new Set();
+     * ForEach(set, (value, value2, set_)=>{
+     * 	// unsafe Code
+     * });
+     */
+    static set<T, R>(set: Set<T>, handler: (value: T, value2: T, set: Set<T>) => R): Array<ReturnType<typeof TrySync<R>>>;
+    /**
+     * @description
+     * - static method helper for `map` to be iterate safely;
+     * @template K, V, R
+     * @param {Map<K,V>} map
+     * @param {(value: V, key: K, map: Map<K,V>) => R} handler
+     * @returns {Array<ReturnType<typeof TrySync<R>>>}
+     * @example
+     * import { Foreach } from 'vivth/neutral';
+     *
+     * const map = new Map();
+     * ForEach(map, (value, key, map_)=>{
+     * 	// unsafe Code
+     * });
+     */
+    static map<K, V, R>(map: Map<K, V>, handler: (value: V, key: K, map: Map<K, V>) => R): Array<ReturnType<typeof TrySync<R>>>;
+}
+import { TrySync } from '../function/TrySync.mjs';

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

@@ -0,0 +1,63 @@
+/**
+ * @typedef {import('../typehints/VivthCleanup.mjs').VivthCleanup} VivthCleanup
+ */
+/**
+ * @description
+ * - this class extends `Signal`;
+ * - `ForSignal_instance.runCleanUp` still needs to be manually called, when cleaning up this instance;
+ * @template {any} TYPE
+ * @implements {VivthCleanup}
+ * @extends {Signal<Array<TYPE|undefined>>}
+ */
+export class ForSignal<TYPE extends unknown> extends Signal<(TYPE | undefined)[]> implements VivthCleanup {
+    /**
+     * @description
+     * @param {(
+     *	this: ForSignal<TYPE>,
+     *	arg:{
+     *		index:number,
+     *		value:{ value:TYPE, isValueDefined:true, }|
+     *			{ value:undefined, isValueDefined:false, },
+     *		prev:{ prev:TYPE, isPrevDefined:true, }|
+     * 			{ prev:undefined, isPrevDefined:false, },
+     * 	})=>void
+     * } loopCallback
+     * - the diffence of `current` and `prev` or `isValueDefined` and `isPrevDefined` can be used for sideEffect, such as;
+     * >- `adding/removing/modifiying` `childNode`s on a parent element;
+     * >- `adding/removing/modifiying` `Signal` instances;
+     * @param {()=>void} [additionalCleanUp]
+     * - additional callback to be run when runCleanUp is called;
+     * @example
+     * import { ForSignal } from 'vivth/neutral';
+     *
+     * const myLoop = new ForSignal(
+     * 	function ({ index, value: {value, isValueDefined}, prev:{ prev, isPrevDefined} }) {
+     * 		// code
+     * 	},
+     * 	() => {
+     * 	 // additional cleanup code
+     * 	}
+     * )
+     * // myLoop.runCleanUp(); // need to be called manually when the instance are to out of scope;
+     */
+    constructor(loopCallback: (this: ForSignal<TYPE>, arg: {
+        index: number;
+        value: {
+            value: TYPE;
+            isValueDefined: true;
+        } | {
+            value: undefined;
+            isValueDefined: false;
+        };
+        prev: {
+            prev: TYPE;
+            isPrevDefined: true;
+        } | {
+            prev: undefined;
+            isPrevDefined: false;
+        };
+    }) => void, additionalCleanUp?: () => void);
+    #private;
+}
+export type VivthCleanup = import("../typehints/VivthCleanup.mjs").VivthCleanup;
+import { Signal } from './Signal.mjs';

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

@@ -0,0 +1,38 @@
+/**
+ * @description
+ * - create getter setter in one place;
+ * @template {any} RET
+ * @template {((...any:any[])=>RET)} TG
+ * @template {((...any:any[])=>void)} TS
+ * @example
+ * import { GetterSetter } from 'vivth/neutral';
+ *
+ * const localA = new GetterSetter({
+ * 	get:() => {
+ * 		return localStorage.getItem('myAValue');
+ * 	},
+ * 	set:(newValue) => {
+ * 		return localStorage.setItem('myAValue', newValue);
+ * 	},
+ * });
+ * localA.get(); // null;
+ * localA.set('my new value');
+ * localA.get(); // 'my new value'
+ */
+export class GetterSetter<RET extends unknown, TG extends ((...any: any[]) => RET), TS extends ((...any: any[]) => void)> {
+    /**
+     * @param {{ get?: TG, set?: TS }} options
+     */
+    constructor({ get, set }: {
+        get?: TG;
+        set?: TS;
+    });
+    /**
+     * @type {ConstructorParameters<typeof GetterSetter<RET,TG,TS>>[0]["get"]}
+     */
+    get: ConstructorParameters<typeof GetterSetter<RET, TG, TS>>[0]["get"];
+    /**
+     * @type {ConstructorParameters<typeof GetterSetter<RET,TG,TS>>[0]["set"]}
+     */
+    set: ConstructorParameters<typeof GetterSetter<RET, TG, TS>>[0]["set"];
+}