vivth 1.4.9 → 1.5.0

package/src/class/ListSignal.mjs

@@ -1,17 +1,19 @@
 // @ts-check
 
+import { IsTypeOf } from '../function/IsTypeOf.mjs';
 import { LazyFactory } from '../function/LazyFactory.mjs';
 import { Console } from './Console.mjs';
+import { DataLog } from './DataLog.mjs';
 import { Signal } from './Signal.mjs';
 
 /**
- * @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 extends Signal {
@@ -23,7 +25,7 @@ export class ListSignal extends Signal {
 	 * @returns {value is Array<Record<string, string>>} True if the first item is a valid string record or array is empty.
 	 */
 	static isValid(value) {
-		if (Array.isArray(value) === false) {
+		if (!Array.isArray(value)) {
 			return false;
 		}
 		const first = value[0];
@@ -33,10 +35,10 @@ export class ListSignal extends Signal {
 		}
 		return (
 			first &&
-			typeof first === 'object' &&
+			IsTypeOf(first, 'object') &&
 			!Array.isArray(first) &&
 			Object.entries(first).every(
-				([key, val]) => typeof key === 'string' && typeof val === 'string'
+				([key, val]) => IsTypeOf(key, 'string') && IsTypeOf(val, 'string'),
 			)
 		);
 	}
@@ -44,17 +46,24 @@ export class ListSignal extends Signal {
 	 * @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 = []) {
+	constructor(value = [], performanceChangesReport = undefined) {
 		super(value);
+		this.#performanceChangesReport = performanceChangesReport;
 	}
+	/**
+	 * @type {ConstructorParameters<typeof Signal<LISTARG[]>>[1]}
+	 */
+	#performanceChangesReport;
 	/**
 	 * @description
 	 * - reference to original inputed `value`;
@@ -74,6 +83,26 @@ export class ListSignal extends Signal {
 	set value(_) {
 		Console.error('`List.value` `setter` are not available outside the class or instance');
 	}
+	/**
+	 * @description
+	 * - structuredClone of prev
+	 * @type {LISTARG[]|undefined}
+	 * @override
+	 */
+	get prev() {
+		return structuredClone(super.prev);
+	}
+	/**
+	 * @type {()=>void}
+	 */
+	#notifyWithPerformanceChangesReport = () => {
+		this.subscribers.notify(async () => {
+			if (!this.#performanceChangesReport) {
+				return;
+			}
+			this.#performanceChangesReport(new DataLog(this.arrayMethods.structuredClone));
+		});
+	};
 	/**
 	 * @description
 	 * - methods collection that mimics `Array` API;
@@ -84,9 +113,25 @@ export class ListSignal extends Signal {
 			/**
 			 * @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
+			 * 	})
+			 * })
 			 */
 			get structuredClone() {
 				return structuredClone(super.value);
@@ -100,7 +145,7 @@ export class ListSignal extends Signal {
 			 */
 			push: (...listArg) => {
 				super.value.push(...listArg);
-				this.subscribers.notify();
+				this.#notifyWithPerformanceChangesReport();
 			},
 			/**
 			 * @instance arrayMethods
@@ -110,7 +155,7 @@ export class ListSignal extends Signal {
 			 */
 			shift: () => {
 				super.value.shift();
-				this.subscribers.notify();
+				this.#notifyWithPerformanceChangesReport();
 			},
 			/**
 			 * @instance arrayMethods
@@ -121,7 +166,7 @@ export class ListSignal extends Signal {
 			 */
 			unshift: (...listArg) => {
 				super.value.unshift(...listArg);
-				this.subscribers.notify();
+				this.#notifyWithPerformanceChangesReport();
 			},
 			/**
 			 * @instance arrayMethods
@@ -162,11 +207,11 @@ export class ListSignal extends Signal {
 			 */
 			splice: (start, deleteCount, ...listArg) => {
 				const end = start + deleteCount - 1;
-				if (this.#checkLength('splice', end) === false) {
+				if (!this.#checkLength('splice', end)) {
 					return;
 				}
 				super.value.splice(start, deleteCount, ...listArg);
-				this.subscribers.notify();
+				this.#notifyWithPerformanceChangesReport();
 			},
 			/**
 			 * @instance arrayMethods
@@ -177,15 +222,12 @@ export class ListSignal extends Signal {
 			 * @returns {void}
 			 */
 			swap: (indexA, indexB) => {
-				if (
-					this.#checkLength('swap', indexA) === false ||
-					this.#checkLength('swap', indexB) === false
-				) {
+				if (!this.#checkLength('swap', indexA) || !this.#checkLength('swap', indexB)) {
 					return;
 				}
 				// @ts-expect-error
 				[super.value[indexA], super.value[indexB]] = [super.value[indexB], super.value[indexA]];
-				this.subscribers.notify();
+				this.#notifyWithPerformanceChangesReport();
 			},
 			/**
 			 * @instance arrayMethods
@@ -196,7 +238,7 @@ export class ListSignal extends Signal {
 			 * @returns {void}
 			 */
 			modify: (index, listArg) => {
-				if (this.#checkLength('modify', index) === false) {
+				if (!this.#checkLength('modify', index)) {
 					return;
 				}
 				for (const key in listArg) {
@@ -206,7 +248,7 @@ export class ListSignal extends Signal {
 						super.value[index][key] = listArgKey;
 					}
 				}
-				this.subscribers.notify();
+				this.#notifyWithPerformanceChangesReport();
 			},
 			/**
 			 * @instance arrayMethods
@@ -216,7 +258,7 @@ export class ListSignal extends Signal {
 			 * @returns {void}
 			 */
 			remove: (index) => {
-				if (this.#checkLength('remove', index) === false) {
+				if (!this.#checkLength('remove', index)) {
 					return;
 				}
 				this.arrayMethods.splice(index, 1);
@@ -225,21 +267,21 @@ export class ListSignal extends Signal {
 			 * @instance arrayMethods
 			 * @description
 			 * - reverses the elements in an `List` in place.
-			 * @returns {void}
+			 * @type {()=>void}
 			 */
 			reverse: () => {
 				super.value.reverse();
-				this.subscribers.notify();
+				this.#notifyWithPerformanceChangesReport();
 			},
 			/**
 			 * @instance arrayMethods
 			 * @description
 			 * - removes the last element;
-			 * @returns {void}
+			 * @type {()=>void}
 			 */
 			pop: () => {
 				super.value.pop();
-				this.subscribers.notify();
+				this.#notifyWithPerformanceChangesReport();
 			},
 		};
 	});

package/src/class/LitExp.mjs

@@ -2,6 +2,7 @@
 
 import { LazyFactory } from '../function/LazyFactory.mjs';
 import { TrySync } from '../function/TrySync.mjs';
+import { Console } from './Console.mjs';
 
 /**
  * @description
@@ -17,7 +18,7 @@ import { TrySync } from '../function/TrySync.mjs';
  */
 export class LitExp {
 	/**
-	 * @typedef {import("../types/LitExpKeyType.mjs").LitExpKeyType} LitExpKeyType
+	 * @typedef {import("../typehints/LitExpKeyType.mjs").LitExpKeyType} LitExpKeyType
 	 */
 
 	/**
@@ -58,7 +59,7 @@ export class LitExp {
 	 * - 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({
@@ -77,6 +78,12 @@ export class LitExp {
 	static prepare(keysAndDefaultValuePair) {
 		return TrySync(() => {
 			for (const key in keysAndDefaultValuePair) {
+				if (
+					!Object.hasOwn(keysAndDefaultValuePair, key) ||
+					keysAndDefaultValuePair[key] === undefined
+				) {
+					continue;
+				}
 				const regex = keysAndDefaultValuePair[key];
 				const capture = !regex ? `[\\s\\S]*?` : regex.source;
 				if (capture.match(/\(\<\w+\>[\s\S]*?\)/g)) {
@@ -129,11 +136,9 @@ export class LitExp {
 			for (let i = 0; i < stringsLength; i++) {
 				const string = strings[i];
 				if (string === undefined) {
-					throw new Error('string undefined');
+					throw 'string undefined';
 				}
-				if (i + 1 == stringsLength && string === '') {
-					result.push('(?:\\s+?|;|,|$|\/\/)');
-				} else {
+				if (i + 1 !== stringsLength || string !== '') {
 					result.push(LitExp.escape(string));
 				}
 				if (i < values.length) {
@@ -159,29 +164,39 @@ export class LitExp {
 	#regExp = ({ flags, whiteSpaceSensitive, absoluteLeadAndFollowing }) => {
 		return TrySync(() => {
 			let regExpStringCache;
-			if (this.#regExpStringCache === undefined) {
+			if (
+				/** */
+				this.#regExpStringCache === undefined
+			) {
 				const [regExpStringCache, error] = LitExp.#processTemplate(
 					this.#keyRules,
 					this.#values,
 					LitExp.#namedChapture,
-					this.#templateStringArray
+					this.#templateStringArray,
 				);
-				if (error) {
+				if (
+					/** */
+					error
+				) {
 					throw error;
 				}
 				this.#regExpStringCache = regExpStringCache.join('');
 			}
-			if (whiteSpaceSensitive) {
+			if (
+				/** */
+				whiteSpaceSensitive
+			) {
 				regExpStringCache = this.#regExpStringCache;
 			} else {
 				regExpStringCache = this.#regExpStringCache.replace(/\s+/g, `\\s+`);
 			}
 			return new RegExp(
 				absoluteLeadAndFollowing ? `\^${regExpStringCache}\$` : regExpStringCache,
-				flags
+				flags,
 			);
 		});
 	};
+
 	/**
 	 * @param {Parameters<LitExp<KEYS>["evaluate"]["matchedAllAndGrouped"]>[1]} options
 	 * @returns {ReturnType<typeof TrySync<RegExp>>}
@@ -189,19 +204,29 @@ export class LitExp {
 	#regexToMatchAll = ({ flags, whiteSpaceSensitive }) => {
 		return TrySync(() => {
 			let regExpToMatchStringCache;
-			if (this.#regExpToMatchStringCache === undefined) {
+			if (
+				/** */
+				this.#regExpToMatchStringCache === undefined
+			) {
 				const [regExpToMatchStringCache, error] = LitExp.#processTemplate(
 					this.#keyRules,
 					this.#values,
 					LitExp.#namedChapture,
-					this.#templateStringArray
+					this.#templateStringArray,
 				);
-				if (error || regExpToMatchStringCache === undefined) {
+				if (
+					/** */
+					error ||
+					regExpToMatchStringCache === undefined
+				) {
 					throw error;
 				}
 				this.#regExpToMatchStringCache = regExpToMatchStringCache.join('');
 			}
-			if (whiteSpaceSensitive) {
+			if (
+				/** */
+				whiteSpaceSensitive
+			) {
 				regExpToMatchStringCache = this.#regExpToMatchStringCache;
 			} else {
 				regExpToMatchStringCache = this.#regExpToMatchStringCache.replace(/\s+/g, `\\s+`);
@@ -223,7 +248,7 @@ export class LitExp {
 			 * @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,
@@ -249,7 +274,7 @@ export class LitExp {
 								return overrides[key];
 							});
 						},
-						this_.#templateStringArray
+						this_.#templateStringArray,
 					);
 					if (error) {
 						throw error;
@@ -271,7 +296,7 @@ export class LitExp {
 	 */
 	static #namedChapture(value, regex) {
 		return TrySync(() => {
-			const capture = regex === false ? `[\\s\\S]*?` : regex.source;
+			const capture = !regex ? `[\\s\\S]*?` : regex.source;
 			return `(?<${value.toString()}>${capture})`;
 		});
 	}
@@ -305,7 +330,7 @@ export class LitExp {
 			 * regexp:RegExp}>>
 			 * }
 			 * @example
-			 * import { LitExp } from 'vivth';
+			 * import { LitExp } from 'vivth/neutral';
 			 *
 			 * const [literal, errorPreparing] = LitExp.prepare({
 			 * 	myKey: false,
@@ -338,19 +363,19 @@ export class LitExp {
 					}
 					const execResult = regexp.exec(string);
 					if (execResult === null) {
-						return undefined;
+						const error = { string, regexp, message: 'execResult should not be null', execResult };
+						Console.error(error);
+						throw error;
 					}
 					const whole = execResult[1];
 					const named = execResult?.groups;
 					const result = { named, whole };
 					if (named === undefined) {
-						throw new Error(
-							JSON.stringify({
-								regexpSource: regexp.source,
-								message: 'no match is found',
-								sugestion: 'make sure all `keys` values will capture any scenario',
-							})
-						);
+						throw JSON.stringify({
+							regexpSource: regexp.source,
+							message: 'no match is found',
+							sugestion: 'make sure all `keys` values will capture any scenario',
+						});
 					}
 					return { result, regexp };
 				});
@@ -361,10 +386,10 @@ export class LitExp {
 			 * - 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,
@@ -418,13 +443,11 @@ export class LitExp {
 					const matchedAll = string.matchAll(regexp);
 					for (const match of matchedAll) {
 						if (match.groups === undefined) {
-							throw new Error(
-								JSON.stringify({
-									regexpSource: regexp.source,
-									message: 'no match is found',
-									sugestion: 'make sure all `keys` values will capture any scenario',
-								})
-							);
+							throw JSON.stringify({
+								regexpSource: regexp.source,
+								message: 'no match is found',
+								sugestion: 'make sure all `keys` values will capture any scenario',
+							});
 						}
 						whole.push(match[1] ?? '');
 						// @ts-expect-error

package/src/class/ObjectSignal.mjs

@@ -0,0 +1,225 @@
+// @ts-check
+
+import { LazyFactory } from '../function/LazyFactory.mjs';
+import { Derived } from './Derived.mjs';
+import { QChannel } from './QChannel.mjs';
+import { Signal } from './Signal.mjs';
+
+/**
+ * @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 {
+	vivthCleanup = async () => {
+		this.remove.ref();
+	};
+	/**
+	 * @type {QChannel<Object>}
+	 */
+	static #q = LazyFactory(() => new QChannel('ObjectSignal:q'));
+	/**
+	 * @type {WeakMap<Object, ObjectSignal<any>>}
+	 */
+	static #mappedSignal = new WeakMap();
+	/**
+	 * @template {any} SHAREDOBJECT
+	 * @param {Object} object
+	 * @returns {Promise<ObjectSignal<SHAREDOBJECT>>}
+	 */
+	static async get(object) {
+		const mapped = ObjectSignal.#mappedSignal;
+		const { resume } = await ObjectSignal.#q.key(object);
+		if (!mapped.has(object)) {
+			mapped.set(object, new ObjectSignal());
+		}
+		resume();
+		// @ts-expect-error
+		return mapped.get(object);
+	}
+	/**
+	 * @private
+	 */
+	constructor() {}
+	/**
+	 * @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';
+	 */
+	// @ts-expect-error
+	dispatcher = LazyFactory(() => {
+		return new Signal(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 = LazyFactory(() => {
+		const dispatch = this.dispatcher;
+		return new Derived(async ({ subscribe }) => {
+			return subscribe(dispatch).value;
+		});
+	});
+	/**
+	 * @description
+	 * - methods of this static property is lazily created;
+	 * - remove signal and effect subscription of the named `ObjectSignal_instance`;
+	 */
+	static remove = LazyFactory(() => ({
+		/**
+		 * @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, effectInstance) => {
+			/**
+			 * this part is not needed, as the effect might need to react to other signals
+			// effectInstance.options.removeEffect();
+			 */
+			ObjectSignal.get(name).then(({ remove }) => {
+				remove.subscriber(effectInstance);
+			});
+		},
+		/**
+		 * @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) => {
+			ObjectSignal.get(name).then(({ remove }) => {
+				remove.allSubscribers();
+			});
+		},
+		/**
+		 * @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) => {
+			ObjectSignal.get(name).then(({ remove }) => {
+				remove.ref();
+			});
+		},
+	}));
+	remove = LazyFactory(() => ({
+		/**
+		 * @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) => {
+			/**
+			 * this part is not needed, as the effect might need to react to other signals
+			// effectInstance.options.removeEffect();
+			 */
+			this.dispatcher.remove.subscriber(effectInstance);
+			this.listener.remove.subscriber(effectInstance);
+		},
+		/**
+		 * @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: () => {
+			this.dispatcher.remove.allSubscribers();
+			this.listener.remove.allSubscribers();
+		},
+		/**
+		 * @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: () => {
+			this.dispatcher.remove.ref();
+			this.listener.remove.ref();
+		},
+	}));
+}