@oscarpalmer/mora 0.16.0 → 0.17.0

package/src/value/computed.ts

@@ -1,7 +1,7 @@
 import {batchDepth, batchedHandlers} from '../batch';
 import {type Effect, activeEffect, effect, runEffect} from '../effect';
 import {computedName} from '../helpers/is';
-import {Reactive, type ReactiveState} from './reactive';
+import {Reactive, type ReactiveOptions, type ReactiveState} from './reactive';
 
 export type ComputedEffect = {
 	dirty: boolean;
@@ -10,7 +10,7 @@ export type ComputedEffect = {
 
 export type InternalComputed = {
 	readonly effect: ComputedEffect;
-	readonly state: ReactiveState<unknown>;
+	readonly state: ReactiveState<unknown, unknown>;
 };
 
 export let activeComputed: Computed<unknown> | undefined;
@@ -21,8 +21,8 @@ export class Computed<Value> extends Reactive<Value> {
 		instance: undefined as never,
 	};
 
-	constructor(callback: () => Value) {
-		super(computedName, undefined as never);
+	constructor(callback: () => Value, options?: ReactiveOptions<Value>) {
+		super(computedName, undefined as never, options);
 
 		this.effect.instance = effect(() => {
 			if (this.effect.dirty) {
@@ -34,7 +34,7 @@ export class Computed<Value> extends Reactive<Value> {
 
 				activeComputed = previousComputed;
 
-				if (!Object.is(this.state.value, value)) {
+				if (!this.state.equal(this.state.value, value)) {
 					this.state.value = value;
 
 					for (const computed of this.state.computeds) {
@@ -78,6 +78,9 @@ export class Computed<Value> extends Reactive<Value> {
 /**
  * Create a computed value
  */
-export function computed<Value>(callback: () => Value): Computed<Value> {
-	return new Computed(callback);
+export function computed<Value>(
+	callback: () => Value,
+	options?: ReactiveOptions<Value>,
+): Computed<Value> {
+	return new Computed(callback, options);
 }

package/src/value/reactive.ts

@@ -7,17 +7,22 @@ import {
 } from '../subscription';
 import type {Computed} from './computed';
 
-export abstract class Reactive<Value> {
-	protected readonly state: ReactiveState<Value> = {
+export abstract class Reactive<Value, Equal = Value> {
+	protected readonly state: ReactiveState<Value, Equal> = {
 		computeds: new Set(),
 		effects: new Set(),
+		equal: Object.is,
 		subscriptions: new Map(),
 		value: undefined as never,
 	};
 
-	constructor(name: string, value: Value) {
+	constructor(name: string, value: Value, options?: ReactiveOptions<Equal>) {
 		this.state.value = value;
 
+		if (typeof options === 'object' && typeof options.equal === 'function') {
+			this.state.equal = options.equal;
+		}
+
 		Object.defineProperty(this, '$mora', {
 			value: name,
 		});
@@ -64,9 +69,17 @@ export abstract class Reactive<Value> {
 	}
 }
 
-export type ReactiveState<Value> = {
+export type ReactiveOptions<Value> = {
+	/**
+	 * Method to compare values for equality
+	 */
+	equal?: (first: Value, second: Value) => boolean;
+};
+
+export type ReactiveState<Value, Equal> = {
 	computeds: Set<Computed<unknown>>;
 	effects: Set<Effect>;
+	equal: (first: Equal, second: Equal) => boolean;
 	subscriptions: Map<(value: Value) => void, Subscription<Value>>;
 	value: Value;
 };

package/src/value/signal.ts

@@ -1,10 +1,10 @@
 import {signalName} from '../helpers/is';
 import {differentValues, emitValue, getValue} from '../helpers/value';
-import {Reactive} from './reactive';
+import {Reactive, type ReactiveOptions} from './reactive';
 
 export class Signal<Value> extends Reactive<Value> {
-	constructor(value: Value) {
-		super(signalName, value);
+	constructor(value: Value, options?: ReactiveOptions<Value>) {
+		super(signalName, value, options);
 	}
 
 	/**
@@ -18,7 +18,7 @@ export class Signal<Value> extends Reactive<Value> {
 	 * Set the value
 	 */
 	set(value: Value): void {
-		if (differentValues(this.state.value, value)) {
+		if (differentValues(this.state, this.state.value, value)) {
 			this.state.value = value;
 
 			emitValue(this.state);
@@ -36,6 +36,9 @@ export class Signal<Value> extends Reactive<Value> {
 /**
  * Create a reactive value
  */
-export function signal<Value>(value: Value): Signal<Value> {
-	return new Signal(value);
+export function signal<Value>(
+	value: Value,
+	options?: ReactiveOptions<Value>,
+): Signal<Value> {
+	return new Signal<Value>(value, options);
 }

package/types/batch.d.cts

@@ -8,15 +8,15 @@ declare class Effect {
 }
 declare class Computed<Value> extends Reactive<Value> {
 	private readonly effect;
-	constructor(callback: () => Value);
+	constructor(callback: () => Value, options?: ReactiveOptions<Value>);
 	/**
 	 * @inheritdoc
 	 */
 	get(): Value;
 }
-declare abstract class Reactive<Value> {
-	protected readonly state: ReactiveState<Value>;
-	constructor(name: string, value: Value);
+declare abstract class Reactive<Value, Equal = Value> {
+	protected readonly state: ReactiveState<Value, Equal>;
+	constructor(name: string, value: Value, options?: ReactiveOptions<Equal>);
 	/**
 	 * Get the value
 	 */
@@ -42,16 +42,23 @@ declare abstract class Reactive<Value> {
 	 */
 	unsubscribe(callback: (value: Value) => void): void;
 }
-export type ReactiveState<Value> = {
+export type ReactiveOptions<Value> = {
+	/**
+	 * Method to compare values for equality
+	 */
+	equal?: (first: Value, second: Value) => boolean;
+};
+export type ReactiveState<Value, Equal> = {
 	computeds: Set<Computed<unknown>>;
 	effects: Set<Effect>;
+	equal: (first: Equal, second: Equal) => boolean;
 	subscriptions: Map<(value: Value) => void, Subscription<Value>>;
 	value: Value;
 };
 declare class Subscription<Value> {
-	state: ReactiveState<Value>;
+	state: ReactiveState<Value, never>;
 	callback: GenericCallback;
-	constructor(state: ReactiveState<Value>, callback: GenericCallback);
+	constructor(state: ReactiveState<Value, never>, callback: GenericCallback);
 }
 /**
  * Unsubscribe from changes

package/types/helpers/is.d.cts

@@ -8,15 +8,15 @@ declare class Effect {
 }
 declare class Computed<Value> extends Reactive<Value> {
 	private readonly effect;
-	constructor(callback: () => Value);
+	constructor(callback: () => Value, options?: ReactiveOptions<Value>);
 	/**
 	 * @inheritdoc
 	 */
 	get(): Value;
 }
-declare abstract class Reactive<Value> {
-	protected readonly state: ReactiveState<Value>;
-	constructor(name: string, value: Value);
+declare abstract class Reactive<Value, Equal = Value> {
+	protected readonly state: ReactiveState<Value, Equal>;
+	constructor(name: string, value: Value, options?: ReactiveOptions<Equal>);
 	/**
 	 * Get the value
 	 */
@@ -42,22 +42,29 @@ declare abstract class Reactive<Value> {
 	 */
 	unsubscribe(callback: (value: Value) => void): void;
 }
-export type ReactiveState<Value> = {
+export type ReactiveOptions<Value> = {
+	/**
+	 * Method to compare values for equality
+	 */
+	equal?: (first: Value, second: Value) => boolean;
+};
+export type ReactiveState<Value, Equal> = {
 	computeds: Set<Computed<unknown>>;
 	effects: Set<Effect>;
+	equal: (first: Equal, second: Equal) => boolean;
 	subscriptions: Map<(value: Value) => void, Subscription<Value>>;
 	value: Value;
 };
 declare class Subscription<Value> {
-	state: ReactiveState<Value>;
+	state: ReactiveState<Value, never>;
 	callback: GenericCallback;
-	constructor(state: ReactiveState<Value>, callback: GenericCallback);
+	constructor(state: ReactiveState<Value, never>, callback: GenericCallback);
 }
 /**
  * Unsubscribe from changes
  */
 export type Unsubscribe = () => void;
-declare class ReactiveArray<Item> extends Reactive<Item[]> {
+declare class ReactiveArray<Item> extends Reactive<Item[], Item> {
 	#private;
 	/**
 	 * The length of the array
@@ -67,7 +74,7 @@ declare class ReactiveArray<Item> extends Reactive<Item[]> {
 	 * Set the length of the array
 	 */
 	set length(value: number);
-	constructor(value: Item[]);
+	constructor(value: Item[], options?: ReactiveOptions<Item>);
 	/**
 	 * Get an indexed item
 	 */
@@ -130,7 +137,7 @@ declare class ReactiveArray<Item> extends Reactive<Item[]> {
 	unshift(...items: Item[]): number;
 }
 declare class Signal<Value> extends Reactive<Value> {
-	constructor(value: Value);
+	constructor(value: Value, options?: ReactiveOptions<Value>);
 	/**
 	 * @inheritdoc
 	 */

package/types/helpers/value.d.cts

@@ -8,15 +8,15 @@ declare class Effect {
 }
 declare class Computed<Value> extends Reactive<Value> {
 	private readonly effect;
-	constructor(callback: () => Value);
+	constructor(callback: () => Value, options?: ReactiveOptions<Value>);
 	/**
 	 * @inheritdoc
 	 */
 	get(): Value;
 }
-declare abstract class Reactive<Value> {
-	protected readonly state: ReactiveState<Value>;
-	constructor(name: string, value: Value);
+declare abstract class Reactive<Value, Equal = Value> {
+	protected readonly state: ReactiveState<Value, Equal>;
+	constructor(name: string, value: Value, options?: ReactiveOptions<Equal>);
 	/**
 	 * Get the value
 	 */
@@ -42,24 +42,31 @@ declare abstract class Reactive<Value> {
 	 */
 	unsubscribe(callback: (value: Value) => void): void;
 }
-export type ReactiveState<Value> = {
+export type ReactiveOptions<Value> = {
+	/**
+	 * Method to compare values for equality
+	 */
+	equal?: (first: Value, second: Value) => boolean;
+};
+export type ReactiveState<Value, Equal> = {
 	computeds: Set<Computed<unknown>>;
 	effects: Set<Effect>;
+	equal: (first: Equal, second: Equal) => boolean;
 	subscriptions: Map<(value: Value) => void, Subscription<Value>>;
 	value: Value;
 };
 declare class Subscription<Value> {
-	state: ReactiveState<Value>;
+	state: ReactiveState<Value, never>;
 	callback: GenericCallback;
-	constructor(state: ReactiveState<Value>, callback: GenericCallback);
+	constructor(state: ReactiveState<Value, never>, callback: GenericCallback);
 }
 /**
  * Unsubscribe from changes
  */
 export type Unsubscribe = () => void;
-export declare function differentArrays(first: unknown[], second: unknown[]): boolean;
-export declare function differentValues(first: unknown, second: unknown): boolean;
-export declare function emitValue<Value>(state: ReactiveState<Value>): void;
-export declare function getValue<Value>(state: ReactiveState<Value>): Value;
+export declare function differentArrays<Value>(state: ReactiveState<Value[], Value>, first: Value[], second: Value[]): boolean;
+export declare function differentValues<Value>(state: ReactiveState<Value, Value>, first: Value, second: Value): boolean;
+export declare function emitValue<Value>(state: ReactiveState<Value, never>): void;
+export declare function getValue<Value>(state: ReactiveState<Value, never>): Value;
 
 export {};

package/types/helpers/value.d.ts

@@ -1,5 +1,5 @@
 import type { ReactiveState } from '../value/reactive';
-export declare function differentArrays(first: unknown[], second: unknown[]): boolean;
-export declare function differentValues(first: unknown, second: unknown): boolean;
-export declare function emitValue<Value>(state: ReactiveState<Value>): void;
-export declare function getValue<Value>(state: ReactiveState<Value>): Value;
+export declare function differentArrays<Value>(state: ReactiveState<Value[], Value>, first: Value[], second: Value[]): boolean;
+export declare function differentValues<Value>(state: ReactiveState<Value, Value>, first: Value, second: Value): boolean;
+export declare function emitValue<Value>(state: ReactiveState<Value, never>): void;
+export declare function getValue<Value>(state: ReactiveState<Value, never>): Value;

package/types/index.d.cts

@@ -12,7 +12,7 @@ export declare class Effect {
 export declare function effect(callback: GenericCallback): Effect;
 export declare class Computed<Value> extends Reactive<Value> {
 	private readonly effect;
-	constructor(callback: () => Value);
+	constructor(callback: () => Value, options?: ReactiveOptions<Value>);
 	/**
 	 * @inheritdoc
 	 */
@@ -21,10 +21,10 @@ export declare class Computed<Value> extends Reactive<Value> {
 /**
  * Create a computed value
  */
-export declare function computed<Value>(callback: () => Value): Computed<Value>;
-export declare abstract class Reactive<Value> {
-	protected readonly state: ReactiveState<Value>;
-	constructor(name: string, value: Value);
+export declare function computed<Value>(callback: () => Value, options?: ReactiveOptions<Value>): Computed<Value>;
+export declare abstract class Reactive<Value, Equal = Value> {
+	protected readonly state: ReactiveState<Value, Equal>;
+	constructor(name: string, value: Value, options?: ReactiveOptions<Equal>);
 	/**
 	 * Get the value
 	 */
@@ -50,16 +50,23 @@ export declare abstract class Reactive<Value> {
 	 */
 	unsubscribe(callback: (value: Value) => void): void;
 }
-export type ReactiveState<Value> = {
+export type ReactiveOptions<Value> = {
+	/**
+	 * Method to compare values for equality
+	 */
+	equal?: (first: Value, second: Value) => boolean;
+};
+export type ReactiveState<Value, Equal> = {
 	computeds: Set<Computed<unknown>>;
 	effects: Set<Effect>;
+	equal: (first: Equal, second: Equal) => boolean;
 	subscriptions: Map<(value: Value) => void, Subscription<Value>>;
 	value: Value;
 };
 declare class Subscription<Value> {
-	state: ReactiveState<Value>;
+	state: ReactiveState<Value, never>;
 	callback: GenericCallback;
-	constructor(state: ReactiveState<Value>, callback: GenericCallback);
+	constructor(state: ReactiveState<Value, never>, callback: GenericCallback);
 }
 /**
  * Unsubscribe from changes
@@ -73,7 +80,7 @@ export declare function startBatch(): void;
  * Stop batching effects and flush _(run)_ them
  */
 export declare function stopBatch(): void;
-export declare class ReactiveArray<Item> extends Reactive<Item[]> {
+export declare class ReactiveArray<Item> extends Reactive<Item[], Item> {
 	#private;
 	/**
 	 * The length of the array
@@ -83,7 +90,7 @@ export declare class ReactiveArray<Item> extends Reactive<Item[]> {
 	 * Set the length of the array
 	 */
 	set length(value: number);
-	constructor(value: Item[]);
+	constructor(value: Item[], options?: ReactiveOptions<Item>);
 	/**
 	 * Get an indexed item
 	 */
@@ -148,9 +155,9 @@ export declare class ReactiveArray<Item> extends Reactive<Item[]> {
 /**
  * Create a reactive array
  */
-export declare function array<Item>(value: Item[]): ReactiveArray<Item>;
+export declare function array<Item>(value: Item[], options?: ReactiveOptions<Item>): ReactiveArray<Item>;
 export declare class Signal<Value> extends Reactive<Value> {
-	constructor(value: Value);
+	constructor(value: Value, options?: ReactiveOptions<Value>);
 	/**
 	 * @inheritdoc
 	 */
@@ -167,7 +174,7 @@ export declare class Signal<Value> extends Reactive<Value> {
 /**
  * Create a reactive value
  */
-export declare function signal<Value>(value: Value): Signal<Value>;
+export declare function signal<Value>(value: Value, options?: ReactiveOptions<Value>): Signal<Value>;
 /**
  * Is the value a reactive array?
  */

package/types/subscription.d.cts

@@ -8,15 +8,15 @@ declare class Effect {
 }
 declare class Computed<Value> extends Reactive<Value> {
 	private readonly effect;
-	constructor(callback: () => Value);
+	constructor(callback: () => Value, options?: ReactiveOptions<Value>);
 	/**
 	 * @inheritdoc
 	 */
 	get(): Value;
 }
-declare abstract class Reactive<Value> {
-	protected readonly state: ReactiveState<Value>;
-	constructor(name: string, value: Value);
+declare abstract class Reactive<Value, Equal = Value> {
+	protected readonly state: ReactiveState<Value, Equal>;
+	constructor(name: string, value: Value, options?: ReactiveOptions<Equal>);
 	/**
 	 * Get the value
 	 */
@@ -42,23 +42,30 @@ declare abstract class Reactive<Value> {
 	 */
 	unsubscribe(callback: (value: Value) => void): void;
 }
-export type ReactiveState<Value> = {
+export type ReactiveOptions<Value> = {
+	/**
+	 * Method to compare values for equality
+	 */
+	equal?: (first: Value, second: Value) => boolean;
+};
+export type ReactiveState<Value, Equal> = {
 	computeds: Set<Computed<unknown>>;
 	effects: Set<Effect>;
+	equal: (first: Equal, second: Equal) => boolean;
 	subscriptions: Map<(value: Value) => void, Subscription<Value>>;
 	value: Value;
 };
 export declare class Subscription<Value> {
-	state: ReactiveState<Value>;
+	state: ReactiveState<Value, never>;
 	callback: GenericCallback;
-	constructor(state: ReactiveState<Value>, callback: GenericCallback);
+	constructor(state: ReactiveState<Value, never>, callback: GenericCallback);
 }
 /**
  * Unsubscribe from changes
  */
 export type Unsubscribe = () => void;
 export declare function noop(): void;
-export declare function subscribe<Value>(state: ReactiveState<Value>, callback: (value: Value) => void): Unsubscribe;
-export declare function unsubscribe<Value>(state: ReactiveState<Value>, callback: (value: Value) => void): void;
+export declare function subscribe<Value>(state: ReactiveState<Value, never>, callback: (value: Value) => void): Unsubscribe;
+export declare function unsubscribe<Value>(state: ReactiveState<Value, never>, callback: (value: Value) => void): void;
 
 export {};

package/types/subscription.d.ts

@@ -1,14 +1,14 @@
 import type { GenericCallback } from '@oscarpalmer/atoms/models';
 import type { ReactiveState } from './value/reactive';
 export declare class Subscription<Value> {
-    state: ReactiveState<Value>;
+    state: ReactiveState<Value, never>;
     callback: GenericCallback;
-    constructor(state: ReactiveState<Value>, callback: GenericCallback);
+    constructor(state: ReactiveState<Value, never>, callback: GenericCallback);
 }
 /**
  * Unsubscribe from changes
  */
 export type Unsubscribe = () => void;
 export declare function noop(): void;
-export declare function subscribe<Value>(state: ReactiveState<Value>, callback: (value: Value) => void): Unsubscribe;
-export declare function unsubscribe<Value>(state: ReactiveState<Value>, callback: (value: Value) => void): void;
+export declare function subscribe<Value>(state: ReactiveState<Value, never>, callback: (value: Value) => void): Unsubscribe;
+export declare function unsubscribe<Value>(state: ReactiveState<Value, never>, callback: (value: Value) => void): void;

package/types/value/array.d.cts

@@ -8,15 +8,15 @@ declare class Effect {
 }
 declare class Computed<Value> extends Reactive<Value> {
 	private readonly effect;
-	constructor(callback: () => Value);
+	constructor(callback: () => Value, options?: ReactiveOptions<Value>);
 	/**
 	 * @inheritdoc
 	 */
 	get(): Value;
 }
-declare abstract class Reactive<Value> {
-	protected readonly state: ReactiveState<Value>;
-	constructor(name: string, value: Value);
+declare abstract class Reactive<Value, Equal = Value> {
+	protected readonly state: ReactiveState<Value, Equal>;
+	constructor(name: string, value: Value, options?: ReactiveOptions<Equal>);
 	/**
 	 * Get the value
 	 */
@@ -42,22 +42,29 @@ declare abstract class Reactive<Value> {
 	 */
 	unsubscribe(callback: (value: Value) => void): void;
 }
-export type ReactiveState<Value> = {
+export type ReactiveOptions<Value> = {
+	/**
+	 * Method to compare values for equality
+	 */
+	equal?: (first: Value, second: Value) => boolean;
+};
+export type ReactiveState<Value, Equal> = {
 	computeds: Set<Computed<unknown>>;
 	effects: Set<Effect>;
+	equal: (first: Equal, second: Equal) => boolean;
 	subscriptions: Map<(value: Value) => void, Subscription<Value>>;
 	value: Value;
 };
 declare class Subscription<Value> {
-	state: ReactiveState<Value>;
+	state: ReactiveState<Value, never>;
 	callback: GenericCallback;
-	constructor(state: ReactiveState<Value>, callback: GenericCallback);
+	constructor(state: ReactiveState<Value, never>, callback: GenericCallback);
 }
 /**
  * Unsubscribe from changes
  */
 export type Unsubscribe = () => void;
-export declare class ReactiveArray<Item> extends Reactive<Item[]> {
+export declare class ReactiveArray<Item> extends Reactive<Item[], Item> {
 	#private;
 	/**
 	 * The length of the array
@@ -67,7 +74,7 @@ export declare class ReactiveArray<Item> extends Reactive<Item[]> {
 	 * Set the length of the array
 	 */
 	set length(value: number);
-	constructor(value: Item[]);
+	constructor(value: Item[], options?: ReactiveOptions<Item>);
 	/**
 	 * Get an indexed item
 	 */
@@ -132,6 +139,6 @@ export declare class ReactiveArray<Item> extends Reactive<Item[]> {
 /**
  * Create a reactive array
  */
-export declare function array<Item>(value: Item[]): ReactiveArray<Item>;
+export declare function array<Item>(value: Item[], options?: ReactiveOptions<Item>): ReactiveArray<Item>;
 
 export {};

package/types/value/array.d.ts

@@ -1,6 +1,6 @@
 import { type Computed } from './computed';
-import { Reactive } from './reactive';
-export declare class ReactiveArray<Item> extends Reactive<Item[]> {
+import { Reactive, type ReactiveOptions } from './reactive';
+export declare class ReactiveArray<Item> extends Reactive<Item[], Item> {
     #private;
     /**
      * The length of the array
@@ -10,7 +10,7 @@ export declare class ReactiveArray<Item> extends Reactive<Item[]> {
      * Set the length of the array
      */
     set length(value: number);
-    constructor(value: Item[]);
+    constructor(value: Item[], options?: ReactiveOptions<Item>);
     /**
      * Get an indexed item
      */
@@ -75,4 +75,4 @@ export declare class ReactiveArray<Item> extends Reactive<Item[]> {
 /**
  * Create a reactive array
  */
-export declare function array<Item>(value: Item[]): ReactiveArray<Item>;
+export declare function array<Item>(value: Item[], options?: ReactiveOptions<Item>): ReactiveArray<Item>;

package/types/value/computed.d.cts

@@ -12,12 +12,12 @@ export type ComputedEffect = {
 };
 export type InternalComputed = {
 	readonly effect: ComputedEffect;
-	readonly state: ReactiveState<unknown>;
+	readonly state: ReactiveState<unknown, unknown>;
 };
 export declare let activeComputed: Computed<unknown> | undefined;
 export declare class Computed<Value> extends Reactive<Value> {
 	private readonly effect;
-	constructor(callback: () => Value);
+	constructor(callback: () => Value, options?: ReactiveOptions<Value>);
 	/**
 	 * @inheritdoc
 	 */
@@ -26,10 +26,10 @@ export declare class Computed<Value> extends Reactive<Value> {
 /**
  * Create a computed value
  */
-export declare function computed<Value>(callback: () => Value): Computed<Value>;
-declare abstract class Reactive<Value> {
-	protected readonly state: ReactiveState<Value>;
-	constructor(name: string, value: Value);
+export declare function computed<Value>(callback: () => Value, options?: ReactiveOptions<Value>): Computed<Value>;
+declare abstract class Reactive<Value, Equal = Value> {
+	protected readonly state: ReactiveState<Value, Equal>;
+	constructor(name: string, value: Value, options?: ReactiveOptions<Equal>);
 	/**
 	 * Get the value
 	 */
@@ -55,16 +55,23 @@ declare abstract class Reactive<Value> {
 	 */
 	unsubscribe(callback: (value: Value) => void): void;
 }
-export type ReactiveState<Value> = {
+export type ReactiveOptions<Value> = {
+	/**
+	 * Method to compare values for equality
+	 */
+	equal?: (first: Value, second: Value) => boolean;
+};
+export type ReactiveState<Value, Equal> = {
 	computeds: Set<Computed<unknown>>;
 	effects: Set<Effect>;
+	equal: (first: Equal, second: Equal) => boolean;
 	subscriptions: Map<(value: Value) => void, Subscription<Value>>;
 	value: Value;
 };
 declare class Subscription<Value> {
-	state: ReactiveState<Value>;
+	state: ReactiveState<Value, never>;
 	callback: GenericCallback;
-	constructor(state: ReactiveState<Value>, callback: GenericCallback);
+	constructor(state: ReactiveState<Value, never>, callback: GenericCallback);
 }
 /**
  * Unsubscribe from changes

package/types/value/computed.d.ts

@@ -1,17 +1,17 @@
 import { type Effect } from '../effect';
-import { Reactive, type ReactiveState } from './reactive';
+import { Reactive, type ReactiveOptions, type ReactiveState } from './reactive';
 export type ComputedEffect = {
     dirty: boolean;
     instance: Effect;
 };
 export type InternalComputed = {
     readonly effect: ComputedEffect;
-    readonly state: ReactiveState<unknown>;
+    readonly state: ReactiveState<unknown, unknown>;
 };
 export declare let activeComputed: Computed<unknown> | undefined;
 export declare class Computed<Value> extends Reactive<Value> {
     private readonly effect;
-    constructor(callback: () => Value);
+    constructor(callback: () => Value, options?: ReactiveOptions<Value>);
     /**
      * @inheritdoc
      */
@@ -20,4 +20,4 @@ export declare class Computed<Value> extends Reactive<Value> {
 /**
  * Create a computed value
  */
-export declare function computed<Value>(callback: () => Value): Computed<Value>;
+export declare function computed<Value>(callback: () => Value, options?: ReactiveOptions<Value>): Computed<Value>;