@oscarpalmer/mora 0.38.0 → 0.39.0

package/src/value/array.ts

@@ -1,20 +1,23 @@
 import {filter} from '@oscarpalmer/atoms/array/filter';
 import {select} from '@oscarpalmer/atoms/array/select';
 import {
+	MESSAGE_DEACTIVATED_ARRAY_FILTER,
+	MESSAGE_DEACTIVATED_ARRAY_MAP,
+	MESSAGE_DEACTIVATED_ARRAY_SELECT,
 	METHODS_AFFECTING_LENGTH,
 	METHODS_UPDATE,
 	NAME_ARRAY,
-	NAME_MORA,
 	PROPERTY_LENGTH,
 	SYMBOL_STATE,
 } from '../constants';
-import {getState} from '../helpers/misc';
+import {deactivateProxy, getReactiveActive, getState} from '../helpers/misc';
 import {
 	getValueInProxy,
 	notifyProxyValue,
 	peekValueInProxy,
 	setProxyValue,
 	setValueInProxy,
+	updateProxyDerivations,
 	updateProxyValue,
 } from '../helpers/proxy';
 import {subscribeToProxy} from '../helpers/subscription';
@@ -28,7 +31,7 @@ import {signal} from './signal';
 
 function ReactiveArray(this: any, value: unknown, options?: ReactiveOptions<unknown>): void {
 	this[SYMBOL_STATE] = {
-		...getState(undefined, options),
+		...getState(NAME_ARRAY, undefined, options),
 		isArray: true,
 		length: signal(0),
 	};
@@ -44,17 +47,10 @@ function ReactiveArray(this: any, value: unknown, options?: ReactiveOptions<unkn
 	setProxyValue.call(this, value);
 }
 
-ReactiveArray.prototype[NAME_MORA] = NAME_ARRAY;
-
-Object.defineProperty(ReactiveArray.prototype, PROPERTY_LENGTH, {
-	enumerable: true,
-	get: getArrayLength,
-	set: setArrayLength,
-});
-
 ReactiveArray.prototype.asReadonly = getReadonlySignal;
 ReactiveArray.prototype.at = getArrayValues;
 ReactiveArray.prototype.clear = clearArrayValues;
+ReactiveArray.prototype.deactivate = deactivateArray;
 ReactiveArray.prototype.filter = filterArrayValues;
 ReactiveArray.prototype.get = getArrayValues;
 ReactiveArray.prototype.map = mapArrayValues;
@@ -72,6 +68,18 @@ ReactiveArray.prototype.toJSON = getJsonValue;
 ReactiveArray.prototype.unshift = unshiftArrayValues;
 ReactiveArray.prototype.update = updateProxyValue;
 
+Object.defineProperties(ReactiveArray.prototype, {
+	[PROPERTY_LENGTH]: {
+		enumerable: true,
+		get: getArrayLength,
+		set: setArrayLength,
+	},
+	active: {
+		enumerable: true,
+		get: getReactiveActive,
+	},
+});
+
 // #endregion
 
 // #region Functions
@@ -115,11 +123,34 @@ export function array(value: unknown, options?: ReactiveOptions<unknown>): React
 }
 
 function clearArrayValues(this: InternalArray): void {
-	(this[SYMBOL_STATE].value as unknown[]).length = 0;
+	const state = this[SYMBOL_STATE];
+
+	if (state.active) {
+		(state.value as unknown[]).length = 0;
+	}
+}
+
+function deactivateArray(this: InternalArray): void {
+	const state = this[SYMBOL_STATE];
+
+	if (!state.active) {
+		return;
+	}
+
+	state.length?.deactivate?.();
+
+	deactivateProxy.call(this);
 }
 
 function filterArrayValues(this: InternalArray, callback: never): Computed<unknown[]> {
-	return computed(() => filter(getArrayValues.call(this) as never, callback) as never);
+	if (!this[SYMBOL_STATE].active) {
+		throw new Error(MESSAGE_DEACTIVATED_ARRAY_FILTER);
+	}
+
+	return updateProxyDerivations(
+		this,
+		computed(() => filter(getArrayValues.call(this) as never, callback) as never),
+	);
 }
 
 function getArrayLength(this: InternalArray): number {
@@ -132,8 +163,22 @@ function getArrayValues(this: InternalArray, value?: unknown): unknown {
 		: getValueInProxy.call(this, value);
 }
 
-function mapArrayValues(this: InternalArray, callback: never): Computed<unknown[]> {
-	return computed(() => (getArrayValues.call(this) as unknown[]).map(callback));
+function mapArrayValues(
+	this: InternalArray,
+	callback: (item: unknown, index: number, array: unknown[]) => unknown,
+): Computed<unknown[]> {
+	if (!this[SYMBOL_STATE].active) {
+		throw new Error(MESSAGE_DEACTIVATED_ARRAY_MAP);
+	}
+
+	return updateProxyDerivations(
+		this,
+		computed(() =>
+			(getArrayValues.call(this) as unknown[]).map((item, index, array) =>
+				callback(item, index, array),
+			),
+		),
+	);
 }
 
 function peekArrayValue(this: InternalArray, first?: unknown, second?: boolean): unknown {
@@ -143,19 +188,37 @@ function peekArrayValue(this: InternalArray, first?: unknown, second?: boolean):
 }
 
 function popArrayValue(this: InternalArray): unknown {
-	return (this[SYMBOL_STATE].value as unknown[]).pop();
+	const state = this[SYMBOL_STATE];
+
+	return state.active ? (state.value as unknown[]).pop() : undefined;
 }
 
 function pushArrayValues(this: InternalArray, ...items: unknown[]): number {
-	return (this[SYMBOL_STATE].value as unknown[]).push(...items);
+	const state = this[SYMBOL_STATE];
+
+	return state.active
+		? (state.value as unknown[]).push(...items)
+		: (state.value as unknown[]).length;
 }
 
 function selectArrayValues(this: InternalArray, filter: never, map: never): Computed<unknown[]> {
-	return computed(() => select(getArrayValues.call(this) as unknown[], filter, map));
+	if (!this[SYMBOL_STATE].active) {
+		throw new Error(MESSAGE_DEACTIVATED_ARRAY_SELECT);
+	}
+
+	return updateProxyDerivations(
+		this,
+		computed(() => select(getArrayValues.call(this) as unknown[], filter, map)),
+	);
 }
 
 function setArrayLength(this: InternalArray, value: number): void {
 	const state = this[SYMBOL_STATE];
+
+	if (!state.active) {
+		return;
+	}
+
 	const values = state.value as unknown[];
 
 	if (typeof value === 'number' && !Number.isNaN(value) && value >= 0 && value !== values.length) {
@@ -164,7 +227,9 @@ function setArrayLength(this: InternalArray, value: number): void {
 }
 
 function shiftArrayValue(this: InternalArray): unknown {
-	return (this[SYMBOL_STATE].value as unknown[]).shift();
+	const state = this[SYMBOL_STATE];
+
+	return state.active ? (state.value as unknown[]).shift() : undefined;
 }
 
 function spliceArrayValues(
@@ -173,18 +238,32 @@ function spliceArrayValues(
 	to?: never,
 	...items: unknown[]
 ): unknown[] {
-	const values = this[SYMBOL_STATE].value as unknown[];
+	const state = this[SYMBOL_STATE];
+
+	if (!state.active) {
+		return [];
+	}
+
+	const values = state.value as unknown[];
 
 	return values.splice(from, to ?? values.length, ...items);
 }
 
 function unshiftArrayValues(this: InternalArray, ...items: unknown[]): number {
-	return (this[SYMBOL_STATE].value as unknown[]).unshift(...items);
+	const state = this[SYMBOL_STATE];
+
+	return state.active
+		? (state.value as unknown[]).unshift(...items)
+		: (state.value as unknown[]).length;
 }
 
 function updateArray(instance: InternalArray, type: string | symbol, array: unknown[]): unknown {
 	const state = instance[SYMBOL_STATE];
 
+	if (!state.active) {
+		return () => undefined;
+	}
+
 	const affectsLength = METHODS_AFFECTING_LENGTH.has(type);
 	const previousArray = affectsLength ? [] : array.slice();
 	const previousLength = array.length;

package/src/value/computed.ts

@@ -3,8 +3,8 @@ import {flushHandlers} from '../batch';
 import {
 	ACTIVE,
 	BATCH,
+	MESSAGE_COMPUTED_CALLBACK,
 	NAME_COMPUTED,
-	NAME_MORA,
 	SUBSCRIPTION_TYPE_FROZEN,
 	SUBSCRIPTION_TYPES,
 	SUBSCRIPTION_TYPES_COPY,
@@ -12,7 +12,7 @@ import {
 	SYMBOL_STATE,
 } from '../constants';
 import {internalEffect, runEffect} from '../effect';
-import {getState} from '../helpers/misc';
+import {deactivateComputed, getReactiveActive, getState} from '../helpers/misc';
 import {subscribeToSignal} from '../helpers/subscription';
 import {getJsonValue, getStringValue, handleSignal, peekSignalValue} from '../helpers/value';
 import type {
@@ -26,18 +26,24 @@ import type {
 // #region Instance
 
 function Computed(this: any, callback: GenericCallback, options?: ReactiveOptions<unknown>): void {
-	this[SYMBOL_STATE] = getState(undefined, options);
+	this[SYMBOL_STATE] = getState(NAME_COMPUTED, undefined, options);
 	this[SYMBOL_EFFECT] = getComputedEffect(this, callback);
 }
 
-Computed.prototype[NAME_MORA] = NAME_COMPUTED;
-
+Computed.prototype.deactivate = deactivateComputed;
 Computed.prototype.get = getComputedValue;
 Computed.prototype.peek = peekSignalValue;
 Computed.prototype.subscribe = subscribeToSignal;
 Computed.prototype.toJSON = getJsonValue;
 Computed.prototype.toString = getStringValue;
 
+Object.defineProperties(Computed.prototype, {
+	active: {
+		enumerable: true,
+		get: getReactiveActive,
+	},
+});
+
 // #endregion
 
 // #region Functions
@@ -61,7 +67,7 @@ function getComputed<Value>(
 	options?: ReactiveOptions<Value>,
 ): InternalComputed {
 	if (typeof callback !== 'function') {
-		throw new TypeError('Computed callback must be a function');
+		throw new TypeError(MESSAGE_COMPUTED_CALLBACK);
 	}
 
 	// @ts-expect-error All good, no worries :-)
@@ -104,9 +110,14 @@ function getComputedEffect(
 }
 
 function getComputedValue(this: InternalComputed): unknown {
-	const fx = this[SYMBOL_EFFECT];
 	const state = this[SYMBOL_STATE];
 
+	if (!state.active) {
+		return state.value;
+	}
+
+	const fx = this[SYMBOL_EFFECT];
+
 	if (ACTIVE.computed != null && fx !== ACTIVE.computed) {
 		state.computeds ??= new Set();
 
@@ -136,7 +147,7 @@ export function internalComputed(
 function setAndEmit(instance: InternalStateful, value: unknown, notify: boolean): void {
 	const state = instance[SYMBOL_STATE];
 
-	if (!notify && (state.equal ?? Object.is)(state.value, value)) {
+	if (!state.active || (!notify && (state.equal ?? Object.is)(state.value, value))) {
 		return;
 	}
 
@@ -144,13 +155,21 @@ function setAndEmit(instance: InternalStateful, value: unknown, notify: boolean)
 
 	if (state.computeds != null && state.computeds.size > 0) {
 		for (const computed of state.computeds) {
-			computed.dirty = true;
+			if (computed.instance.active) {
+				computed.dirty = true;
+			} else {
+				state.computeds.delete(computed);
+			}
 		}
 	}
 
 	if (state.effects != null && state.effects.size > 0) {
 		for (const effect of state.effects) {
-			BATCH.handlers.set(effect, effect);
+			if (effect.active) {
+				BATCH.handlers.set(effect, effect);
+			} else {
+				state.effects.delete(effect);
+			}
 		}
 	}
 

package/src/value/readonly.ts

@@ -1,10 +1,11 @@
 import {
-	NAME_MORA,
-	NAME_READONLY,
+	MESSAGE_DEACTIVATED_READONLY,
 	SUBSCRIPTION_TYPE_FROZEN,
 	SUBSCRIPTION_TYPE_ORIGINAL,
+	SYMBOL_READONLY,
 	SYMBOL_STATE,
 } from '../constants';
+import {deactivateReadonly, getReadonlyActive} from '../helpers/misc';
 import {subscribeToReadonly} from '../helpers/subscription';
 import {
 	getFrozenValue,
@@ -13,61 +14,63 @@ import {
 	getStringValue,
 	peekSignalValue,
 } from '../helpers/value';
-import type {InternalSignal, ReadonlyFrozenSignal, ReadonlySignal, SignalState} from '../models';
-
-// #region Types
-
-type InternalReadonly = {
-	[SUBSCRIPTION_TYPE_FROZEN]: boolean;
-} & InternalSignal;
-
-// #endregion
+import type {InternalReadonly, InternalSignal, ReadonlySignal, SignalState} from '../models';
 
 // #region Instance
 
-function Readonly(this: any, state: SignalState, frozen: boolean): void {
-	this[SUBSCRIPTION_TYPE_FROZEN] = frozen;
+function Readonly(this: InternalReadonly, state: SignalState, frozen: boolean): void {
 	this[SYMBOL_STATE] = state;
-}
 
-Readonly.prototype[NAME_MORA] = NAME_READONLY;
+	this[SYMBOL_READONLY] = {
+		active: true,
+		name: frozen ? SUBSCRIPTION_TYPE_FROZEN : SUBSCRIPTION_TYPE_ORIGINAL,
+	};
 
+	Object.defineProperty(this, SUBSCRIPTION_TYPE_FROZEN, {
+		value: frozen,
+	});
+}
+
+Readonly.prototype.deactivate = deactivateReadonly;
 Readonly.prototype.get = getReadonlyValue;
 Readonly.prototype.peek = peekReadonlyValue;
 Readonly.prototype.subscribe = subscribeToReadonly;
 Readonly.prototype.toJSON = getJsonValue;
 Readonly.prototype.toString = getStringValue;
 
+Object.defineProperties(Readonly.prototype, {
+	active: {
+		enumerable: true,
+		get: getReadonlyActive,
+	},
+});
+
 // #endregion
 
 // #region Functions
 
-export function getReadonlyInstance(
-	state: SignalState,
-	frozen: boolean,
-): ReadonlySignal<unknown> | ReadonlyFrozenSignal<unknown> {
-	// @ts-expect-error All good, no worries :-)
-	return new Readonly(state, frozen);
-}
-
 export function getReadonlySignal<Value>(
 	this: InternalSignal,
 	frozen?: never,
 ): ReadonlySignal<Value> {
+	const state = this[SYMBOL_STATE];
+
+	if (!state.active) {
+		throw new Error(MESSAGE_DEACTIVATED_READONLY);
+	}
+
 	const key = (frozen === true ? SUBSCRIPTION_TYPE_FROZEN : SUBSCRIPTION_TYPE_ORIGINAL) as never;
 
-	this[SYMBOL_STATE].readonlies ??= {};
+	state.readonlies ??= {};
 
-	this[SYMBOL_STATE].readonlies[key] ??= getReadonlyInstance(
-		this[SYMBOL_STATE],
-		frozen === true,
-	) as never;
+	// @ts-expect-error All good, no worries :-)
+	state.readonlies[key] ??= new Readonly(state, frozen === true);
 
-	return this[SYMBOL_STATE].readonlies[key] as never;
+	return state.readonlies[key] as never;
 }
 
 function getReadonlyValue(this: InternalReadonly) {
-	return handleReadonlyValue(this, false, this[SUBSCRIPTION_TYPE_FROZEN]);
+	return handleReadonlyValue(this, false, this.frozen);
 }
 
 function handleReadonlyValue(
@@ -76,19 +79,21 @@ function handleReadonlyValue(
 	frozen: boolean,
 	copy?: boolean,
 ): unknown {
+	const state = instance[SYMBOL_READONLY];
+
 	let value: unknown;
 
 	if (peek) {
-		value = peekSignalValue.call(instance, copy === true);
+		value = peekSignalValue.call(state.active ? instance : [instance, state.value], copy === true);
 	} else {
-		value = getSignalValue.call(instance);
+		value = state.active ? getSignalValue.call(instance) : state.value;
 	}
 
 	return frozen ? getFrozenValue(value) : value;
 }
 
 function peekReadonlyValue(this: InternalReadonly, copy?: boolean) {
-	return handleReadonlyValue(this, true, this[SUBSCRIPTION_TYPE_FROZEN], copy);
+	return handleReadonlyValue(this, true, this.frozen, copy);
 }
 
 // #endregion

package/src/value/signal.ts

@@ -1,5 +1,5 @@
-import {NAME_MORA, NAME_SIGNAL, SYMBOL_STATE} from '../constants';
-import {getState} from '../helpers/misc';
+import {NAME_SIGNAL, SYMBOL_STATE} from '../constants';
+import {deactivateReactive, getReactiveActive, getState} from '../helpers/misc';
 import {subscribeToSignal} from '../helpers/subscription';
 import {
 	emitValue,
@@ -16,14 +16,13 @@ import {getReadonlySignal} from './readonly';
 // #region Instance
 
 function Signal(this: any, value: unknown, options?: ReactiveOptions<unknown>): void {
-	this[SYMBOL_STATE] = getState(undefined, options);
+	this[SYMBOL_STATE] = getState(NAME_SIGNAL, undefined, options);
 
 	handleSignal(this, value, setAndEmit);
 }
 
-Signal.prototype[NAME_MORA] = NAME_SIGNAL;
-
 Signal.prototype.asReadonly = getReadonlySignal;
+Signal.prototype.deactivate = deactivateReactive;
 Signal.prototype.get = getSignalValue;
 Signal.prototype.peek = peekSignalValue;
 Signal.prototype.set = setSignalValue;
@@ -32,6 +31,13 @@ Signal.prototype.toString = getStringValue;
 Signal.prototype.toJSON = getJsonValue;
 Signal.prototype.update = updateSignalValue;
 
+Object.defineProperties(Signal.prototype, {
+	active: {
+		enumerable: true,
+		get: getReactiveActive,
+	},
+});
+
 // #endregion
 
 // #region Functions

package/src/value/store.ts

@@ -1,6 +1,6 @@
 import type {PlainObject} from '@oscarpalmer/atoms/models';
-import {NAME_MORA, NAME_STORE, SYMBOL_STATE} from '../constants';
-import {getState} from '../helpers/misc';
+import {NAME_STORE, SYMBOL_STATE} from '../constants';
+import {deactivateProxy, getReactiveActive, getState} from '../helpers/misc';
 import {
 	getValueInProxy,
 	notifyProxyValue,
@@ -18,7 +18,7 @@ import {getReadonlySignal} from './readonly';
 
 function ReactiveStore(this: any, value: never, options?: ReactiveOptions<unknown>): void {
 	this[SYMBOL_STATE] = {
-		...getState(undefined, options),
+		...getState(NAME_STORE, undefined, options),
 		isArray: false,
 	};
 
@@ -32,9 +32,8 @@ function ReactiveStore(this: any, value: never, options?: ReactiveOptions<unknow
 	setProxyValue.call(this, value);
 }
 
-ReactiveStore.prototype[NAME_MORA] = NAME_STORE;
-
 ReactiveStore.prototype.asReadonly = getReadonlySignal;
+ReactiveStore.prototype.deactivate = deactivateProxy;
 ReactiveStore.prototype.get = getValueInProxy;
 ReactiveStore.prototype.notify = notifyProxyValue;
 ReactiveStore.prototype.peek = peekValueInProxy;
@@ -44,6 +43,13 @@ ReactiveStore.prototype.toJSON = getJsonValue;
 ReactiveStore.prototype.toString = getStringValue;
 ReactiveStore.prototype.update = updateProxyValue;
 
+Object.defineProperties(ReactiveStore.prototype, {
+	active: {
+		enumerable: true,
+		get: getReactiveActive,
+	},
+});
+
 // #endregion
 
 // #region Functions

package/types/batch.d.ts

@@ -1,11 +0,0 @@
-export declare function flushHandlers(): void;
-/**
- * Start batching effects
- *
- * _(Use {@link stopBatch} to flush and run batched effects)_
- */
-export declare function startBatch(): void;
-/**
- * Stop batching effects and flush _(run)_ them
- */
-export declare function stopBatch(): void;

package/types/constants.d.ts

@@ -1,16 +0,0 @@
-import type { Active, Batch } from './models';
-export declare const ACTIVE: Active;
-export declare const ARRAY_THRESHOLD = 100;
-export declare const ARRAY_OFFSET = 25;
-export declare const ARRAY_PEEK = 10;
-export declare const BATCH: Batch;
-export declare const METHODS_AFFECTING_LENGTH: Set<string>;
-export declare const METHODS_UPDATE: Set<string>;
-export declare const NAME_ARRAY = "array";
-export declare const NAME_COMPUTED = "computed";
-export declare const NAME_EFFECT = "effect";
-export declare const NAME_MORA = "$mora";
-export declare const NAME_SIGNAL = "signal";
-export declare const NAME_STORE = "store";
-export declare const NAMES: Set<string>;
-export declare const PROPERTY_LENGTH = "length";

package/types/effect.d.ts

@@ -1,13 +0,0 @@
-import type { GenericCallback } from '@oscarpalmer/atoms/models';
-export declare class Effect {
-    private readonly $mora;
-    private readonly state;
-    constructor(callback: GenericCallback);
-}
-export declare function runEffect(effect: Effect): void;
-/**
- * Create an effect
- * @param callback Callback for handling signal effects
- * @returns Effect
- */
-export declare function effect(callback: GenericCallback): Effect;

package/types/helpers/is.d.ts

@@ -1,43 +0,0 @@
-import type { PlainObject } from '@oscarpalmer/atoms/models';
-import type { Effect } from '../effect';
-import type { ReactiveArray } from '../value/array';
-import type { Computed } from '../value/computed';
-import type { Reactive } from '../value/reactive';
-import type { Signal } from '../value/signal';
-import type { Store } from '../value/store';
-/**
- * Is the value a reactive array?
- * @param value Value to check
- * @returns True if value is a {@link ReactiveArray}
- */
-export declare function isArray<Item>(value: unknown): value is ReactiveArray<Item>;
-/**
- * Is the value a computed signal?
- * @param value Value to check
- * @returns True if value is a {@link Computed}
- */
-export declare function isComputed<Value>(value: unknown): value is Computed<Value>;
-/**
- * Is the value an effect?
- * @param value Value to check
- * @returns True if value is an {@link Effect}
- */
-export declare function isEffect(value: unknown): value is Effect;
-/**
- * Is the value reactive?
- * @param value Value to check
- * @returns True if value is a {@link Reactive}
- */
-export declare function isReactive<Value, Equal = Value>(value: unknown): value is Reactive<Value, Equal>;
-/**
- * Is the value a signal?
- * @param value Value to check
- * @returns True if value is a {@link Signal}
- */
-export declare function isSignal<Value>(value: unknown): value is Signal<Value>;
-/**
- * Is the value a reactive store?
- * @param value Value to check
- * @returns True if value is a {@link Store}
- */
-export declare function isStore<Value extends PlainObject>(value: unknown): value is Store<Value>;

package/types/helpers/proxy.d.ts

@@ -1,11 +0,0 @@
-import type { ArrayOrPlainObject, Key, PlainObject } from '@oscarpalmer/atoms/models';
-import type { ReactiveState, SetValueInProxyParameters } from '../models';
-import type { ReactiveArray } from '../value/array';
-import { type Computed } from '../value/computed';
-import type { Store } from '../value/store';
-export declare function emityProxyValues<Value>(state: ReactiveState<Value, Value>, mapped: Map<Key, Computed<unknown>>): void;
-export declare function emityProxyValues<Value>(state: ReactiveState<Value[], Value>, mapped: Map<Key, Computed<unknown>>): void;
-export declare function getReactiveValueInProxy<Value>(array: ReactiveArray<Value>, mapped: Map<Key, Computed<unknown>>, index: number, isArray: true): Computed<unknown>;
-export declare function getReactiveValueInProxy<Value extends PlainObject>(store: Store<Value>, mapped: Map<Key, Computed<unknown>>, key: Key, isArray: false): Computed<unknown>;
-export declare function setProxyValue(proxy: ArrayOrPlainObject, value: ArrayOrPlainObject): void;
-export declare function setValueInProxy<Value extends ArrayOrPlainObject, Equal>(parameters: SetValueInProxyParameters<Value, Equal>): boolean;

package/types/helpers/value.d.ts

@@ -1,4 +0,0 @@
-import type { ReactiveState } from '../models';
-export declare function emitValue<Value>(state: ReactiveState<Value, never>): void;
-export declare function equalArrays<Value>(state: ReactiveState<Value[], Value>, first: Value[], second: Value[]): boolean;
-export declare function getValue<Value>(state: ReactiveState<Value, never>): Value;

package/types/index.d.ts

@@ -1,9 +0,0 @@
-export { startBatch, stopBatch } from './batch';
-export { effect, type Effect } from './effect';
-export { isArray, isComputed, isEffect, isReactive, isSignal, } from './helpers/is';
-export type { Unsubscribe } from './models';
-export { array, type ReactiveArray } from './value/array';
-export { computed, type Computed } from './value/computed';
-export type { Reactive } from './value/reactive';
-export { signal, type Signal } from './value/signal';
-export { store, type Store } from './value/store';