vivth 1.4.10 → 1.5.0

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

@@ -0,0 +1,50 @@
+/**
+ * @description
+ * - class helper to handle `.json` file;
+ * - this class assume, `Paths` already instantiated;
+ */
+export class JSONFileHandler {
+    /**
+     * @param {string} path
+     * - `relative`(to `Paths.root`) OR `absolute`, both are accepted;
+     */
+    constructor(path: string);
+    /**
+     * @description
+     * @returns {ReturnType<typeof TryAsync<Object>>}
+     * @example
+     * import { JSONFileHandler } from "vivth/node";
+     *
+     * const packageJSONHandler = new JSONFileHandler('/package.json');
+     * const [content, error] = await packageJSONHandler.read();
+     */
+    read: () => ReturnType<typeof TryAsync<Object>>;
+    /**
+     * @description
+     * @param {Object} newObj
+     * @return { ReturnType<typeof TryAsync<void>> }
+     * @example
+     * import { this.writeJSONFileHandler } from "vivth/node";
+     *
+     * const packageJSONHandler = new JSONFileHandler('/package.json');
+     * const [, error] = await packageJSONHandler.write({
+     *  ...object,
+     * });
+     */
+    write: (newObj: Object) => ReturnType<typeof TryAsync<void>>;
+    /**
+     * @description
+     * @param {Object} object
+     * @return { ReturnType<typeof TryAsync<void>> }
+     * @example
+     * import { JSONFileHandler } from "vivth/node";
+     *
+     * const packageJSONHandler = new JSONFileHandler('/package.json');
+     * const [, error] = await packageJSONHandler.assign({
+     *  ...object,
+     * });
+     */
+    assign: (object: Object) => ReturnType<typeof TryAsync<void>>;
+    #private;
+}
+import { TryAsync } from '../function/TryAsync.mjs';

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

@@ -1,14 +1,14 @@
 /**
- * @typedef {import('../types/ListArg.mjs').ListArg} ListArg
- * @typedef {import('../types/MutationType.mjs').MutationType} MutationType
+ * @typedef {import('../typehints/ListArg.mjs').ListArg} ListArg
+ * @typedef {import('../typehints/MutationType.mjs').MutationType} MutationType
  */
 /**
  * @description
  * - class to create list that satisfy `Array<Record<string, string>>`.
- * @template {import('../types/ListArg.mjs').ListArg} LISTARG
+ * @template {import('../typehints/ListArg.mjs').ListArg} LISTARG
  * @extends {Signal<LISTARG[]>}
  */
-export class ListSignal<LISTARG extends import("../types/ListArg.mjs").ListArg> extends Signal<LISTARG[]> {
+export class ListSignal<LISTARG extends import("../typehints/ListArg.mjs").ListArg> extends Signal<LISTARG[]> {
     /**
      * @description
      * - Checks if the input is an array whose first item (if present) is a plain object
@@ -21,15 +21,17 @@ export class ListSignal<LISTARG extends import("../types/ListArg.mjs").ListArg>
      * @description
      * - usefull for `loops`;
      * @param {LISTARG[]} [value]
+     * @param {ConstructorParameters<typeof Signal<LISTARG[]>>[1]} [performanceChangesReport]
+     * - the argument passed are `structuredClone` of the array;
      * @example
-     * import { ListSignal } from 'vivth';
+     * import { ListSignal } from 'vivth/neutral';
      *
      * const listExample = new ListSignal([
      *      {key1: "test1",},
      *      {key1: "test2",},
      * ]);
      */
-    constructor(value?: LISTARG[]);
+    constructor(value?: LISTARG[], performanceChangesReport?: ConstructorParameters<typeof Signal<LISTARG[]>>[1]);
     /**
      * @description
      * - methods collection that mimics `Array` API;
@@ -39,9 +41,25 @@ export class ListSignal<LISTARG extends import("../types/ListArg.mjs").ListArg>
         /**
          * @instance arrayMethods
          * @description
-         * - reference to structuredClone elements of `value`;
+         * - reference to `structuredClone` elements of `value`;
          * - calling doesn't notify for changes;
          * @returns {Array<LISTARG>}
+         * - use this getter instead of subscribing the `ListSignal` value;
+         * >- as to not accidentally mutate the source value;
+         * @example
+         * import { ListSignal, Derived } from 'vivth/neutral';
+         *
+         * const myListSignal = new ListSignal([
+         * 	{ key:'a', group:0 },
+         * 	{ key:'b', group:1 },
+         * 	{ key:'c', group:0 },
+         * ]);
+         *
+         * const myFilteredListSignal = new Derived(async ({ subscribe }) => {
+         * 	return subscribe(myListSignal).structuredClone.filter((val)=>{
+         * 		// return specific val
+         * 	})
+         * })
          */
         readonly structuredClone: Array<LISTARG>;
         /**
@@ -130,24 +148,40 @@ export class ListSignal<LISTARG extends import("../types/ListArg.mjs").ListArg>
          * @instance arrayMethods
          * @description
          * - reverses the elements in an `List` in place.
-         * @returns {void}
+         * @type {()=>void}
          */
         reverse: () => void;
         /**
          * @instance arrayMethods
          * @description
          * - removes the last element;
-         * @returns {void}
+         * @type {()=>void}
          */
         pop: () => void;
     } & {
-        "vivth:unwrapLazy;": () => {
+        [x: symbol]: {
             /**
              * @instance arrayMethods
              * @description
-             * - reference to structuredClone elements of `value`;
+             * - reference to `structuredClone` elements of `value`;
              * - calling doesn't notify for changes;
              * @returns {Array<LISTARG>}
+             * - use this getter instead of subscribing the `ListSignal` value;
+             * >- as to not accidentally mutate the source value;
+             * @example
+             * import { ListSignal, Derived } from 'vivth/neutral';
+             *
+             * const myListSignal = new ListSignal([
+             * 	{ key:'a', group:0 },
+             * 	{ key:'b', group:1 },
+             * 	{ key:'c', group:0 },
+             * ]);
+             *
+             * const myFilteredListSignal = new Derived(async ({ subscribe }) => {
+             * 	return subscribe(myListSignal).structuredClone.filter((val)=>{
+             * 		// return specific val
+             * 	})
+             * })
              */
             readonly structuredClone: Array<LISTARG>;
             /**
@@ -236,20 +270,20 @@ export class ListSignal<LISTARG extends import("../types/ListArg.mjs").ListArg>
              * @instance arrayMethods
              * @description
              * - reverses the elements in an `List` in place.
-             * @returns {void}
+             * @type {()=>void}
              */
             reverse: () => void;
             /**
              * @instance arrayMethods
              * @description
              * - removes the last element;
-             * @returns {void}
+             * @type {()=>void}
              */
             pop: () => void;
         };
     };
     #private;
 }
-export type ListArg = import("../types/ListArg.mjs").ListArg;
-export type MutationType = import("../types/MutationType.mjs").MutationType;
+export type ListArg = import("../typehints/ListArg.mjs").ListArg;
+export type MutationType = import("../typehints/MutationType.mjs").MutationType;
 import { Signal } from './Signal.mjs';

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

@@ -10,9 +10,9 @@
  * - made primarily for generating string file, that are purely managed programatically;
  * @template {LitExpKeyType} KEYS
  */
-export class LitExp<KEYS extends import("../types/LitExpKeyType.mjs").LitExpKeyType> {
+export class LitExp<KEYS extends import("../typehints/LitExpKeyType.mjs").LitExpKeyType> {
     /**
-     * @typedef {import("../types/LitExpKeyType.mjs").LitExpKeyType} LitExpKeyType
+     * @typedef {import("../typehints/LitExpKeyType.mjs").LitExpKeyType} LitExpKeyType
      */
     /**
      * @description
@@ -50,7 +50,7 @@ export class LitExp<KEYS extends import("../types/LitExpKeyType.mjs").LitExpKeyT
      * - placement of `key` will determine the named capture group will be placed in the template literal;
      * - it is recomended to not end template literal with any of the `key`s as the regex detection might failed to detects the boundary of the end of matched string of that capture group;
      * @example
-     * import { LitExp } from 'vivth';
+     * import { LitExp } from 'vivth/neutral';
      *
      * (()=>{
      * 	const [liteal, errorPrep] = LitExp.prepare({
@@ -66,7 +66,7 @@ export class LitExp<KEYS extends import("../types/LitExpKeyType.mjs").LitExpKeyT
      * 	// recommended to end the template literal with any string but `key`;
      * })()
      */
-    static prepare<KEYS_1 extends import("../types/LitExpKeyType.mjs").LitExpKeyType>(keysAndDefaultValuePair: KEYS_1): ReturnType<typeof TrySync<(templateStringArray: TemplateStringsArray, ...values: (keyof KEYS_1)[]) => LitExp<KEYS_1>>>;
+    static prepare<KEYS_1 extends import("../typehints/LitExpKeyType.mjs").LitExpKeyType>(keysAndDefaultValuePair: KEYS_1): ReturnType<typeof TrySync<(templateStringArray: TemplateStringsArray, ...values: (keyof KEYS_1)[]) => LitExp<KEYS_1>>>;
     /**
      * @template {LitExpKeyType} KEYS
      * @param {KEYS} instance_rules
@@ -75,14 +75,14 @@ export class LitExp<KEYS extends import("../types/LitExpKeyType.mjs").LitExpKeyT
      * @param {TemplateStringsArray} strings
      * @returns {ReturnType<typeof TrySync<string[]>>}
      */
-    static "__#private@#processTemplate"<KEYS_1 extends import("../types/LitExpKeyType.mjs").LitExpKeyType>(instance_rules: KEYS_1, intance_values: (keyof KEYS_1)[], valueHandler: (value: keyof KEYS_1, regex: RegExp | false) => ReturnType<typeof TrySync<string>>, strings: TemplateStringsArray): ReturnType<typeof TrySync<string[]>>;
+    static #processTemplate<KEYS_1 extends import("../typehints/LitExpKeyType.mjs").LitExpKeyType>(instance_rules: KEYS_1, intance_values: (keyof KEYS_1)[], valueHandler: (value: keyof KEYS_1, regex: RegExp | false) => ReturnType<typeof TrySync<string>>, strings: TemplateStringsArray): ReturnType<typeof TrySync<string[]>>;
     /**
      * @template {LitExpKeyType} KEYS
      * @param {RegExp|false} regex
      * @param {keyof KEYS} value
      * @returns {ReturnType<typeof TrySync<string>>}
      */
-    static "__#private@#namedChapture"<KEYS_1 extends import("../types/LitExpKeyType.mjs").LitExpKeyType>(value: keyof KEYS_1, regex: RegExp | false): ReturnType<typeof TrySync<string>>;
+    static #namedChapture<KEYS_1 extends import("../typehints/LitExpKeyType.mjs").LitExpKeyType>(value: keyof KEYS_1, regex: RegExp | false): ReturnType<typeof TrySync<string>>;
     /**
      * @private
      * @param {KEYS} keys
@@ -102,7 +102,7 @@ export class LitExp<KEYS extends import("../types/LitExpKeyType.mjs").LitExpKeyT
          * @param {Partial<{ [K in keyof KEYS]?: string }>} overrides
          * @returns {string|undefined}
          * @example
-         * import { LitExp } from 'vivth';
+         * import { LitExp } from 'vivth/neutral';
          *
          * const [literal, errorPreparing] = LitExp.prepare({
          * 	myKey: false,
@@ -119,7 +119,7 @@ export class LitExp<KEYS extends import("../types/LitExpKeyType.mjs").LitExpKeyT
          */
         string: (overrides: Partial<{ [K in keyof KEYS]?: string; }>) => string | undefined;
     } & {
-        "vivth:unwrapLazy;": () => {
+        [x: symbol]: {
             /**
              * @instance make
              * @description
@@ -127,7 +127,7 @@ export class LitExp<KEYS extends import("../types/LitExpKeyType.mjs").LitExpKeyT
              * @param {Partial<{ [K in keyof KEYS]?: string }>} overrides
              * @returns {string|undefined}
              * @example
-             * import { LitExp } from 'vivth';
+             * import { LitExp } from 'vivth/neutral';
              *
              * const [literal, errorPreparing] = LitExp.prepare({
              * 	myKey: false,
@@ -169,7 +169,7 @@ export class LitExp<KEYS extends import("../types/LitExpKeyType.mjs").LitExpKeyT
          * regexp:RegExp}>>
          * }
          * @example
-         * import { LitExp } from 'vivth';
+         * import { LitExp } from 'vivth/neutral';
          *
          * const [literal, errorPreparing] = LitExp.prepare({
          * 	myKey: false,
@@ -210,10 +210,10 @@ export class LitExp<KEYS extends import("../types/LitExpKeyType.mjs").LitExpKeyT
          * - to match all and grouped based on `key`;
          * @param {Parameters<LitExp<KEYS>["evaluate"]["execGroups"]>[0]} string
          * @param {Omit<Parameters<LitExp<KEYS>["evaluate"]["execGroups"]>[1], 'absoluteLeadAndFollowing'>} options
-         * @returns {ReturnType<typeof TrySync<import('../types/LitExpResultType.mjs').LitExpResultType<KEYS>>>
+         * @returns {ReturnType<typeof TrySync<import('../typehints/LitExpResultType.mjs').LitExpResultType<KEYS>>>
          * }
          * @example
-         * import { LitExp, Console } from 'vivth';
+         * import { LitExp, Console } from 'vivth/neutral';
          *
          * const [literal, errorPreparing] = LitExp.prepare({
          * 	myKey: false,
@@ -246,9 +246,9 @@ export class LitExp<KEYS extends import("../types/LitExpKeyType.mjs").LitExpKeyT
          *	})
          * })()
          */
-        matchedAllAndGrouped: (string: Parameters<LitExp<KEYS>["evaluate"]["execGroups"]>[0], options: Omit<Parameters<LitExp<KEYS>["evaluate"]["execGroups"]>[1], "absoluteLeadAndFollowing">) => ReturnType<typeof TrySync<import("../types/LitExpResultType.mjs").LitExpResultType<KEYS>>>;
+        matchedAllAndGrouped: (string: Parameters<LitExp<KEYS>["evaluate"]["execGroups"]>[0], options: Omit<Parameters<LitExp<KEYS>["evaluate"]["execGroups"]>[1], "absoluteLeadAndFollowing">) => ReturnType<typeof TrySync<import("../typehints/LitExpResultType.mjs").LitExpResultType<KEYS>>>;
     } & {
-        "vivth:unwrapLazy;": () => {
+        [x: symbol]: {
             /**
              * @instance evaluate
              * @description
@@ -268,7 +268,7 @@ export class LitExp<KEYS extends import("../types/LitExpKeyType.mjs").LitExpKeyT
              * regexp:RegExp}>>
              * }
              * @example
-             * import { LitExp } from 'vivth';
+             * import { LitExp } from 'vivth/neutral';
              *
              * const [literal, errorPreparing] = LitExp.prepare({
              * 	myKey: false,
@@ -309,10 +309,10 @@ export class LitExp<KEYS extends import("../types/LitExpKeyType.mjs").LitExpKeyT
              * - to match all and grouped based on `key`;
              * @param {Parameters<LitExp<KEYS>["evaluate"]["execGroups"]>[0]} string
              * @param {Omit<Parameters<LitExp<KEYS>["evaluate"]["execGroups"]>[1], 'absoluteLeadAndFollowing'>} options
-             * @returns {ReturnType<typeof TrySync<import('../types/LitExpResultType.mjs').LitExpResultType<KEYS>>>
+             * @returns {ReturnType<typeof TrySync<import('../typehints/LitExpResultType.mjs').LitExpResultType<KEYS>>>
              * }
              * @example
-             * import { LitExp, Console } from 'vivth';
+             * import { LitExp, Console } from 'vivth/neutral';
              *
              * const [literal, errorPreparing] = LitExp.prepare({
              * 	myKey: false,
@@ -345,7 +345,7 @@ export class LitExp<KEYS extends import("../types/LitExpKeyType.mjs").LitExpKeyT
              *	})
              * })()
              */
-            matchedAllAndGrouped: (string: Parameters<LitExp<KEYS>["evaluate"]["execGroups"]>[0], options: Omit<Parameters<LitExp<KEYS>["evaluate"]["execGroups"]>[1], "absoluteLeadAndFollowing">) => ReturnType<typeof TrySync<import("../types/LitExpResultType.mjs").LitExpResultType<KEYS>>>;
+            matchedAllAndGrouped: (string: Parameters<LitExp<KEYS>["evaluate"]["execGroups"]>[0], options: Omit<Parameters<LitExp<KEYS>["evaluate"]["execGroups"]>[1], "absoluteLeadAndFollowing">) => ReturnType<typeof TrySync<import("../typehints/LitExpResultType.mjs").LitExpResultType<KEYS>>>;
         };
     };
     #private;

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

@@ -0,0 +1,267 @@
+/**
+ * @typedef { import('../typehints/VivthCleanup.mjs').VivthCleanup } VivthCleanup
+ */
+/**
+ * @description
+ * - Signal based on shared/globally available `Object` as key;
+ * @template {any} SHAREDOBJECT
+ * @implements {VivthCleanup}
+ */
+export class ObjectSignal<SHAREDOBJECT extends unknown> implements VivthCleanup {
+    /**
+     * @type {QChannel<Object>}
+     */
+    static #q: QChannel<Object>;
+    /**
+     * @type {WeakMap<Object, ObjectSignal<any>>}
+     */
+    static #mappedSignal: WeakMap<Object, ObjectSignal<any>>;
+    /**
+     * @template {any} SHAREDOBJECT
+     * @param {Object} object
+     * @returns {Promise<ObjectSignal<SHAREDOBJECT>>}
+     */
+    static get<SHAREDOBJECT_1 extends unknown>(object: Object): Promise<ObjectSignal<SHAREDOBJECT_1>>;
+    /**
+     * @description
+     * - methods of this static property is lazily created;
+     * - remove signal and effect subscription of the named `ObjectSignal_instance`;
+     */
+    static remove: {
+        /**
+         * @static remove
+         * @description
+         * - remove subscriber from the named `ObjectSignal_instance`;
+         * @param {string} name
+         * @param {import('./Effect.mjs').Effect} effectInstance
+         * @returns {void}
+         * @example
+         * import { ObjectSignal } from 'vivth/neutral';
+         *
+         * ObjectSignal.remove.subscriber('yourObjectSignalName', myEffectInstance);
+         */
+        subscriber: (name: string, effectInstance: import("./Effect.mjs").Effect) => void;
+        /**
+         * @static remove
+         * @description
+         * - remove all subscribers from the named `ObjectSignal_instance`;
+         * @param {string} name
+         * @returns {void}
+         * @example
+         * import { ObjectSignal } from 'vivth/neutral';
+         *
+         * ObjectSignal.remove.allSubscribers('yourObjectSignalName');
+         */
+        allSubscribers: (name: string) => void;
+        /**
+         * @static remove
+         * @description
+         * - remove reference of the `proxySignals` of the named `ObjectSignal_instance`;
+         * @param {string} name
+         * @returns {void}
+         * @example
+         * import { ObjectSignal } from 'vivth/neutral';
+         *
+         * ObjectSignal.remove.refs('yourObjectSignalName');
+         */
+        refs: (name: string) => void;
+    } & {
+        [x: symbol]: {
+            /**
+             * @static remove
+             * @description
+             * - remove subscriber from the named `ObjectSignal_instance`;
+             * @param {string} name
+             * @param {import('./Effect.mjs').Effect} effectInstance
+             * @returns {void}
+             * @example
+             * import { ObjectSignal } from 'vivth/neutral';
+             *
+             * ObjectSignal.remove.subscriber('yourObjectSignalName', myEffectInstance);
+             */
+            subscriber: (name: string, effectInstance: import("./Effect.mjs").Effect) => void;
+            /**
+             * @static remove
+             * @description
+             * - remove all subscribers from the named `ObjectSignal_instance`;
+             * @param {string} name
+             * @returns {void}
+             * @example
+             * import { ObjectSignal } from 'vivth/neutral';
+             *
+             * ObjectSignal.remove.allSubscribers('yourObjectSignalName');
+             */
+            allSubscribers: (name: string) => void;
+            /**
+             * @static remove
+             * @description
+             * - remove reference of the `proxySignals` of the named `ObjectSignal_instance`;
+             * @param {string} name
+             * @returns {void}
+             * @example
+             * import { ObjectSignal } from 'vivth/neutral';
+             *
+             * ObjectSignal.remove.refs('yourObjectSignalName');
+             */
+            refs: (name: string) => void;
+        };
+    };
+    vivthCleanup: () => Promise<void>;
+    /**
+     * @description
+     * - is [Signal](#signal);
+     * - if needed to pass along the messages, it can be used as `dispatcher` and `listener` at the same time;
+     * - is `lazily` created;
+     * @type {Signal<SHAREDOBJECT|undefined>}
+     * @example
+     * import { ObjectSignal, Effect, Console } from 'vivth/neutral';
+     *
+     * const myObjectSignal = await ObjectSignal.get('dataEvent', false);
+     *
+     * new Effect(({ subscribe })=>{
+     * 	const listenValue = subscribe(myObjectSignal.dispatch).value;
+     * 	// dispatch can be used as two way communication;
+     * 	Console.log({ listenValue });
+     * })
+     * myObjectSignal.dispatch.value = 'hey';
+     */
+    dispatcher: Signal<SHAREDOBJECT | undefined>;
+    /**
+     * @description
+     * - 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<SHAREDOBJECT|undefined>}
+     * @example
+     * import { ObjectSignal, Effect, Console } from 'vivth/neutral';
+     *
+     * const myObjectSignal = await ObjectSignal.get('dataEvent', false);
+     *
+     * new Effect(({ subscribe })=>{
+     * 	const listenValue = subscribe(myObjectSignal.listen).value;
+     * 	// listen can be used only as listener for one way communication;
+     * 	Console.log({ listenValue });
+     * })
+     * myObjectSignal.dispatch.value = 'hey';
+     */
+    listener: Derived<SHAREDOBJECT | undefined>;
+    remove: {
+        /**
+         * @instance remove
+         * @description
+         * - remove subscriber from the `ObjectSignal_instance`;
+         * @param {import('./Effect.mjs').Effect} effectInstance
+         * @returns {void}
+         * @example
+         * import { ObjectSignal, Effect, Console } from 'vivth/neutral';
+         *
+         * const myObjectSignal = await ObjectSignal.get('dataEvent', false);
+         *
+         * const myEffectInstance = new Effect(({ subscribe })=>{
+         * 	const listenValue = subscribe(myObjectSignal.dispatch).value;
+         * 	Console.log({ listenValue });
+         * })
+         * myObjectSignal.dispatch.value = 'hey';
+         * objectSigObjectSignal_instance.remove.subscriber(myEffectInstance);
+         */
+        subscriber: (effectInstance: import("./Effect.mjs").Effect) => void;
+        /**
+         * @instance remove
+         * @description
+         * - remove allSubscribers from the `ObjectSignal_instance`;
+         * @type  {()=>void}
+         * @example
+         * import { ObjectSignal, Effect, Console } from 'vivth/neutral';
+         *
+         * const myObjectSignal = await ObjectSignal.get('dataEvent', false);
+         *
+         * const myEffectInstance = new Effect(({ subscribe })=>{
+         * 	const listenValue = subscribe(myObjectSignal.dispatch).value;
+         * 	Console.log({ listenValue });
+         * })
+         * myObjectSignal.dispatch.value = 'hey';
+         * objectSigObjectSignal_instance.remove.allSubscribers();
+         */
+        allSubscribers: () => void;
+        /**
+         * @instance remove
+         * @description
+         * - remove reference of the `proxySignals` of the `ObjectSignal_instance`;
+         * @type {()=>void}
+         * @example
+         * import { ObjectSignal, Effect, Console } from 'vivth/neutral';
+         *
+         * const myObjectSignal = await ObjectSignal.get('dataEvent', false);
+         *
+         * const myEffectInstance = new Effect(({ subscribe })=>{
+         * 	const listenValue = subscribe(myObjectSignal.dispatch).value;
+         * 	Console.log({ listenValue });
+         * });
+         *
+         * objectSigObjectSignal_instance.remove.ref();
+         */
+        ref: () => void;
+    } & {
+        [x: symbol]: {
+            /**
+             * @instance remove
+             * @description
+             * - remove subscriber from the `ObjectSignal_instance`;
+             * @param {import('./Effect.mjs').Effect} effectInstance
+             * @returns {void}
+             * @example
+             * import { ObjectSignal, Effect, Console } from 'vivth/neutral';
+             *
+             * const myObjectSignal = await ObjectSignal.get('dataEvent', false);
+             *
+             * const myEffectInstance = new Effect(({ subscribe })=>{
+             * 	const listenValue = subscribe(myObjectSignal.dispatch).value;
+             * 	Console.log({ listenValue });
+             * })
+             * myObjectSignal.dispatch.value = 'hey';
+             * objectSigObjectSignal_instance.remove.subscriber(myEffectInstance);
+             */
+            subscriber: (effectInstance: import("./Effect.mjs").Effect) => void;
+            /**
+             * @instance remove
+             * @description
+             * - remove allSubscribers from the `ObjectSignal_instance`;
+             * @type  {()=>void}
+             * @example
+             * import { ObjectSignal, Effect, Console } from 'vivth/neutral';
+             *
+             * const myObjectSignal = await ObjectSignal.get('dataEvent', false);
+             *
+             * const myEffectInstance = new Effect(({ subscribe })=>{
+             * 	const listenValue = subscribe(myObjectSignal.dispatch).value;
+             * 	Console.log({ listenValue });
+             * })
+             * myObjectSignal.dispatch.value = 'hey';
+             * objectSigObjectSignal_instance.remove.allSubscribers();
+             */
+            allSubscribers: () => void;
+            /**
+             * @instance remove
+             * @description
+             * - remove reference of the `proxySignals` of the `ObjectSignal_instance`;
+             * @type {()=>void}
+             * @example
+             * import { ObjectSignal, Effect, Console } from 'vivth/neutral';
+             *
+             * const myObjectSignal = await ObjectSignal.get('dataEvent', false);
+             *
+             * const myEffectInstance = new Effect(({ subscribe })=>{
+             * 	const listenValue = subscribe(myObjectSignal.dispatch).value;
+             * 	Console.log({ listenValue });
+             * });
+             *
+             * objectSigObjectSignal_instance.remove.ref();
+             */
+            ref: () => void;
+        };
+    };
+}
+export type VivthCleanup = import("../typehints/VivthCleanup.mjs").VivthCleanup;
+import { Signal } from './Signal.mjs';
+import { Derived } from './Derived.mjs';
+import { QChannel } from './QChannel.mjs';