@oscarpalmer/mora 0.21.0 → 0.23.0

package/dist/batch.js

@@ -1,33 +1,19 @@
+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();
-    for (const handler of handlers) {
-      if (isEffect(handler)) {
-        runEffect(handler);
-      } else {
-        handler.callback(handler.state.value);
-      }
-    }
-  }
+	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;
-  }
-  flushHandlers();
+	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,34 @@
+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_SIGNAL = "signal";
+const NAME_STORE = "store";
+const NAMES = new Set([
+	NAME_ARRAY,
+	NAME_COMPUTED,
+	NAME_SIGNAL,
+	NAME_STORE
+]);
+export { ACTIVE, ARRAY_OFFSET, ARRAY_PEEK, ARRAY_THRESHOLD, BATCH, METHODS_AFFECTING_LENGTH, METHODS_UPDATE, NAMES, NAME_ARRAY, NAME_COMPUTED, NAME_EFFECT, NAME_SIGNAL, NAME_STORE };

package/dist/effect.js

@@ -1,31 +1,21 @@
-import { effectName } from "./helpers/is.js";
-class Effect {
-  constructor(callback) {
-    Object.defineProperty(this, "$mora", {
-      value: effectName
-    });
-    this.state = {
-      callback
-    };
-    runEffect(this);
-  }
-}
-function runEffect(effect2) {
-  const previousEffect = activeEffect;
-  activeEffect = effect2;
-  try {
-    effect2.state.callback();
-  } finally {
-    activeEffect = previousEffect;
-  }
+import { ACTIVE, NAME_EFFECT } from "./constants.js";
+var Effect = class {
+	constructor(callback) {
+		Object.defineProperty(this, "$mora", { value: NAME_EFFECT });
+		this.state = { callback };
+		runEffect(this);
+	}
+};
+function runEffect(effect$1) {
+	const previousEffect = ACTIVE.effect;
+	ACTIVE.effect = effect$1;
+	try {
+		effect$1.state.callback();
+	} finally {
+		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,40 +1,23 @@
+import { NAMES, NAME_ARRAY, NAME_COMPUTED, NAME_EFFECT, 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";
-const reactiveNames = /* @__PURE__ */ 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

@@ -2,55 +2,43 @@ import { startBatch, stopBatch } from "../batch.js";
 import { computed } from "../value/computed.js";
 import { emitValue } from "./value.js";
 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];
-    });
-    mapped.set(key, item);
-  }
-  return item;
+	let item = mapped.get(key);
+	if (item == null) {
+		item = computed(() => {
+			const value = reactive.get();
+			return isArray ? value.at(key) : value[key];
+		});
+		mapped.set(key, item);
+	}
+	return item;
 }
 function setProxyValue(proxy, value) {
-  startBatch();
-  const proxyKeys = Object.keys(proxy);
-  const valueKeys = Object.keys(value);
-  let { length } = proxyKeys;
-  for (let index = 0; index < length; index += 1) {
-    const key = proxyKeys[index];
-    proxy[key] = valueKeys.includes(key) ? value[key] : void 0;
-  }
-  length = valueKeys.length;
-  for (let index = 0; index < length; index += 1) {
-    const key = valueKeys[index];
-    if (!proxyKeys.includes(key)) {
-      const keyedValue = value[key];
-      proxy[key] = keyedValue;
-    }
-  }
-  stopBatch();
+	startBatch();
+	const proxyKeys = Object.keys(proxy);
+	const valueKeys = Object.keys(value);
+	let { length } = proxyKeys;
+	for (let index = 0; index < length; index += 1) {
+		const key = proxyKeys[index];
+		proxy[key] = valueKeys.includes(key) ? value[key] : void 0;
+	}
+	length = valueKeys.length;
+	for (let index = 0; index < length; index += 1) {
+		const key = valueKeys[index];
+		if (!proxyKeys.includes(key)) proxy[key] = value[key];
+	}
+	stopBatch();
 }
-function setValueInProxy(target, property, value, state, isArray, length) {
-  if (isArray) {
-    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);
-    if (isArray) {
-      length == null ? void 0 : length.set(target.length);
-    }
-  }
-  return true;
+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);
+	}
+	const previous = Reflect.get(target, property);
+	if (!state.equal(previous, value)) {
+		Reflect.set(target, property, value);
+		emitValue(state);
+		if (isArray) length?.set(target.length);
+	}
+	return true;
 }
-export {
-  getReactiveValueInProxy,
-  setProxyValue,
-  setValueInProxy
-};
+export { getReactiveValueInProxy, setProxyValue, setValueInProxy };

package/dist/helpers/value.js

@@ -1,54 +1,27 @@
-import { batchedHandlers, batchDepth, flushHandlers } from "../batch.js";
-import { activeEffect } from "../effect.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 computed of state.computeds) computed.effect.dirty = true;
+	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;
-  if (length !== second.length) {
-    return false;
-  }
-  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 (!state.equal(first[index], second[index])) {
-        return false;
-      }
-    }
-  }
-  length -= offset;
-  for (let index = offset; index < length; index += 1) {
-    if (!state.equal(first[index], second[index])) {
-      return false;
-    }
-  }
-  return true;
+	let { length } = first;
+	if (length !== second.length) return false;
+	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 (!state.equal(first[index], second[index])) return false;
+	}
+	length -= offset;
+	for (let index = offset; index < length; index += 1) if (!state.equal(first[index], second[index])) return false;
+	return true;
 }
 function getValue(state) {
-  if (activeComputed != null) {
-    state.computeds.add(activeComputed);
-  }
-  if (activeEffect != null) {
-    state.effects.add(activeEffect);
-  }
-  return state.value;
+	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
-};
+export { emitValue, equalArrays, getValue };

package/dist/index.js

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