@oscarpalmer/mora 0.17.0 → 0.18.0

package/src/value/array.ts

@@ -1,5 +1,6 @@
 import {arrayName} from '../helpers/is';
-import {differentArrays, emitValue, getValue} from '../helpers/value';
+import {setValueInProxy} from '../helpers/proxy';
+import {emitValue, equalArrays, getValue} from '../helpers/value';
 import {type Computed, computed} from './computed';
 import {Reactive, type ReactiveOptions, type ReactiveState} from './reactive';
 import {type Signal, signal} from './signal';
@@ -36,7 +37,14 @@ export class ReactiveArray<Item> extends Reactive<Item[], Item> {
 						? updateArray(property as string, target, this.state, this.#size)
 						: Reflect.get(target, property),
 				set: (target, property, value) =>
-					setValue(target, property, value, this.state, this.#size),
+					setValueInProxy(
+						target,
+						property,
+						value,
+						this.state,
+						true,
+						this.#size,
+					),
 			}),
 			options,
 		);
@@ -172,33 +180,6 @@ export function array<Item>(
 	return new ReactiveArray(Array.isArray(value) ? value : [], options);
 }
 
-function setValue<Item>(
-	target: Item[],
-	property: PropertyKey,
-	value: Item,
-	state: ReactiveState<Item[], Item>,
-	length: Signal<number>,
-): boolean {
-	const isIndex = !Number.isNaN(Number(property));
-	const isLength = property === 'length';
-
-	if (!isIndex && !isLength) {
-		return Reflect.set(target, property, value);
-	}
-
-	const previous = Reflect.get(target, property);
-
-	if (!state.equal(previous, value)) {
-		Reflect.set(target, property, value);
-
-		emitValue(state);
-
-		length.set(target.length);
-	}
-
-	return true;
-}
-
 function updateArray<Item>(
 	type: string,
 	array: Item[],
@@ -217,7 +198,7 @@ function updateArray<Item>(
 		if (
 			affectsLength
 				? array.length !== previousLength
-				: differentArrays(state, previousArray, array)
+				: !equalArrays(state, previousArray, array)
 		) {
 			emitValue(state);
 

package/src/value/signal.ts

@@ -1,5 +1,5 @@
 import {signalName} from '../helpers/is';
-import {differentValues, emitValue, getValue} from '../helpers/value';
+import {emitValue, getValue} from '../helpers/value';
 import {Reactive, type ReactiveOptions} from './reactive';
 
 export class Signal<Value> extends Reactive<Value> {
@@ -18,7 +18,7 @@ export class Signal<Value> extends Reactive<Value> {
 	 * Set the value
 	 */
 	set(value: Value): void {
-		if (differentValues(this.state, this.state.value, value)) {
+		if (!this.state.equal(this.state.value, value)) {
 			this.state.value = value;
 
 			emitValue(this.state);

package/src/value/store.ts

@@ -0,0 +1,90 @@
+import {isKey, isPlainObject} from '@oscarpalmer/atoms/is';
+import type {Key, PlainObject} from '@oscarpalmer/atoms/models';
+import {storeName} from '../helpers/is';
+import {setProxyValue, setValueInProxy} from '../helpers/proxy';
+import {getValue} from '../helpers/value';
+import {Reactive, type ReactiveOptions} from './reactive';
+
+export class Store<Value extends PlainObject> extends Reactive<Value, Value> {
+	constructor(value: Value, options?: ReactiveOptions<Value>) {
+		super(
+			storeName,
+			new Proxy(value, {
+				set: (target, property, value) =>
+					setValueInProxy(target, property, value, this.state, false),
+			}),
+			options,
+		);
+	}
+
+	/**
+	 * @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(key?: unknown): unknown {
+		return isKey(key) ? this.state.value[key] : getValue(this.state);
+	}
+
+	/**
+	 * 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;
+
+	peek(key?: unknown): unknown {
+		return isKey(key) ? this.state.value[key] : {...this.state.value};
+	}
+
+	/**
+	 * 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;
+
+	set(first?: unknown, second?: unknown): void {
+		if (isKey(first)) {
+			(this.state.value as PlainObject)[first] = second;
+		} else if (first == null || isPlainObject(first)) {
+			setProxyValue(this.state.value, first ?? {});
+		}
+	}
+}
+
+/**
+ * Create a reactive store
+ */
+export function store<Value extends PlainObject>(
+	value: Value,
+	options?: ReactiveOptions<Value>,
+): Store<Value> {
+	return new Store((isPlainObject(value) ? value : {}) as 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, options?: ReactiveOptions<Value>);
+	constructor(callback: () => 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>);
+declare abstract class Reactive<Value> {
+	protected readonly state: ReactiveState<Value>;
+	constructor(name: string, value: Value);
 	/**
 	 * Get the value
 	 */
@@ -42,23 +42,16 @@ declare abstract class Reactive<Value, Equal = Value> {
 	 */
 	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> = {
+export type ReactiveState<Value> = {
 	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>;
+	state: ReactiveState<Value>;
 	callback: GenericCallback;
-	constructor(state: ReactiveState<Value, never>, callback: GenericCallback);
+	constructor(state: ReactiveState<Value>, 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, options?: ReactiveOptions<Value>);
+	constructor(callback: () => 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>);
+declare abstract class Reactive<Value> {
+	protected readonly state: ReactiveState<Value>;
+	constructor(name: string, value: Value);
 	/**
 	 * Get the value
 	 */
@@ -42,29 +42,22 @@ declare abstract class Reactive<Value, Equal = Value> {
 	 */
 	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> = {
+export type ReactiveState<Value> = {
 	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>;
+	state: ReactiveState<Value>;
 	callback: GenericCallback;
-	constructor(state: ReactiveState<Value, never>, callback: GenericCallback);
+	constructor(state: ReactiveState<Value>, callback: GenericCallback);
 }
 /**
  * Unsubscribe from changes
  */
 export type Unsubscribe = () => void;
-declare class ReactiveArray<Item> extends Reactive<Item[], Item> {
+declare class ReactiveArray<Item> extends Reactive<Item[]> {
 	#private;
 	/**
 	 * The length of the array
@@ -74,7 +67,7 @@ declare class ReactiveArray<Item> extends Reactive<Item[], Item> {
 	 * Set the length of the array
 	 */
 	set length(value: number);
-	constructor(value: Item[], options?: ReactiveOptions<Item>);
+	constructor(value: Item[]);
 	/**
 	 * Get an indexed item
 	 */
@@ -137,7 +130,7 @@ declare class ReactiveArray<Item> extends Reactive<Item[], Item> {
 	unshift(...items: Item[]): number;
 }
 declare class Signal<Value> extends Reactive<Value> {
-	constructor(value: Value, options?: ReactiveOptions<Value>);
+	constructor(value: 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, options?: ReactiveOptions<Value>);
+	constructor(callback: () => 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>);
+declare abstract class Reactive<Value> {
+	protected readonly state: ReactiveState<Value>;
+	constructor(name: string, value: Value);
 	/**
 	 * Get the value
 	 */
@@ -42,31 +42,24 @@ declare abstract class Reactive<Value, Equal = Value> {
 	 */
 	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> = {
+export type ReactiveState<Value> = {
 	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>;
+	state: ReactiveState<Value>;
 	callback: GenericCallback;
-	constructor(state: ReactiveState<Value, never>, callback: GenericCallback);
+	constructor(state: ReactiveState<Value>, callback: GenericCallback);
 }
 /**
  * Unsubscribe from changes
  */
 export type Unsubscribe = () => void;
-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 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 {};

package/types/helpers/value.d.ts

@@ -1,5 +1,5 @@
 import type { ReactiveState } from '../value/reactive';
-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 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;

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, options?: ReactiveOptions<Value>);
+	constructor(callback: () => 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, 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>);
+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);
 	/**
 	 * Get the value
 	 */
@@ -50,23 +50,16 @@ export declare abstract class Reactive<Value, Equal = Value> {
 	 */
 	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> = {
+export type ReactiveState<Value> = {
 	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>;
+	state: ReactiveState<Value>;
 	callback: GenericCallback;
-	constructor(state: ReactiveState<Value, never>, callback: GenericCallback);
+	constructor(state: ReactiveState<Value>, callback: GenericCallback);
 }
 /**
  * Unsubscribe from changes
@@ -80,7 +73,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[], Item> {
+export declare class ReactiveArray<Item> extends Reactive<Item[]> {
 	#private;
 	/**
 	 * The length of the array
@@ -90,7 +83,7 @@ export declare class ReactiveArray<Item> extends Reactive<Item[], Item> {
 	 * Set the length of the array
 	 */
 	set length(value: number);
-	constructor(value: Item[], options?: ReactiveOptions<Item>);
+	constructor(value: Item[]);
 	/**
 	 * Get an indexed item
 	 */
@@ -155,9 +148,9 @@ export declare class ReactiveArray<Item> extends Reactive<Item[], Item> {
 /**
  * Create a reactive array
  */
-export declare function array<Item>(value: Item[], options?: ReactiveOptions<Item>): ReactiveArray<Item>;
+export declare function array<Item>(value: Item[]): ReactiveArray<Item>;
 export declare class Signal<Value> extends Reactive<Value> {
-	constructor(value: Value, options?: ReactiveOptions<Value>);
+	constructor(value: Value);
 	/**
 	 * @inheritdoc
 	 */
@@ -174,7 +167,7 @@ export declare class Signal<Value> extends Reactive<Value> {
 /**
  * Create a reactive value
  */
-export declare function signal<Value>(value: Value, options?: ReactiveOptions<Value>): Signal<Value>;
+export declare function signal<Value>(value: 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, options?: ReactiveOptions<Value>);
+	constructor(callback: () => 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>);
+declare abstract class Reactive<Value> {
+	protected readonly state: ReactiveState<Value>;
+	constructor(name: string, value: Value);
 	/**
 	 * Get the value
 	 */
@@ -42,30 +42,23 @@ declare abstract class Reactive<Value, Equal = Value> {
 	 */
 	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> = {
+export type ReactiveState<Value> = {
 	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, never>;
+	state: ReactiveState<Value>;
 	callback: GenericCallback;
-	constructor(state: ReactiveState<Value, never>, callback: GenericCallback);
+	constructor(state: ReactiveState<Value>, callback: GenericCallback);
 }
 /**
  * Unsubscribe from changes
  */
 export type Unsubscribe = () => void;
 export declare function noop(): 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 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 {};

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, never>;
+    state: ReactiveState<Value>;
     callback: GenericCallback;
-    constructor(state: ReactiveState<Value, never>, callback: GenericCallback);
+    constructor(state: ReactiveState<Value>, callback: GenericCallback);
 }
 /**
  * Unsubscribe from changes
  */
 export type Unsubscribe = () => void;
 export declare function noop(): 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 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;

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, options?: ReactiveOptions<Value>);
+	constructor(callback: () => 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>);
+declare abstract class Reactive<Value> {
+	protected readonly state: ReactiveState<Value>;
+	constructor(name: string, value: Value);
 	/**
 	 * Get the value
 	 */
@@ -42,29 +42,22 @@ declare abstract class Reactive<Value, Equal = Value> {
 	 */
 	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> = {
+export type ReactiveState<Value> = {
 	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>;
+	state: ReactiveState<Value>;
 	callback: GenericCallback;
-	constructor(state: ReactiveState<Value, never>, callback: GenericCallback);
+	constructor(state: ReactiveState<Value>, callback: GenericCallback);
 }
 /**
  * Unsubscribe from changes
  */
 export type Unsubscribe = () => void;
-export declare class ReactiveArray<Item> extends Reactive<Item[], Item> {
+export declare class ReactiveArray<Item> extends Reactive<Item[]> {
 	#private;
 	/**
 	 * The length of the array
@@ -74,7 +67,7 @@ export declare class ReactiveArray<Item> extends Reactive<Item[], Item> {
 	 * Set the length of the array
 	 */
 	set length(value: number);
-	constructor(value: Item[], options?: ReactiveOptions<Item>);
+	constructor(value: Item[]);
 	/**
 	 * Get an indexed item
 	 */
@@ -139,6 +132,6 @@ export declare class ReactiveArray<Item> extends Reactive<Item[], Item> {
 /**
  * Create a reactive array
  */
-export declare function array<Item>(value: Item[], options?: ReactiveOptions<Item>): ReactiveArray<Item>;
+export declare function array<Item>(value: Item[]): ReactiveArray<Item>;
 
 export {};

package/types/value/array.d.ts

@@ -1,6 +1,6 @@
 import { type Computed } from './computed';
-import { Reactive, type ReactiveOptions } from './reactive';
-export declare class ReactiveArray<Item> extends Reactive<Item[], Item> {
+import { Reactive } from './reactive';
+export declare class ReactiveArray<Item> extends Reactive<Item[]> {
     #private;
     /**
      * The length of the array
@@ -10,7 +10,7 @@ export declare class ReactiveArray<Item> extends Reactive<Item[], Item> {
      * Set the length of the array
      */
     set length(value: number);
-    constructor(value: Item[], options?: ReactiveOptions<Item>);
+    constructor(value: Item[]);
     /**
      * Get an indexed item
      */
@@ -75,4 +75,4 @@ export declare class ReactiveArray<Item> extends Reactive<Item[], Item> {
 /**
  * Create a reactive array
  */
-export declare function array<Item>(value: Item[], options?: ReactiveOptions<Item>): ReactiveArray<Item>;
+export declare function array<Item>(value: 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, unknown>;
+	readonly state: ReactiveState<unknown>;
 };
 export declare let activeComputed: Computed<unknown> | undefined;
 export declare class Computed<Value> extends Reactive<Value> {
 	private readonly effect;
-	constructor(callback: () => Value, options?: ReactiveOptions<Value>);
+	constructor(callback: () => 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, 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>);
+export declare function computed<Value>(callback: () => Value): Computed<Value>;
+declare abstract class Reactive<Value> {
+	protected readonly state: ReactiveState<Value>;
+	constructor(name: string, value: Value);
 	/**
 	 * Get the value
 	 */
@@ -55,23 +55,16 @@ declare abstract class Reactive<Value, Equal = Value> {
 	 */
 	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> = {
+export type ReactiveState<Value> = {
 	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>;
+	state: ReactiveState<Value>;
 	callback: GenericCallback;
-	constructor(state: ReactiveState<Value, never>, callback: GenericCallback);
+	constructor(state: ReactiveState<Value>, callback: GenericCallback);
 }
 /**
  * Unsubscribe from changes