@oscarpalmer/mora 0.18.0 → 0.18.2

package/types/helpers/proxy.d.cts

@@ -0,0 +1,89 @@
+// Generated by dts-bundle-generator v9.5.1
+
+/**
+ * A generic array or object
+ */
+export type ArrayOrPlainObject = unknown[] | Record<PropertyKey, unknown>;
+export type GenericCallback = (...args: any[]) => any;
+declare class Effect {
+	private readonly $mora;
+	private readonly state;
+	constructor(callback: GenericCallback);
+}
+declare class Computed<Value> extends Reactive<Value> {
+	private readonly effect;
+	constructor(callback: () => Value, options?: ReactiveOptions<Value>);
+	/**
+	 * @inheritdoc
+	 */
+	get(): 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
+	 */
+	abstract get(): Value;
+	/**
+	 * Get the value _(without reactivity)_
+	 */
+	peek(): Value;
+	/**
+	 * Subscribe to changes
+	 */
+	subscribe(callback: (value: Value) => void): Unsubscribe;
+	/**
+	 * JSON representation of the value
+	 */
+	toJSON(): Value;
+	/**
+	 * String representation of the value
+	 */
+	toString(): string;
+	/**
+	 * Unsubscribe from changes
+	 */
+	unsubscribe(callback: (value: Value) => void): void;
+}
+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, never>;
+	callback: GenericCallback;
+	constructor(state: ReactiveState<Value, never>, callback: GenericCallback);
+}
+/**
+ * Unsubscribe from changes
+ */
+export type Unsubscribe = () => void;
+declare class Signal<Value> extends Reactive<Value> {
+	constructor(value: Value, options?: ReactiveOptions<Value>);
+	/**
+	 * @inheritdoc
+	 */
+	get(): Value;
+	/**
+	 * Set the value
+	 */
+	set(value: Value): void;
+	/**
+	 * Update the value
+	 */
+	update(callback: (value: Value) => Value): void;
+}
+export declare function setProxyValue(proxy: ArrayOrPlainObject, value: ArrayOrPlainObject): void;
+export declare function setValueInProxy<Value extends ArrayOrPlainObject, Equal>(target: Value, property: PropertyKey, value: unknown, state: ReactiveState<Value, Equal>, isArray: boolean, length?: Signal<number>): boolean;
+
+export {};

package/types/helpers/proxy.d.ts

@@ -0,0 +1,5 @@
+import type { ArrayOrPlainObject } from '@oscarpalmer/atoms/models';
+import type { ReactiveState } from '../value/reactive';
+import type { Signal } from '../value/signal';
+export declare function setProxyValue(proxy: ArrayOrPlainObject, value: ArrayOrPlainObject): void;
+export declare function setValueInProxy<Value extends ArrayOrPlainObject, Equal>(target: Value, property: PropertyKey, value: unknown, state: ReactiveState<Value, Equal>, isArray: boolean, length?: Signal<number>): boolean;

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,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;
 };
 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 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;
 
 export {};

package/types/helpers/value.d.ts

@@ -1,5 +1,4 @@
 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 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.cts

@@ -1,6 +1,14 @@
 // Generated by dts-bundle-generator v9.5.1
 
 export type GenericCallback = (...args: any[]) => any;
+/**
+ * A useful key type
+ */
+export type Key = number | string;
+/**
+ * A generic object
+ */
+export type PlainObject = Record<PropertyKey, unknown>;
 export declare class Effect {
 	private readonly $mora;
 	private readonly state;
@@ -12,7 +20,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 +29,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 +58,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 +88,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 +98,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 +163,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 +182,50 @@ 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>;
+export declare class Store<Value extends PlainObject> extends Reactive<Value, Value> {
+	constructor(value: Value, options?: ReactiveOptions<Value>);
+	/**
+	 * @inheritdoc
+	 */
+	get(): Value;
+	/**
+	 * Get a value by key _(without reactivity)_
+	 */
+	get(key: keyof Value): Value[keyof Value];
+	/**
+	 * Get a value by key _(without reactivity)_
+	 */
+	get(key: Key): unknown;
+	/**
+	 * Get the value _(without reactivity)_
+	 */
+	peek(): Value;
+	/**
+	 * Get a value by key _(without reactivity)_
+	 */
+	peek(key: keyof Value): Value[keyof Value];
+	/**
+	 * Get a value by key _(without reactivity)_
+	 */
+	peek(key: Key): unknown;
+	/**
+	 * Set the value
+	 */
+	set(value?: Value): void;
+	/**
+	 * Set a value by key
+	 */
+	set(key: keyof Value, value: Value[keyof Value]): void;
+	/**
+	 * Set a value by key
+	 */
+	set(key: Key, value: unknown): void;
+}
+/**
+ * Create a reactive store
+ */
+export declare function store<Value extends PlainObject>(value: Value, options?: ReactiveOptions<Value>): Store<Value>;
 /**
  * Is the value a reactive array?
  */

package/types/index.d.ts

@@ -5,3 +5,4 @@ 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';

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>;

package/types/value/reactive.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;
 }
-export declare abstract class Reactive<Value> {
-	protected readonly state: ReactiveState<Value>;
-	constructor(name: string, value: 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
 	 */
@@ -42,16 +42,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

package/types/value/reactive.d.ts

@@ -1,9 +1,9 @@
 import type { Effect } from '../effect';
 import { type Subscription, type Unsubscribe } from '../subscription';
 import type { Computed } from './computed';
-export declare abstract class Reactive<Value> {
-    protected readonly state: ReactiveState<Value>;
-    constructor(name: string, value: 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
      */
@@ -29,9 +29,16 @@ 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;
 };