@oscarpalmer/mora 0.15.0 → 0.16.0

package/dist/batch.cjs

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const effect = require("./effect.cjs");
 const helpers_is = require("./helpers/is.cjs");
-function flushEffects() {
+function flushHandlers() {
   while (exports.batchDepth === 0 && batchedHandlers.size > 0) {
     const handlers = [...batchedHandlers];
     batchedHandlers.clear();
@@ -22,11 +22,11 @@ function stopBatch() {
   if (exports.batchDepth > 0) {
     exports.batchDepth -= 1;
   }
-  flushEffects();
+  flushHandlers();
 }
 const batchedHandlers = /* @__PURE__ */ new Set();
 exports.batchDepth = 0;
 exports.batchedHandlers = batchedHandlers;
-exports.flushEffects = flushEffects;
+exports.flushHandlers = flushHandlers;
 exports.startBatch = startBatch;
 exports.stopBatch = stopBatch;

package/dist/batch.js

@@ -1,6 +1,6 @@
 import { runEffect } from "./effect.js";
 import { isEffect } from "./helpers/is.js";
-function flushEffects() {
+function flushHandlers() {
   while (batchDepth === 0 && batchedHandlers.size > 0) {
     const handlers = [...batchedHandlers];
     batchedHandlers.clear();
@@ -20,14 +20,14 @@ function stopBatch() {
   if (batchDepth > 0) {
     batchDepth -= 1;
   }
-  flushEffects();
+  flushHandlers();
 }
 const batchedHandlers = /* @__PURE__ */ new Set();
 let batchDepth = 0;
 export {
   batchDepth,
   batchedHandlers,
-  flushEffects,
+  flushHandlers,
   startBatch,
   stopBatch
 };

package/dist/helpers/value.cjs

@@ -1,8 +1,48 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const batch = require("../batch.cjs");
 const effect = require("../effect.cjs");
 const value_computed = require("../value/computed.cjs");
-const helpers_emit = require("./emit.cjs");
+function differentArrays(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 differentValues(first, second) {
+  return Array.isArray(first) && Array.isArray(second) ? differentArrays(first, second) : !Object.is(first, second);
+}
+function emitValue(state) {
+  for (const computed of state.computeds) {
+    computed.effect.dirty = true;
+  }
+  for (const effect2 of state.effects) {
+    batch.batchedHandlers.add(effect2);
+  }
+  for (const [, subscription] of state.subscriptions) {
+    batch.batchedHandlers.add(subscription);
+  }
+  if (batch.batchDepth === 0) {
+    batch.flushHandlers();
+  }
+}
 function getValue(state) {
   if (value_computed.activeComputed != null) {
     state.computeds.add(value_computed.activeComputed);
@@ -12,11 +52,7 @@ function getValue(state) {
   }
   return state.value;
 }
-function setValue(state, value) {
-  if (!Object.is(state.value, value)) {
-    state.value = value;
-    helpers_emit.emitValue(state);
-  }
-}
+exports.differentArrays = differentArrays;
+exports.differentValues = differentValues;
+exports.emitValue = emitValue;
 exports.getValue = getValue;
-exports.setValue = setValue;

package/dist/helpers/value.js

@@ -1,6 +1,46 @@
+import { batchedHandlers, batchDepth, flushHandlers } from "../batch.js";
 import { activeEffect } from "../effect.js";
 import { activeComputed } from "../value/computed.js";
-import { emitValue } from "./emit.js";
+function differentArrays(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 differentValues(first, second) {
+  return Array.isArray(first) && Array.isArray(second) ? differentArrays(first, second) : !Object.is(first, second);
+}
+function emitValue(state) {
+  for (const computed of state.computeds) {
+    computed.effect.dirty = true;
+  }
+  for (const effect of state.effects) {
+    batchedHandlers.add(effect);
+  }
+  for (const [, subscription] of state.subscriptions) {
+    batchedHandlers.add(subscription);
+  }
+  if (batchDepth === 0) {
+    flushHandlers();
+  }
+}
 function getValue(state) {
   if (activeComputed != null) {
     state.computeds.add(activeComputed);
@@ -10,13 +50,9 @@ function getValue(state) {
   }
   return state.value;
 }
-function setValue(state, value) {
-  if (!Object.is(state.value, value)) {
-    state.value = value;
-    emitValue(state);
-  }
-}
 export {
-  getValue,
-  setValue
+  differentArrays,
+  differentValues,
+  emitValue,
+  getValue
 };

package/dist/mora.full.js

@@ -68,7 +68,7 @@ function effect(callback) {
 }
 let activeEffect;
 
-function flushEffects() {
+function flushHandlers() {
     while (batchDepth === 0 && batchedHandlers.size > 0) {
         const handlers = [...batchedHandlers];
         batchedHandlers.clear();
@@ -95,49 +95,11 @@ function stopBatch() {
     if (batchDepth > 0) {
         batchDepth -= 1;
     }
-    flushEffects();
+    flushHandlers();
 }
 const batchedHandlers = new Set();
 let batchDepth = 0;
 
-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) {
-        batchedHandlers.add(effect);
-    }
-    for (const [, subscription] of state.subscriptions) {
-        batchedHandlers.add(subscription);
-    }
-    if (batchDepth === 0) {
-        flushEffects();
-    }
-}
-
 class Subscription {
     state;
     callback;
@@ -245,7 +207,7 @@ class Computed extends Reactive {
      * @inheritdoc
      */
     get() {
-        if (activeComputed != null && activeComputed !== this) {
+        if (activeComputed != null && this !== activeComputed) {
             this.state.computeds.add(activeComputed);
         }
         if (activeEffect != null && activeEffect !== this.effect.instance) {
@@ -264,6 +226,48 @@ function computed(callback) {
     return new Computed(callback);
 }
 
+function differentArrays(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 differentValues(first, second) {
+    return Array.isArray(first) && Array.isArray(second)
+        ? differentArrays(first, second)
+        : !Object.is(first, second);
+}
+function emitValue(state) {
+    for (const computed of state.computeds) {
+        computed.effect.dirty = true;
+    }
+    for (const effect of state.effects) {
+        batchedHandlers.add(effect);
+    }
+    for (const [, subscription] of state.subscriptions) {
+        batchedHandlers.add(subscription);
+    }
+    if (batchDepth === 0) {
+        flushHandlers();
+    }
+}
 function getValue(state) {
     if (activeComputed != null) {
         state.computeds.add(activeComputed);
@@ -273,12 +277,6 @@ function getValue(state) {
     }
     return state.value;
 }
-function setValue$1(state, value) {
-    if (!Object.is(state.value, value)) {
-        state.value = value;
-        emitValue(state);
-    }
-}
 
 class Signal extends Reactive {
     constructor(value) {
@@ -294,7 +292,10 @@ class Signal extends Reactive {
      * Set the value
      */
     set(value) {
-        setValue$1(this.state, value);
+        if (differentValues(this.state.value, value)) {
+            this.state.value = value;
+            emitValue(this.state);
+        }
     }
     /**
      * Update the value
@@ -343,6 +344,12 @@ class ReactiveArray extends Reactive {
     at(index) {
         return this.get().at(index);
     }
+    /**
+     * Clear the array
+     */
+    clear() {
+        this.length = 0;
+    }
     /**
      * @inheritdoc
      */
@@ -434,7 +441,7 @@ function updateArray(type, array, state, length) {
         const result = array[type](...args);
         if (affectsLength
             ? array.length !== previousLength
-            : emitArrayChanges(previousArray, array)) {
+            : differentArrays(previousArray, array)) {
             emitValue(state);
             length.set(array.length);
         }

package/dist/value/array.cjs

@@ -7,7 +7,6 @@ var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read fr
 var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
 var _size;
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const helpers_emit = require("../helpers/emit.cjs");
 const helpers_is = require("../helpers/is.cjs");
 const helpers_value = require("../helpers/value.cjs");
 const value_computed = require("./computed.cjs");
@@ -45,6 +44,12 @@ class ReactiveArray extends value_reactive.Reactive {
   at(index) {
     return this.get().at(index);
   }
+  /**
+   * Clear the array
+   */
+  clear() {
+    this.length = 0;
+  }
   /**
    * @inheritdoc
    */
@@ -123,7 +128,7 @@ function setValue(target, property, value, state, length) {
   const previous = Reflect.get(target, property);
   if (!Object.is(previous, value)) {
     Reflect.set(target, property, value);
-    helpers_emit.emitValue(state);
+    helpers_value.emitValue(state);
     length.set(target.length);
   }
   return true;
@@ -136,8 +141,8 @@ function updateArray(type, array2, state, length) {
     const result = array2[type](
       ...args
     );
-    if (affectsLength ? array2.length !== previousLength : helpers_emit.emitArrayChanges(previousArray, array2)) {
-      helpers_emit.emitValue(state);
+    if (affectsLength ? array2.length !== previousLength : helpers_value.differentArrays(previousArray, array2)) {
+      helpers_value.emitValue(state);
       length.set(array2.length);
     }
     return result;

package/dist/value/array.js

@@ -5,9 +5,8 @@ var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot
 var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
 var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
 var _size;
-import { emitValue, emitArrayChanges } from "../helpers/emit.js";
 import { arrayName } from "../helpers/is.js";
-import { getValue } from "../helpers/value.js";
+import { getValue, emitValue, differentArrays } from "../helpers/value.js";
 import { computed } from "./computed.js";
 import { Reactive } from "./reactive.js";
 import { signal } from "./signal.js";
@@ -43,6 +42,12 @@ class ReactiveArray extends Reactive {
   at(index) {
     return this.get().at(index);
   }
+  /**
+   * Clear the array
+   */
+  clear() {
+    this.length = 0;
+  }
   /**
    * @inheritdoc
    */
@@ -134,7 +139,7 @@ function updateArray(type, array2, state, length) {
     const result = array2[type](
       ...args
     );
-    if (affectsLength ? array2.length !== previousLength : emitArrayChanges(previousArray, array2)) {
+    if (affectsLength ? array2.length !== previousLength : differentArrays(previousArray, array2)) {
       emitValue(state);
       length.set(array2.length);
     }

package/dist/value/computed.cjs

@@ -41,7 +41,7 @@ class Computed extends value_reactive.Reactive {
    * @inheritdoc
    */
   get() {
-    if (exports.activeComputed != null && exports.activeComputed !== this) {
+    if (exports.activeComputed != null && this !== exports.activeComputed) {
       this.state.computeds.add(exports.activeComputed);
     }
     if (effect.activeEffect != null && effect.activeEffect !== this.effect.instance) {

package/dist/value/computed.js

@@ -39,7 +39,7 @@ class Computed extends Reactive {
    * @inheritdoc
    */
   get() {
-    if (activeComputed != null && activeComputed !== this) {
+    if (activeComputed != null && this !== activeComputed) {
       this.state.computeds.add(activeComputed);
     }
     if (activeEffect != null && activeEffect !== this.effect.instance) {

package/dist/value/signal.cjs

@@ -17,7 +17,10 @@ class Signal extends value_reactive.Reactive {
    * Set the value
    */
   set(value) {
-    helpers_value.setValue(this.state, value);
+    if (helpers_value.differentValues(this.state.value, value)) {
+      this.state.value = value;
+      helpers_value.emitValue(this.state);
+    }
   }
   /**
    * Update the value

package/dist/value/signal.js

@@ -1,5 +1,5 @@
 import { signalName } from "../helpers/is.js";
-import { getValue, setValue } from "../helpers/value.js";
+import { getValue, differentValues, emitValue } from "../helpers/value.js";
 import { Reactive } from "./reactive.js";
 class Signal extends Reactive {
   constructor(value) {
@@ -15,7 +15,10 @@ class Signal extends Reactive {
    * Set the value
    */
   set(value) {
-    setValue(this.state, value);
+    if (differentValues(this.state.value, value)) {
+      this.state.value = value;
+      emitValue(this.state);
+    }
   }
   /**
    * Update the value

package/package.json

@@ -12,14 +12,14 @@
 		"@rollup/plugin-node-resolve": "^16",
 		"@rollup/plugin-typescript": "^12.1",
 		"@types/node": "^22.15",
-		"@vitest/coverage-istanbul": "^3.1",
+		"@vitest/coverage-istanbul": "^3.2",
 		"dts-bundle-generator": "^9.5",
 		"glob": "^11",
 		"jsdom": "^26.1",
 		"tslib": "^2.8",
 		"typescript": "^5.8",
 		"vite": "^6.3",
-		"vitest": "^3.1"
+		"vitest": "^3.2"
 	},
 	"exports": {
 		".": {
@@ -54,5 +54,5 @@
 	},
 	"type": "module",
 	"types": "./types/index.d.ts",
-	"version": "0.15.0"
+	"version": "0.16.0"
 }

package/src/batch.ts

@@ -2,7 +2,7 @@ import {type Effect, runEffect} from './effect';
 import {isEffect} from './helpers/is';
 import type {Subscription} from './subscription';
 
-export function flushEffects(): void {
+export function flushHandlers(): void {
 	while (batchDepth === 0 && batchedHandlers.size > 0) {
 		const handlers = [...batchedHandlers];
 
@@ -33,7 +33,7 @@ export function stopBatch(): void {
 		batchDepth -= 1;
 	}
 
-	flushEffects();
+	flushHandlers();
 }
 
 export const batchedHandlers = new Set<Effect | Subscription<unknown>>();

package/src/helpers/is.ts

@@ -3,7 +3,7 @@ import type {Effect} from '../effect';
 import type {ReactiveArray} from '../value/array';
 import type {Computed} from '../value/computed';
 import type {Reactive} from '../value/reactive';
-import {signal, type Signal} from '../value/signal';
+import type {Signal} from '../value/signal';
 
 /**
  * Is the value a reactive array?

package/src/helpers/value.ts

@@ -1,7 +1,62 @@
+import {batchDepth, batchedHandlers, flushHandlers} from '../batch';
 import {activeEffect} from '../effect';
-import {activeComputed} from '../value/computed';
+import {type InternalComputed, activeComputed} from '../value/computed';
 import type {ReactiveState} from '../value/reactive';
-import {emitValue} from './emit';
+
+export function differentArrays(first: unknown[], second: unknown[]): boolean {
+	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;
+}
+
+export function differentValues(first: unknown, second: unknown): boolean {
+	return Array.isArray(first) && Array.isArray(second)
+		? differentArrays(first, second)
+		: !Object.is(first, second);
+}
+
+export function emitValue<Value>(state: ReactiveState<Value>): void {
+	for (const computed of state.computeds) {
+		(computed as unknown as InternalComputed).effect.dirty = true;
+	}
+
+	for (const effect of state.effects) {
+		batchedHandlers.add(effect);
+	}
+
+	for (const [, subscription] of state.subscriptions) {
+		batchedHandlers.add(subscription as never);
+	}
+
+	if (batchDepth === 0) {
+		flushHandlers();
+	}
+}
 
 export function getValue<Value>(state: ReactiveState<Value>): Value {
 	if (activeComputed != null) {
@@ -14,14 +69,3 @@ export function getValue<Value>(state: ReactiveState<Value>): Value {
 
 	return state.value;
 }
-
-export function setValue<Value>(
-	state: ReactiveState<Value>,
-	value: Value,
-): void {
-	if (!Object.is(state.value, value)) {
-		state.value = value;
-
-		emitValue(state);
-	}
-}

package/src/value/array.ts

@@ -1,6 +1,5 @@
-import {emitArrayChanges, emitValue} from '../helpers/emit';
 import {arrayName} from '../helpers/is';
-import {getValue} from '../helpers/value';
+import {differentArrays, emitValue, getValue} from '../helpers/value';
 import {type Computed, computed} from './computed';
 import {Reactive, type ReactiveState} from './reactive';
 import {type Signal, signal} from './signal';
@@ -51,6 +50,13 @@ export class ReactiveArray<Item> extends Reactive<Item[]> {
 		return this.get().at(index);
 	}
 
+	/**
+	 * Clear the array
+	 */
+	clear(): void {
+		this.length = 0;
+	}
+
 	/**
 	 * @inheritdoc
 	 */
@@ -207,7 +213,7 @@ function updateArray<Item>(
 		if (
 			affectsLength
 				? array.length !== previousLength
-				: emitArrayChanges(previousArray, array)
+				: differentArrays(previousArray, array)
 		) {
 			emitValue(state);
 

package/src/value/computed.ts

@@ -3,7 +3,7 @@ import {type Effect, activeEffect, effect, runEffect} from '../effect';
 import {computedName} from '../helpers/is';
 import {Reactive, type ReactiveState} from './reactive';
 
-type ComputedEffect = {
+export type ComputedEffect = {
 	dirty: boolean;
 	instance: Effect;
 };
@@ -59,7 +59,7 @@ export class Computed<Value> extends Reactive<Value> {
 	 * @inheritdoc
 	 */
 	get(): Value {
-		if (activeComputed != null && activeComputed !== this) {
+		if (activeComputed != null && this !== activeComputed) {
 			this.state.computeds.add(activeComputed);
 		}
 

package/src/value/signal.ts

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

package/types/batch.d.cts

@@ -57,7 +57,7 @@ declare class Subscription<Value> {
  * Unsubscribe from changes
  */
 export type Unsubscribe = () => void;
-export declare function flushEffects(): void;
+export declare function flushHandlers(): void;
 /**
  * Start batching effects _(use `stopBatch` to flush and run batched effects)_
  */

package/types/batch.d.ts

@@ -1,6 +1,6 @@
 import { type Effect } from './effect';
 import type { Subscription } from './subscription';
-export declare function flushEffects(): void;
+export declare function flushHandlers(): void;
 /**
  * Start batching effects _(use `stopBatch` to flush and run batched effects)_
  */

package/types/helpers/is.d.cts

@@ -72,6 +72,10 @@ declare class ReactiveArray<Item> extends Reactive<Item[]> {
 	 * Get an indexed item
 	 */
 	at(index: number): Item | undefined;
+	/**
+	 * Clear the array
+	 */
+	clear(): void;
 	/**
 	 * @inheritdoc
 	 */

package/types/helpers/is.d.ts

@@ -2,7 +2,7 @@ import type { Effect } from '../effect';
 import type { ReactiveArray } from '../value/array';
 import type { Computed } from '../value/computed';
 import type { Reactive } from '../value/reactive';
-import { type Signal } from '../value/signal';
+import type { Signal } from '../value/signal';
 /**
  * Is the value a reactive array?
  */

package/types/helpers/value.d.cts

@@ -57,7 +57,9 @@ declare class Subscription<Value> {
  * 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 setValue<Value>(state: ReactiveState<Value>, value: Value): void;
 
 export {};

package/types/helpers/value.d.ts

@@ -1,3 +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 setValue<Value>(state: ReactiveState<Value>, value: Value): void;

package/types/index.d.cts

@@ -88,6 +88,10 @@ export declare class ReactiveArray<Item> extends Reactive<Item[]> {
 	 * Get an indexed item
 	 */
 	at(index: number): Item | undefined;
+	/**
+	 * Clear the array
+	 */
+	clear(): void;
 	/**
 	 * @inheritdoc
 	 */

package/types/value/array.d.cts

@@ -72,6 +72,10 @@ export declare class ReactiveArray<Item> extends Reactive<Item[]> {
 	 * Get an indexed item
 	 */
 	at(index: number): Item | undefined;
+	/**
+	 * Clear the array
+	 */
+	clear(): void;
 	/**
 	 * @inheritdoc
 	 */

package/types/value/array.d.ts

@@ -15,6 +15,10 @@ export declare class ReactiveArray<Item> extends Reactive<Item[]> {
      * Get an indexed item
      */
     at(index: number): Item | undefined;
+    /**
+     * Clear the array
+     */
+    clear(): void;
     /**
      * @inheritdoc
      */

package/types/value/computed.d.ts

@@ -1,6 +1,6 @@
 import { type Effect } from '../effect';
 import { Reactive, type ReactiveState } from './reactive';
-type ComputedEffect = {
+export type ComputedEffect = {
     dirty: boolean;
     instance: Effect;
 };
@@ -21,4 +21,3 @@ export declare class Computed<Value> extends Reactive<Value> {
  * Create a computed value
  */
 export declare function computed<Value>(callback: () => Value): Computed<Value>;
-export {};

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;

package/dist/helpers/emit.js

@@ -1,42 +0,0 @@
-import { batchedHandlers, batchDepth, flushEffects } from "../batch.js";
-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) {
-    batchedHandlers.add(effect);
-  }
-  for (const [, subscription] of state.subscriptions) {
-    batchedHandlers.add(subscription);
-  }
-  if (batchDepth === 0) {
-    flushEffects();
-  }
-}
-export {
-  emitArrayChanges,
-  emitValue
-};

package/src/helpers/emit.ts

@@ -1,52 +0,0 @@
-import {batchDepth, batchedHandlers, flushEffects} from '../batch';
-import type {InternalComputed} from '../value/computed';
-import type {ReactiveState} from '../value/reactive';
-
-export function emitArrayChanges(first: unknown[], second: unknown[]): boolean {
-	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;
-}
-
-export function emitValue<Value>(state: ReactiveState<Value>): void {
-	for (const computed of state.computeds) {
-		(computed as unknown as InternalComputed).effect.dirty = true;
-	}
-
-	for (const effect of state.effects) {
-		batchedHandlers.add(effect);
-	}
-
-	for (const [, subscription] of state.subscriptions) {
-		batchedHandlers.add(subscription as never);
-	}
-
-	if (batchDepth === 0) {
-		flushEffects();
-	}
-}

package/types/helpers/emit.d.cts

@@ -1,63 +0,0 @@
-// Generated by dts-bundle-generator v9.5.1
-
-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);
-	/**
-	 * @inheritdoc
-	 */
-	get(): Value;
-}
-declare abstract class Reactive<Value> {
-	protected readonly state: ReactiveState<Value>;
-	constructor(name: string, value: Value);
-	/**
-	 * 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 ReactiveState<Value> = {
-	computeds: Set<Computed<unknown>>;
-	effects: Set<Effect>;
-	subscriptions: Map<(value: Value) => void, Subscription<Value>>;
-	value: Value;
-};
-declare class Subscription<Value> {
-	state: ReactiveState<Value>;
-	callback: GenericCallback;
-	constructor(state: ReactiveState<Value>, callback: GenericCallback);
-}
-/**
- * Unsubscribe from changes
- */
-export type Unsubscribe = () => void;
-export declare function emitArrayChanges(first: unknown[], second: unknown[]): boolean;
-export declare function emitValue<Value>(state: ReactiveState<Value>): void;
-
-export {};

package/types/helpers/emit.d.ts

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