@oscarpalmer/mora 0.21.0 → 0.22.0

package/dist/batch.js

@@ -1,33 +1,20 @@
-import { runEffect } from "./effect.js";
 import { isEffect } from "./helpers/is.js";
+import { runEffect } from "./effect.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 (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);
+	}
 }
 function startBatch() {
-  batchDepth += 1;
+	batchDepth += 1;
 }
 function stopBatch() {
-  if (batchDepth > 0) {
-    batchDepth -= 1;
-  }
-  flushHandlers();
+	if (batchDepth > 0) batchDepth -= 1;
+	flushHandlers();
 }
 const batchedHandlers = /* @__PURE__ */ new Set();
 let batchDepth = 0;
-export {
-  batchDepth,
-  batchedHandlers,
-  flushHandlers,
-  startBatch,
-  stopBatch
-};
+export { batchDepth, batchedHandlers, flushHandlers, startBatch, stopBatch };

package/dist/effect.js

@@ -1,31 +1,22 @@
 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;
-  }
+var Effect = class {
+	constructor(callback) {
+		Object.defineProperty(this, "$mora", { value: effectName });
+		this.state = { callback };
+		runEffect(this);
+	}
+};
+function runEffect(effect$1) {
+	const previousEffect = activeEffect;
+	activeEffect = effect$1;
+	try {
+		effect$1.state.callback();
+	} finally {
+		activeEffect = previousEffect;
+	}
 }
 function effect(callback) {
-  return new Effect(callback);
+	return new Effect(callback);
 }
 let activeEffect;
-export {
-  Effect,
-  activeEffect,
-  effect,
-  runEffect
-};
+export { Effect, activeEffect, effect, runEffect };

package/dist/helpers/is.js

@@ -1,40 +1,33 @@
 function isArray(value) {
-  return isMora(value, arrayName);
+	return isMora(value, arrayName);
 }
 function isComputed(value) {
-  return isMora(value, computedName);
+	return isMora(value, computedName);
 }
 function isEffect(value) {
-  return isMora(value, effectName);
+	return isMora(value, effectName);
 }
 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, reactiveNames);
 }
 function isSignal(value) {
-  return isMora(value, signalName);
+	return isMora(value, signalName);
 }
 function isStore(value) {
-  return isMora(value, storeName);
+	return isMora(value, storeName);
 }
 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
-};
+var reactiveNames = new Set([
+	arrayName,
+	computedName,
+	signalName,
+	storeName
+]);
+export { arrayName, computedName, effectName, isArray, isComputed, isEffect, isReactive, isSignal, isStore, signalName, storeName };

package/dist/helpers/proxy.js

@@ -2,55 +2,42 @@ 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;
+	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,28 @@
-import { batchedHandlers, batchDepth, flushHandlers } from "../batch.js";
 import { activeEffect } from "../effect.js";
+import { batchDepth, batchedHandlers, flushHandlers } from "../batch.js";
 import { activeComputed } from "../value/computed.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) batchedHandlers.add(effect);
+	for (const [, subscription] of state.subscriptions) batchedHandlers.add(subscription);
+	if (batchDepth === 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 (activeComputed != null) state.computeds.add(activeComputed);
+	if (activeEffect != null) state.effects.add(activeEffect);
+	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 { effect } from "./effect.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 };

package/dist/subscription.js

@@ -1,32 +1,24 @@
-class Subscription {
-  constructor(state, callback) {
-    this.state = state;
-    this.callback = callback;
-    callback(state.value);
-  }
-}
-function noop() {
-}
+var Subscription = class {
+	constructor(state, callback) {
+		this.state = state;
+		this.callback = callback;
+		callback(state.value);
+	}
+};
+function noop() {}
 function subscribe(state, callback) {
-  if (typeof callback !== "function" || state.subscriptions.has(callback)) {
-    return noop;
-  }
-  state.subscriptions.set(callback, new Subscription(state, callback));
-  return () => {
-    unsubscribe(state, callback);
-  };
+	if (typeof callback !== "function" || state.subscriptions.has(callback)) return noop;
+	state.subscriptions.set(callback, new Subscription(state, callback));
+	return () => {
+		unsubscribe(state, callback);
+	};
 }
 function unsubscribe(state, callback) {
-  const subscription = state.subscriptions.get(callback);
-  state.subscriptions.delete(callback);
-  if (subscription != null) {
-    subscription.callback = noop;
-    subscription.state = void 0;
-  }
+	const subscription = state.subscriptions.get(callback);
+	state.subscriptions.delete(callback);
+	if (subscription != null) {
+		subscription.callback = noop;
+		subscription.state = void 0;
+	}
 }
-export {
-  Subscription,
-  noop,
-  subscribe,
-  unsubscribe
-};
+export { Subscription, noop, subscribe, unsubscribe };