vivth 1.4.9 → 1.5.0

package/generated/types/src/bundler/adds/PathFSDir.bundled.d.mts

@@ -0,0 +1,30 @@
+export class PathFSDir {
+    /**
+     * @param {string} relativePath
+     * @param {RegExp} rule
+     * @param {{shouldNotIncludes:string}} [options]
+     * @returns {PathFSDir}
+     */
+    static vivthDir: (relativePath: string, rule: RegExp, options?: {
+        shouldNotIncludes: string;
+    }) => PathFSDir;
+    /**
+     * @param {Parameters<typeof PathFSDir["vivthDir"]>[0]} relativePath
+     * @param {Parameters<typeof PathFSDir["vivthDir"]>[2]} [_options]
+     * @param {Parameters<typeof PathFSDir["vivthDir"]>[1]} [rule]
+     */
+    constructor(relativePath: Parameters<(typeof PathFSDir)["vivthDir"]>[0], _options?: Parameters<(typeof PathFSDir)["vivthDir"]>[2], rule?: Parameters<(typeof PathFSDir)["vivthDir"]>[1]);
+    /**
+     * @type {RegExp}
+     */
+    get rule(): RegExp;
+    /**
+     * @returns {string}
+     */
+    get path(): string;
+    /**
+     * @returns {string}
+     */
+    get callerPath(): string;
+    #private;
+}

package/generated/types/src/bundler/adds/PathFSDir.d.mts

@@ -0,0 +1,48 @@
+/**
+ * @description
+ * - includes all files, that match the rule to `.asar` specification;
+ */
+export class PathFSDir {
+    /**
+     * @description
+     * @param {string} relativePath
+     * - relativePath to the `dirname` of the file you are calling this method;
+     * @param {RegExp} rule
+     * @param {Parameters<typeof import('./PathFSBundles.mjs').PathFSBundles["vivthBundles"]>[1]} [options]
+     * @returns {PathFSDir}
+     * @example
+     * import { PathFSDir } from 'vivth/node';
+     *
+     * PathFSDir.vivthDir('../src/', /[\s\S]\*[blank]/);
+     * // visible for ide inline check: without `[blank]`;
+     */
+    static vivthDir: (relativePath: string, rule: RegExp, options?: Parameters<typeof import("./PathFSBundles.mjs").PathFSBundles["vivthBundles"]>[1]) => PathFSDir;
+    /**
+     * @private
+     * @param {Parameters<typeof PathFSDir["vivthDir"]>[0]} relativePath
+     * @param {Parameters<typeof PathFSDir["vivthDir"]>[2]} [options]
+     * @param {Parameters<typeof PathFSDir["vivthDir"]>[1]} [rule]
+     */
+    private constructor();
+    /**
+     * @description
+     * - rule for dir, to get file any file match the rule inside that directory;
+     * @type {RegExp}
+     */
+    get rule(): RegExp;
+    /**
+     * @description
+     * - relative path of the target to the project root;
+     * @returns {string}
+     */
+    get path(): string;
+    /**
+     * @description
+     * - depending on whether running on bundled or not;
+     * - unBundled: absolute disk path of the file caller;
+     * - bundled: `blankstring`;
+     * @returns {string}
+     */
+    get callerPath(): string;
+    #private;
+}

package/generated/types/src/bundler/adds/PathFSFile.bundled.d.mts

@@ -0,0 +1,25 @@
+export class PathFSFile {
+    /**
+     * @param {string} relativePath
+     * @param {{shouldNotIncludes:string}} [options]
+     * @returns {PathFSFile}
+     */
+    static vivthFile: (relativePath: string, options?: {
+        shouldNotIncludes: string;
+    }) => PathFSFile;
+    /**
+     * @private
+     * @param {Parameters<typeof PathFSFile["vivthFile"]>[0]} relativePath
+     * @param {Parameters<typeof PathFSFile["vivthFile"]>[1]} [_options]
+     */
+    private constructor();
+    /**
+     * @returns {string}
+     */
+    get path(): string;
+    /**
+     * @returns {string}
+     */
+    get callerPath(): string;
+    #private;
+}

package/generated/types/src/bundler/adds/PathFSFile.d.mts

@@ -0,0 +1,40 @@
+/**
+ * @description
+ * >- the file are added to `asar` AS IS, OR
+ * >- transformed according to the `asar.options.transform` value;
+ */
+export class PathFSFile {
+    /**
+     * @description
+     * @param {string} relativePath
+     * - to the dirname of the file you are calling this method;
+     * @param {Parameters<typeof import('./PathFSBundles.mjs').PathFSBundles["vivthBundles"]>[1]} [options]
+     * @returns {PathFSFile}
+     * @example
+     * import { PathFSFile } from 'vivth/node';
+     *
+     * PathFSFile.vivthFile('../CompileAS.mjs');
+     */
+    static vivthFile: (relativePath: string, options?: Parameters<typeof import("./PathFSBundles.mjs").PathFSBundles["vivthBundles"]>[1]) => PathFSFile;
+    /**
+     * @private
+     * @param {Parameters<typeof PathFSFile["vivthFile"]>[0]} relativePath
+     * @param {Parameters<typeof PathFSFile["vivthFile"]>[1]} [options]
+     */
+    private constructor();
+    /**
+     * @description
+     * - relative path of the target to the project root;
+     * @returns {string}
+     */
+    get path(): string;
+    /**
+     * @description
+     * - depending on whether running on bundled or not;
+     * - unBundled: absolute disk path of the file caller;
+     * - bundled: `blankstring`;
+     * @returns {string}
+     */
+    get callerPath(): string;
+    #private;
+}

package/{types → generated/types}/src/bundler/adds/ToBundledJSPlugin.d.mts

@@ -1,19 +1,19 @@
 /**
  * @description
- * - generate `esbuild.Plugin` for changing dev time file into runtime file;
+ * - generate `esbuild.Plugin` for changing unbundled time file into runtime file;
  * - on using esbuild with this plugin, it will:
  * >- replace any module that have similiar file name but ended with Bundled(before extname);
- * >- works on `.mts`|`.ts`|`.mjs`|`.cjs`|`.js`;
- * >- `${fileName}.mjs` -> seek for and use `${fileName}Bundled.mjs`, if not found use `${fileName}.mjs`;
- * >- removes `Dev.vivthDevCodeBlock` code block;
+ * >- works on `.mts`|`.ts`|`.mjs`|`.js`;
+ * >- `${fileName}.mjs` -> seek for and use `${fileName}.bundled.mjs`, if not found use `${fileName}.mjs`;
+ * >- removes `BundledV.vivthUnBundledCodeBlock` code block;
  * @param {string} includedInPath
  * - is generalized path, you can freely uses forward or backward slash;
  * @returns {ReturnType<CreateESPlugin>}
  * @example
- * import { ToBundledJSPlugin } from 'vivth';
+ * import { ToBundledJSPlugin } from 'vivth/node';
  *
  * export const myBundledPlugin = ToBundledJSPlugin('/myProjectName/src/');
  */
 export function ToBundledJSPlugin(includedInPath: string): ReturnType<typeof CreateESPlugin>;
-export function removeVivthDevCodeBlock(originalContent_: string): string;
+export function commonContentFixesBundled(filePath: string, originalContent_: string): string;
 import { CreateESPlugin } from '../CreateESPlugin.mjs';

package/generated/types/src/bundler/adds/autoExternalize.d.mts

@@ -0,0 +1,2 @@
+export function autoExternalize(path: string, targetPath: string, watchPath: string, mapToPath: string, depMap: Map<string, Set<string>>, esbuildPathRebuild: Map<string, () => Promise<any>>): Plugin;
+import type { Plugin } from 'esbuild';

package/generated/types/src/bundler/adds/emptyBufferValue.d.mts

@@ -0,0 +1 @@
+export function emptyBufferValue(): Buffer<ArrayBuffer>;

package/generated/types/src/bundler/adds/isModuleTheBundledVersion.d.mts

@@ -0,0 +1 @@
+export function isModuleTheBundledVersion(path: string, ext: string): boolean;

package/generated/types/src/bundler/adds/onEndEsBuildErrorLogger.d.mts

@@ -0,0 +1 @@
+export function onEndEsBuildErrorLogger(errorData: import("esbuild").Message[]): void;

package/generated/types/src/bundler/adds/resolveJSDependencyPath.d.mts

@@ -0,0 +1 @@
+export function resolveJSDependencyPath(jspath: string): Promise<boolean>;

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

@@ -0,0 +1,48 @@
+/**
+ * @typedef {import('../typehints/VivthCleanup.mjs').VivthCleanup} VivthCleanup
+ */
+/**
+ * @description
+ * - `Signal` to unwrap `Promise`;
+ * - useful to create underlying mechanism for something like react `Suspense` component;
+ * - auto queued for last unwrap request;
+ * @template {any} VALUE
+ * @template {any[]} ARGS
+ * @extends {Signal<VALUE|Promise<VALUE>|Error>}
+ * @implements {VivthCleanup}
+ * @example
+ * import { AwaitSignal, Effect } from 'vivth/neutral'
+ * const bigAwaitSignal = new AwaitSignal(fetch('../SomethingReallyBig'));
+ * new Effect(async({ subscribe })=>{
+ * 	const myBigLoadProgress = subscribe(bigAwaitSignal).value;
+ * 	const isError = IsInstanceOf(myBigLoadProgress, Error);
+ * 	if(isError){
+ * 		// handle error here
+ * 		return;
+ * 	}
+ * 	const isAPromise = IsInstanceOf(myBigLoadProgress, Promise);
+ * 	if(isAPromise){
+ * 		// handle suspense here;
+ * 		return;
+ * 	}
+ * 	// handle ready state here;
+ * })
+ */
+export class AwaitSignal<VALUE extends unknown, ARGS extends any[]> extends Signal<Error | VALUE | Promise<VALUE>> implements VivthCleanup {
+    /**
+     * @param {(...args:ARGS)=>Promise<VALUE>} callback
+     * @param {ARGS} firstCallArguments
+     */
+    constructor(callback: (...args: ARGS) => Promise<VALUE>, ...firstCallArguments: ARGS);
+    retryCount: number;
+    /**
+     * @param {number} maxRetries
+     * - `0` for no limit;
+     * @param {ARGS} args
+     * - integer of retryCount;
+     */
+    retry: (maxRetries: number, ...args: ARGS) => void;
+    #private;
+}
+export type VivthCleanup = import("../typehints/VivthCleanup.mjs").VivthCleanup;
+import { Signal } from './Signal.mjs';

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

@@ -0,0 +1,82 @@
+/**
+ * @description
+ * - class with static methods to print to standard console with bare minimum ANSI styles;
+ */
+export class Console {
+    static #ansi: {
+        reset: string;
+        bold: string;
+        colors: {
+            log: string;
+            info: string;
+            warn: string;
+            error: string;
+        };
+    };
+    /**
+     * @param {any} data
+     * @param {import("../typehints/ConsoleAdditionalSettingType.mjs").ConsoleAdditionalSettingType} args
+     * @return {object}
+     */
+    static #addArgsHandler: (data: any, { now: now_ }: import("../typehints/ConsoleAdditionalSettingType.mjs").ConsoleAdditionalSettingType) => object;
+    /**
+     * @param {string} prefix
+     * @param {'log'|'info'|'error'|'warn'} mode
+     * @param {any} data
+     * @param {import("../typehints/ConsoleAdditionalSettingType.mjs").ConsoleAdditionalSettingType} [addArgs]
+     * @returns {void}
+     */
+    static #call: (prefix: string, mode: "log" | "info" | "error" | "warn", data: any, addArgs?: import("../typehints/ConsoleAdditionalSettingType.mjs").ConsoleAdditionalSettingType) => void;
+    /**
+     * @description
+     * @param {any} data
+     * @param {import("../typehints/ConsoleAdditionalSettingType.mjs").ConsoleAdditionalSettingType} [addArgs]
+     * @returns {void}
+     * @example
+     * import { Console } from 'vivth/neutral';
+     *
+     * Console.log({
+     * 	hello: 'world!!',
+     * });
+     */
+    static log: (data: any, addArgs?: import("../typehints/ConsoleAdditionalSettingType.mjs").ConsoleAdditionalSettingType) => void;
+    /**
+     * @description
+     * @param {any} data
+     * @param {import("../typehints/ConsoleAdditionalSettingType.mjs").ConsoleAdditionalSettingType} [addArgs]
+     * @returns {void}
+     * @example
+     * import { Console } from 'vivth/neutral';
+     *
+     * Console.info({
+     * 	hello: 'world!!',
+     * });
+     */
+    static info: (data: any, addArgs?: import("../typehints/ConsoleAdditionalSettingType.mjs").ConsoleAdditionalSettingType) => void;
+    /**
+     * @description
+     * @param {any} data
+     * @param {import("../typehints/ConsoleAdditionalSettingType.mjs").ConsoleAdditionalSettingType} [addArgs]
+     * @returns {void}
+     * @example
+     * import { Console } from 'vivth/neutral';
+     *
+     * Console.warn({
+     * 	hello: 'world!!',
+     * });
+     */
+    static warn: (data: any, addArgs?: import("../typehints/ConsoleAdditionalSettingType.mjs").ConsoleAdditionalSettingType) => void;
+    /**
+     * @description
+     * @param {any} data
+     * @param {import("../typehints/ConsoleAdditionalSettingType.mjs").ConsoleAdditionalSettingType} [addArgs]
+     * @returns {void}
+     * @example
+     * import { Console } from 'vivth/neutral';
+     *
+     * Console.error({
+     * 	hello: 'world!!',
+     * });
+     */
+    static error: (data: any, addArgs?: import("../typehints/ConsoleAdditionalSettingType.mjs").ConsoleAdditionalSettingType) => void;
+}

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

@@ -0,0 +1,25 @@
+/**
+ * @description
+ * - class helper for signal performant logging, more or less just for type hinting;
+ * - internally used as Signal value logging instance;
+ * @template {any} VALUE
+ */
+export class DataLog<VALUE extends unknown> {
+    /**
+     * @description
+     * @param {VALUE} value
+     */
+    constructor(value: VALUE);
+    /**
+     * @description
+     * - data value;
+     * @type {VALUE}
+     */
+    value: VALUE;
+    /**
+     * @description
+     * - occurence unix timestamp;
+     * @type {number}
+     */
+    timeStamp: number;
+}

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

@@ -0,0 +1,74 @@
+/**
+ * @description
+ * - a class for creating derived version of [Signal](#signal);
+ * @template VALUE
+ * @extends Signal<VALUE|undefined>
+ */
+export class Derived<VALUE> extends Signal<VALUE | undefined> {
+    /**
+     * @description
+     * - Derived used [Signal](#signal) and [Effect](#effect) under the hood;
+     * @param {(
+     * 		effectInstanceOptions: Parameters<ConstructorParameters<typeof Effect>[0]>[0] &
+     * 		{
+     * 			dontUpdate:Derived<VALUE>["dontUpdate"]
+     * 		}
+     * 	) => Promise<Derived<VALUE>["dontUpdate"] | VALUE>
+     * } derivedFunction
+     * @param {ConstructorParameters<typeof Effect>[1]} [maxTimelapseBeingDebounced]
+     * - prevent rapid changes from being unhandled more than the value;
+     * - in miliseconds;
+     * - default: `2_000`;
+     * @example
+     * import { Signal, Derived } from 'vivth/neutral';
+     *
+     * const count = new Signal(0);
+     * const double = new Derived(async({
+     * 		subscribe,
+     * 		// : registrar callback for this derived instance, immediately return the signal instance
+     * 	}) => {
+     * 	return subscribe(count).value \* 2;
+     * 	// double listen to count changes, by returning the value, double.value also changes
+     * 	// notice the count.value are accessed double, but it's all safe,
+     * 	// since the wrapped one is the only one that are recorded as notifier.
+     * });
+     *
+     * count.value++;
+     */
+    constructor(derivedFunction: (effectInstanceOptions: Parameters<ConstructorParameters<typeof Effect>[0]>[0] & {
+        dontUpdate: Derived<VALUE>["dontUpdate"];
+    }) => Promise<Derived<VALUE>["dontUpdate"] | VALUE>, maxTimelapseBeingDebounced?: ConstructorParameters<typeof Effect>[1]);
+    /**
+     * @description
+     * - return this value to not to update the value of this instance, even when returning early;
+     * @type {Symbol}
+     * @example
+     * import { Signal, Derived } from 'vivth/neutral';
+     *
+     * const count = new Signal(0);
+     * const double = new Derived(async({
+     * 		subscribe,
+     * 		isLastCalled,
+     * 	}) => {
+     * 		if(!(await isLastCalled(100))) {
+     * 			return this.dontUpdate;
+     * 		}
+     * 		const currentValue = subscribe(count).value;
+     * 		const res = await fetch(`some/path/${curentValue.toString()}`);
+     * 		if (
+     * 			!(await isLastCalled()) ||
+     * 			!res
+     * 		) {
+     * 			// returning early prevent race condition, even if the earlier fetch return late;
+     *			return this.dontUpdate;
+     *			// returning this.dontUpdate, will not modify the derived instance value;
+     * 		}
+     * 		count.value++;
+     * 		return res;
+     * });
+     *
+     */
+    dontUpdate: Symbol;
+}
+import { Signal } from './Signal.mjs';
+import { Effect } from './Effect.mjs';

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

@@ -0,0 +1,213 @@
+/**
+ * @typedef { import('../typehints/VivthCleanup.mjs').VivthCleanup } VivthCleanup
+ */
+/**
+ * @type {Map<Effect, Set<Signal<any>>>}
+ */
+export const mapOfEffects: Map<Effect, Set<Signal<any>>>;
+/**
+ * @description
+ * - a class for creating effect;
+ * - behaviour:
+ * >- doesn't autosubscribe at first run;
+ * >- it is using passed <b>subscribe</b> named `arg0` options as subscriber;
+ * >- doesn't block other queues during first run;
+ * >- can dynamically subscribes to signal, even on conditionals, that are not run during first run;
+ * @implements {VivthCleanup}
+ */
+export class Effect implements VivthCleanup {
+    /**
+     * @type {WeakMap<Object, ()=>void>}
+     */
+    static #mapCurrentCleanupCallback: WeakMap<Object, () => void>;
+    /**
+     * @description
+     * @param {(
+     * 		arg0: Effect["options"]
+     * 	) => Promise<void>
+     * } effect
+     * @param {number} [maxTimelapseBeingDebounced]
+     * - prevent rapid changes from being unhandled more than the value;
+     * - in miliseconds;
+     * - default: `2_000`;
+     * @example
+     * import { Signal, Derived, Effect, Console } from 'vivth/neutral';
+     *
+     * const count = new Signal(0);
+     *
+     * // double listen to count changes
+     * const double = new Derived(async({subscribe}) => subscribe(count).value \* 2);
+     *
+     * new Effect(async ({
+     * 			subscribe, // : registrar callback for this effect instance, immediately return the signal instance
+     * 			removeEffect, // : disable this effect instance from reacting to dependency changes;
+     * 			isLastCalled, // : check whether this callback run is this instance last called effect;
+     * 		}) => {
+     * 			const { value: currentValue, prev: prevValue } = subscribe(double); // effect listen to double changes
+     * 			Console.log({ currentValue, prevValue });
+     * })
+     *
+     * count.value++;
+     */
+    constructor(effect: (arg0: Effect["options"]) => Promise<void>, maxTimelapseBeingDebounced?: number);
+    vivthCleanup: () => Promise<void>;
+    /**
+     * @description
+     * - collections of methods to handle effect calls of this instance;
+     */
+    options: {
+        /**
+         * @instance options
+         * @description
+         * - subscribe to `Signal_instance`;
+         * - normally it's passed as argument to constructor, however it is also accessible from `options` property;
+         * @template {Signal<any>} SIGV
+         * @param {SIGV} signalInstance
+         * @returns {SIGV}
+         * @example
+         * import { Signal, Effect } from 'vivth/neutral';
+         *
+         * const signal1 = new Signal(0);
+         * const signal2 = new Signal(true);
+         * const signal3 = new Signal(true);
+         * const effect = new Effect(async ({ subscribe }) => {
+         * 	const signal1Value = subscribe(signal1).value;
+         * 	if(signal1Value % 2){
+         * 		// only subscribe to signal3, on conditional block
+         * 		const signal3Value = subscribe(signal3).value;
+         * 	}
+         * })
+         * effect.options.subscribe(signal2);
+         */
+        subscribe: <SIGV extends Signal<any>>(signalInstance: SIGV) => SIGV;
+        /**
+         * @instance options
+         * @description
+         * - the same with `.options.subscribe`, but for batches subscription;
+         * - ideal for first run which to add signal to subscription on main condition;
+         * - normally it's passed as argument to constructor, however it is also accessible from `options` property;
+         * @template {ReadonlyArray<any>} T
+         * @param {T} signalInstances
+         * @returns {T}
+         * @example
+         * import { Signal, Effect } from 'vivth/neutral';
+         *
+         * const signal1 = new Signal(0);
+         * const signal2 = new Signal(true);
+         * const effect = new Effect(async ({ subscribes }) => {
+         * 	const [{value: signal1Value}, {value: signal2Value}]= subscribes([signal1, signal2]);
+         * })
+         */
+        subscribes: <T extends ReadonlyArray<any>>(signalInstances: T) => T;
+        /**
+         * @instance options
+         * @description
+         * - normally it's passed as argument to constructor, however it is also accessible from `options` property;
+         * @type {()=>void}
+         * @example
+         * import { Effect } from 'vivth/neutral';
+         *
+         * const effect = new Effect(async ({removeEffect}) => {
+         * 	if(someCondition){
+         * 		removeEffect();
+         * 		return
+         * 	}
+         * })
+         * // OR
+         * effect.options.removeEffect();
+         */
+        removeEffect: () => void;
+        /**
+         * @description
+         * - remove inputed signal from this `Effect_instance`;
+         * - if effect signal has no other `Signal_instance` to listen to, it will then completely rendered non reactive;
+         * - normally it's passed as argument to constructor, however it is also accessible from `options` property;
+         * @param {Signal<any>} signalInstance
+         * @returns {void}
+         * @example
+         * import { Effect, Signal } from 'vivth/neutral';
+         *
+         * const count = new Signal(0);
+         * const effect = new Effect(async ({ subscribe }) => {
+         * 	console.log(subscribe(count).value); // will subscribe  count changes;
+         * })
+         * count.value++; // will increase the count and trigger effect;
+         * effect.options.removeSignal(count);
+         * count.value++; // will increase the count but will no longer trigger effect;
+         */
+        removeSignal: (signalInstance: Signal<any>) => void;
+        /**
+         * @description
+         * - remove inputed `SignalCollection` from this `Effect_instance`;
+         * - normally it's passed as argument to constructor, however it is also accessible from `options` property;
+         * @param {import('./SignalCollection.mjs').SignalCollection<Record<string, Signal<any>>>} collectionInstance
+         * @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 });
+         *
+         * const e = new Effect(async ({ subscribe, isLastCalled, removeCollection }) => {
+         * 	const {
+         * 		a: { value: aa }, // safely desctructured and auto subscribed
+         * 		c: { value: cc }, // safely desctructured and auto subscribed
+         * 	} = f.signals(subscribe);
+         * 	if(!await isLastCalled(100)) {
+         * 		return; // impertaive debounce
+         * 	}
+         * 	// removeCollection(f); // standard call from outside callback;
+         * });
+         * // optional call from outside callback;
+         * e.options.removeCollection(f)
+         */
+        removeCollection: (collectionInstance: import("./SignalCollection.mjs").SignalCollection<Record<string, Signal<any>>>) => void;
+        /**
+         * @instance options
+         * @description
+         * @returns {(timeoutMS?:number)=>Promise<boolean>}
+         * - timeoutMS only necessary if the operation doesn't naturally await;
+         * - if it's operation such as `fetch`, you can just leave it blank;
+         * @example
+         *
+         * import { Effect } from 'vivth/neutral';
+         *
+         * const effect = new Effect(async ({ isLastCalled }) => {
+         * 	if (!(await isLastCalled(100))) {
+         * 		return;
+         * 	}
+         * 	// OR
+         * 	const res = await fetch('some/path');
+         * 	if (!(await isLastCalled(
+         * 		// no need to add timeoutMS argument, as fetch are naturally add delay;
+         * 	))) {
+         * 		return;
+         * 	}
+         * })
+         */
+        readonly isLastCalled: (timeoutMS?: number) => Promise<boolean>;
+    } & {
+        [FactoryKey]: FACTORY;
+    };
+    /**
+     * @description
+     * - normally is to let to be automatically run when dependency signals changes, however it's also accessible as instance method;
+     * @type {()=>void}
+     * @example
+     * import { Effect } from 'vivth/neutral';
+     *
+     * const effect = new Effect(async ()=>{
+     * 	// code
+     * })
+     * effect.run();
+     */
+    run: () => void;
+    #private;
+}
+export type VivthCleanup = import("../typehints/VivthCleanup.mjs").VivthCleanup;
+import { Signal } from './Signal.mjs';
+import { FactoryKey } from '../common/FactoryKey.mjs';

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

@@ -8,6 +8,10 @@ export class EnvSignal<VALUE> {
      * @description
      * - create `EnvSignal` instance;
      * @param {VALUE} initialValue
+     * @example
+     * import { EnvSignal } from 'vivth/neutral';
+     *
+     * export const myEnv = new EnvSignal(true);
      */
     constructor(initialValue: VALUE);
     /**
@@ -15,7 +19,7 @@ export class EnvSignal<VALUE> {
      * - exposed property to listen to;
      * @type {Derived<VALUE>}
      * @example
-     * import { EnvSignal, Effect } from 'vivth';
+     * import { EnvSignal, Effect } from 'vivth/neutral';
      *
      * export const myEnv = new EnvSignal(true);
      * new Effect(async ({ subscribe }) => {
@@ -31,7 +35,7 @@ export class EnvSignal<VALUE> {
      * @param {VALUE} correctedValue
      * @returns {void}
      * @example
-     * import { EnvSignal } from 'vivth';
+     * import { EnvSignal } from 'vivth/neutral';
      *
      * export const myEnv = new EnvSignal(true);
      *