@oscarpalmer/mora 0.22.0 → 0.24.0

package/dist/batch.js

@@ -1,20 +1,19 @@
-import { isEffect } from "./helpers/is.js";
+import { BATCH } from "./constants.js";
 import { runEffect } from "./effect.js";
+import { isEffect } from "./helpers/is.js";
 function flushHandlers() {
-	while (batchDepth === 0 && batchedHandlers.size > 0) {
-		const handlers = [...batchedHandlers];
-		batchedHandlers.clear();
+	while (BATCH.depth === 0 && BATCH.handlers.size > 0) {
+		const handlers = [...BATCH.handlers];
+		BATCH.handlers.clear();
 		for (const handler of handlers) if (isEffect(handler)) runEffect(handler);
 		else handler.callback(handler.state.value);
 	}
 }
 function startBatch() {
-	batchDepth += 1;
+	BATCH.depth += 1;
 }
 function stopBatch() {
-	if (batchDepth > 0) batchDepth -= 1;
+	if (BATCH.depth > 0) BATCH.depth -= 1;
 	flushHandlers();
 }
-const batchedHandlers = /* @__PURE__ */ new Set();
-let batchDepth = 0;
-export { batchDepth, batchedHandlers, flushHandlers, startBatch, stopBatch };
+export { flushHandlers, startBatch, stopBatch };

package/dist/constants.js

@@ -0,0 +1,36 @@
+const ACTIVE = {};
+const ARRAY_THRESHOLD = 100;
+const ARRAY_OFFSET = 25;
+const ARRAY_PEEK = 10;
+const BATCH = {
+	depth: 0,
+	handlers: /* @__PURE__ */ new Set()
+};
+const METHODS_AFFECTING_LENGTH = new Set([
+	"pop",
+	"push",
+	"shift",
+	"unshift"
+]);
+const METHODS_UPDATE = new Set([
+	...METHODS_AFFECTING_LENGTH,
+	"copyWithin",
+	"fill",
+	"reverse",
+	"sort",
+	"splice"
+]);
+const NAME_ARRAY = "array";
+const NAME_COMPUTED = "computed";
+const NAME_EFFECT = "effect";
+const NAME_MORA = "$mora";
+const NAME_SIGNAL = "signal";
+const NAME_STORE = "store";
+const NAMES = new Set([
+	NAME_ARRAY,
+	NAME_COMPUTED,
+	NAME_SIGNAL,
+	NAME_STORE
+]);
+const PROPERTY_LENGTH = "length";
+export { ACTIVE, ARRAY_OFFSET, ARRAY_PEEK, ARRAY_THRESHOLD, BATCH, METHODS_AFFECTING_LENGTH, METHODS_UPDATE, NAMES, NAME_ARRAY, NAME_COMPUTED, NAME_EFFECT, NAME_MORA, NAME_SIGNAL, NAME_STORE, PROPERTY_LENGTH };

package/dist/effect.js

@@ -1,22 +1,21 @@
-import { effectName } from "./helpers/is.js";
+import { ACTIVE, NAME_EFFECT, NAME_MORA } from "./constants.js";
 var Effect = class {
 	constructor(callback) {
-		Object.defineProperty(this, "$mora", { value: effectName });
+		Object.defineProperty(this, NAME_MORA, { value: NAME_EFFECT });
 		this.state = { callback };
 		runEffect(this);
 	}
 };
 function runEffect(effect$1) {
-	const previousEffect = activeEffect;
-	activeEffect = effect$1;
+	const previousEffect = ACTIVE.effect;
+	ACTIVE.effect = effect$1;
 	try {
 		effect$1.state.callback();
 	} finally {
-		activeEffect = previousEffect;
+		ACTIVE.effect = previousEffect;
 	}
 }
 function effect(callback) {
-	return new Effect(callback);
+	return typeof callback === "function" ? new Effect(callback) : void 0;
 }
-let activeEffect;
-export { Effect, activeEffect, effect, runEffect };
+export { Effect, effect, runEffect };

package/dist/helpers/is.js

@@ -1,33 +1,23 @@
+import { NAMES, NAME_ARRAY, NAME_COMPUTED, NAME_EFFECT, NAME_MORA, NAME_SIGNAL, NAME_STORE } from "../constants.js";
 function isArray(value) {
-	return isMora(value, arrayName);
+	return isMora(value, NAME_ARRAY);
 }
 function isComputed(value) {
-	return isMora(value, computedName);
+	return isMora(value, NAME_COMPUTED);
 }
 function isEffect(value) {
-	return isMora(value, effectName);
+	return isMora(value, NAME_EFFECT);
 }
 function isMora(value, name) {
-	return typeof value === "object" && value != null && "$mora" in value && (typeof name === "string" ? value.$mora === name : name.has(value.$mora));
+	return typeof value === "object" && value != null && "$mora" in value && (typeof name === "string" ? value["$mora"] === name : name.has(value["$mora"]));
 }
 function isReactive(value) {
-	return isMora(value, reactiveNames);
+	return isMora(value, NAMES);
 }
 function isSignal(value) {
-	return isMora(value, signalName);
+	return isMora(value, NAME_SIGNAL);
 }
 function isStore(value) {
-	return isMora(value, storeName);
+	return isMora(value, NAME_STORE);
 }
-const arrayName = "array";
-const computedName = "computed";
-const effectName = "effect";
-const signalName = "signal";
-const storeName = "store";
-var reactiveNames = new Set([
-	arrayName,
-	computedName,
-	signalName,
-	storeName
-]);
-export { arrayName, computedName, effectName, isArray, isComputed, isEffect, isReactive, isSignal, isStore, signalName, storeName };
+export { isArray, isComputed, isEffect, isReactive, isSignal, isStore };

package/dist/helpers/proxy.js

@@ -1,13 +1,17 @@
+import { PROPERTY_LENGTH } from "../constants.js";
 import { startBatch, stopBatch } from "../batch.js";
 import { computed } from "../value/computed.js";
 import { emitValue } from "./value.js";
+function emityProxyValues(state, mapped) {
+	const values = [...mapped.values()];
+	const { length } = values;
+	for (let index = 0; index < length; index += 1) values[index].effect.dirty = true;
+	emitValue(state);
+}
 function getReactiveValueInProxy(reactive, mapped, key, isArray) {
 	let item = mapped.get(key);
 	if (item == null) {
-		item = computed(() => {
-			const value = reactive.get();
-			return isArray ? value.at(key) : value[key];
-		});
+		item = computed(() => isArray ? reactive.get().at(key) : reactive.get()[key]);
 		mapped.set(key, item);
 	}
 	return item;
@@ -28,9 +32,10 @@ function setProxyValue(proxy, value) {
 	}
 	stopBatch();
 }
-function setValueInProxy(target, property, value, state, isArray, length) {
+function setValueInProxy(parameters) {
+	const { isArray, length, property, state, target, value } = parameters;
 	if (isArray) {
-		if (!!Number.isNaN(Number(property)) && !(property === "length")) return Reflect.set(target, property, value);
+		if (!(!Number.isNaN(Number(property)) || property === "length")) return Reflect.set(target, property, value);
 	}
 	const previous = Reflect.get(target, property);
 	if (!state.equal(previous, value)) {
@@ -40,4 +45,4 @@ function setValueInProxy(target, property, value, state, isArray, length) {
 	}
 	return true;
 }
-export { getReactiveValueInProxy, setProxyValue, setValueInProxy };
+export { emityProxyValues, getReactiveValueInProxy, setProxyValue, setValueInProxy };

package/dist/helpers/value.js

@@ -1,11 +1,10 @@
-import { activeEffect } from "../effect.js";
-import { batchDepth, batchedHandlers, flushHandlers } from "../batch.js";
-import { activeComputed } from "../value/computed.js";
+import { ACTIVE, ARRAY_OFFSET, ARRAY_PEEK, ARRAY_THRESHOLD, BATCH } from "../constants.js";
+import { flushHandlers } from "../batch.js";
 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();
+	for (const effect of state.effects) BATCH.handlers.add(effect);
+	for (const [, subscription] of state.subscriptions) BATCH.handlers.add(subscription);
+	if (BATCH.depth === 0) flushHandlers();
 }
 function equalArrays(state, first, second) {
 	let { length } = first;
@@ -21,8 +20,8 @@ function equalArrays(state, first, second) {
 	return true;
 }
 function getValue(state) {
-	if (activeComputed != null) state.computeds.add(activeComputed);
-	if (activeEffect != null) state.effects.add(activeEffect);
+	if (ACTIVE.computed != null) state.computeds.add(ACTIVE.computed);
+	if (ACTIVE.effect != null) state.effects.add(ACTIVE.effect);
 	return state.value;
 }
 export { emitValue, equalArrays, getValue };

package/dist/index.js

@@ -1,5 +1,5 @@
-import { isArray, isComputed, isEffect, isReactive, isSignal } from "./helpers/is.js";
 import { effect } from "./effect.js";
+import { isArray, isComputed, isEffect, isReactive, isSignal } from "./helpers/is.js";
 import { startBatch, stopBatch } from "./batch.js";
 import { computed } from "./value/computed.js";
 import { signal } from "./value/signal.js";