@oscarpalmer/mora 0.15.0 → 0.17.0

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,22 +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 getValue<Value>(state: ReactiveState<Value>): Value;
-export declare function setValue<Value>(state: ReactiveState<Value>, value: Value): 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 {};

package/types/helpers/value.d.ts

@@ -1,3 +1,5 @@
 import type { ReactiveState } from '../value/reactive';
-export declare function getValue<Value>(state: ReactiveState<Value>): Value;
-export declare function setValue<Value>(state: ReactiveState<Value>, value: Value): 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;

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,11 +90,15 @@ 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
 	 */
 	at(index: number): Item | undefined;
+	/**
+	 * Clear the array
+	 */
+	clear(): void;
 	/**
 	 * @inheritdoc
 	 */
@@ -144,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
 	 */
@@ -163,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,11 +74,15 @@ 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
 	 */
 	at(index: number): Item | undefined;
+	/**
+	 * Clear the array
+	 */
+	clear(): void;
 	/**
 	 * @inheritdoc
 	 */
@@ -128,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,11 +10,15 @@ 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
      */
     at(index: number): Item | undefined;
+    /**
+     * Clear the array
+     */
+    clear(): void;
     /**
      * @inheritdoc
      */
@@ -71,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';
-type ComputedEffect = {
+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,5 +20,4 @@ export declare class Computed<Value> extends Reactive<Value> {
 /**
  * Create a computed value
  */
-export declare function computed<Value>(callback: () => Value): Computed<Value>;
-export {};
+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;
 };

package/types/value/signal.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;
 };
 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 Signal<Value> extends Reactive<Value> {
-	constructor(value: Value);
+	constructor(value: Value, options?: ReactiveOptions<Value>);
 	/**
 	 * @inheritdoc
 	 */
@@ -75,6 +82,6 @@ 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 {};

package/types/value/signal.d.ts

@@ -1,6 +1,6 @@
-import { Reactive } from './reactive';
+import { Reactive, type ReactiveOptions } from './reactive';
 export declare class Signal<Value> extends Reactive<Value> {
-    constructor(value: Value);
+    constructor(value: Value, options?: ReactiveOptions<Value>);
     /**
      * @inheritdoc
      */
@@ -17,4 +17,4 @@ 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>;

package/dist/helpers/emit.cjs

@@ -1,42 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const batch = require("../batch.cjs");
-function emitArrayChanges(first, second) {
-  let { length } = first;
-  if (length !== second.length) {
-    return true;
-  }
-  let offset = 0;
-  if (length >= 100) {
-    offset = Math.round(length / 10);
-    offset = offset > 25 ? 25 : offset;
-    for (let index = 0; index < offset; index += 1) {
-      if (!Object.is(first[index], second[index])) {
-        return true;
-      }
-    }
-  }
-  length -= offset;
-  for (let index = offset; index < length; index += 1) {
-    if (!Object.is(first[index], second[index])) {
-      return true;
-    }
-  }
-  return false;
-}
-function emitValue(state) {
-  for (const computed of state.computeds) {
-    computed.effect.dirty = true;
-  }
-  for (const effect of state.effects) {
-    batch.batchedHandlers.add(effect);
-  }
-  for (const [, subscription] of state.subscriptions) {
-    batch.batchedHandlers.add(subscription);
-  }
-  if (batch.batchDepth === 0) {
-    batch.flushEffects();
-  }
-}
-exports.emitArrayChanges = emitArrayChanges;
-exports.emitValue = emitValue;