@oscarpalmer/mora 0.21.0 → 0.23.0

package/dist/value/array.js

@@ -1,187 +1,102 @@
-var __typeError = (msg) => {
-  throw TypeError(msg);
-};
-var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
-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 _indiced, _size;
-import { arrayName } from "../helpers/is.js";
-import { setValueInProxy, getReactiveValueInProxy } from "../helpers/proxy.js";
-import { getValue, equalArrays, emitValue } from "../helpers/value.js";
-import { subscribe, noop } from "../subscription.js";
-import { computed } from "./computed.js";
+import { noop, subscribe } from "../subscription.js";
+import { METHODS_AFFECTING_LENGTH, METHODS_UPDATE, NAME_ARRAY } from "../constants.js";
 import { Reactive } from "./reactive.js";
+import { computed } from "./computed.js";
+import { emitValue, equalArrays, getValue } from "../helpers/value.js";
+import { getReactiveValueInProxy, setValueInProxy } from "../helpers/proxy.js";
 import { signal } from "./signal.js";
-class ReactiveArray extends Reactive {
-  constructor(value, options) {
-    super(
-      arrayName,
-      new Proxy(value, {
-        get: (target, property) => updateMethods.has(property) ? updateArray(property, target, this.state, __privateGet(this, _size)) : Reflect.get(target, property),
-        set: (target, property, value2) => setValueInProxy(
-          target,
-          property,
-          value2,
-          this.state,
-          true,
-          __privateGet(this, _size)
-        )
-      }),
-      options
-    );
-    __privateAdd(this, _indiced, /* @__PURE__ */ new Map());
-    __privateAdd(this, _size, signal(0));
-    __privateGet(this, _size).set(value.length);
-  }
-  /**
-   * The length of the array
-   */
-  get length() {
-    return __privateGet(this, _size).get();
-  }
-  /**
-   * Set the length of the array
-   */
-  set length(value) {
-    if (typeof value === "number" && value >= 0 && value !== this.state.value.length) {
-      this.get().length = value;
-    }
-  }
-  /**
-   * Clear the array
-   */
-  clear() {
-    this.length = 0;
-  }
-  get(first) {
-    if (typeof first === "number") {
-      return getReactiveValueInProxy(this, __privateGet(this, _indiced), first, true).get();
-    }
-    if (first === "length") {
-      return this.length;
-    }
-    return getValue(this.state);
-  }
-  /**
-   * Create a computed, filtered array
-   */
-  filter(callback) {
-    return computed(() => this.get().filter(callback));
-  }
-  /**
-   * Create a computed, mapped array
-   */
-  map(callback) {
-    return computed(() => this.get().map(callback));
-  }
-  peek(value) {
-    if (value === true) {
-      return __privateGet(this, _size).peek();
-    }
-    if (typeof value === "number") {
-      return this.state.value.at(value);
-    }
-    return [...this.state.value];
-  }
-  /**
-   * Remove and return the last item of the array
-   */
-  pop() {
-    return this.state.value.pop();
-  }
-  /**
-   * Add items to the end of the array
-   */
-  push(...items) {
-    return this.state.value.push(...items);
-  }
-  set(first, second) {
-    if (first == null || Array.isArray(first)) {
-      this.state.value.splice(0, this.state.value.length, ...first ?? []);
-    } else if (first === "length") {
-      this.length = second;
-    } else if (typeof first === "number") {
-      this.state.value[first] = second;
-    }
-  }
-  /**
-   * Remove and return the first item of the array
-   */
-  shift() {
-    return this.state.value.shift();
-  }
-  /**
-   * Remove and return items from the array _(and optionally add new items)_
-   */
-  splice(from, to, ...items) {
-    return this.state.value.splice(
-      from,
-      to ?? this.state.value.length,
-      ...items
-    );
-  }
-  subscribe(first, second) {
-    if (typeof first === "number" && typeof second === "function") {
-      return getReactiveValueInProxy(
-        this,
-        __privateGet(this, _indiced),
-        first,
-        true
-      ).subscribe(second);
-    }
-    return typeof first === "function" ? subscribe(this.state, first) : noop;
-  }
-  /**
-   * Add items to the beginning of the array
-   */
-  unshift(...items) {
-    return this.state.value.unshift(...items);
-  }
-  /**
-   * Update the value _(based on the current value)_
-   */
-  update(callback) {
-    const updated = callback(this.state.value);
-    if (updated == null || Array.isArray(updated)) {
-      this.set(updated);
-    }
-  }
-}
-_indiced = new WeakMap();
-_size = new WeakMap();
+var ReactiveArray = class extends Reactive {
+	#indiced = /* @__PURE__ */ new Map();
+	#size = signal(0);
+	get length() {
+		return this.#size.get();
+	}
+	set length(value) {
+		if (typeof value === "number" && value >= 0 && value !== this.state.value.length) this.get().length = value;
+	}
+	constructor(value, options) {
+		super(NAME_ARRAY, new Proxy(value, {
+			get: (target, property) => METHODS_UPDATE.has(property) ? updateArray(property, target, this.state, this.#size) : Reflect.get(target, property),
+			set: (target, property, value$1) => setValueInProxy({
+				property,
+				target,
+				value: value$1,
+				isArray: true,
+				state: this.state,
+				length: this.#size
+			})
+		}), options);
+		this.#size.set(value.length);
+	}
+	clear() {
+		this.length = 0;
+	}
+	filter(callback) {
+		return computed(() => this.get().filter(callback));
+	}
+	get(first) {
+		if (typeof first === "number") return getReactiveValueInProxy(this, this.#indiced, first, true).get();
+		if (first === "length") return this.length;
+		return getValue(this.state);
+	}
+	map(callback) {
+		return computed(() => this.get().map(callback));
+	}
+	notify() {
+		emitValue(this.state);
+	}
+	peek(value) {
+		if (value === "length") return this.#size.peek();
+		if (typeof value === "number") return this.state.value.at(value);
+		return [...this.state.value];
+	}
+	pop() {
+		return this.state.value.pop();
+	}
+	push(...items) {
+		return this.state.value.push(...items);
+	}
+	set(first, second) {
+		if (first == null || Array.isArray(first)) this.state.value.splice(0, this.state.value.length, ...first ?? []);
+		else if (first === "length") this.length = second;
+		else if (typeof first === "number" && !Number.isNaN(first)) setAtIndex(this.state.value, first, second);
+	}
+	shift() {
+		return this.state.value.shift();
+	}
+	splice(from, to, ...items) {
+		return this.state.value.splice(from, to ?? this.state.value.length, ...items);
+	}
+	subscribe(first, second) {
+		if (typeof first === "number" && typeof second === "function") return getReactiveValueInProxy(this, this.#indiced, first, true).subscribe(second);
+		return typeof first === "function" ? subscribe(this.state, first) : noop;
+	}
+	unshift(...items) {
+		return this.state.value.unshift(...items);
+	}
+	update(callback) {
+		const updated = callback(this.state.value);
+		if (updated == null || Array.isArray(updated)) this.set(updated);
+	}
+};
 function array(value, options) {
-  return new ReactiveArray(Array.isArray(value) ? value : [], options);
+	return new ReactiveArray(Array.isArray(value) ? value : [], options);
 }
-function updateArray(type, array2, state, length) {
-  const affectsLength = lengthAffectingMethods.has(type);
-  const previousArray = affectsLength ? [] : [...array2];
-  const previousLength = array2.length;
-  return (...args) => {
-    const result = array2[type](
-      ...args
-    );
-    if (affectsLength ? array2.length !== previousLength : !equalArrays(state, previousArray, array2)) {
-      emitValue(state);
-      length.set(array2.length);
-    }
-    return result;
-  };
+function updateArray(type, array$1, state, length) {
+	const affectsLength = METHODS_AFFECTING_LENGTH.has(type);
+	const previousArray = affectsLength ? [] : [...array$1];
+	const previousLength = array$1.length;
+	return (...args) => {
+		const result = array$1[type](...args);
+		if (affectsLength ? array$1.length !== previousLength : !equalArrays(state, previousArray, array$1)) {
+			emitValue(state);
+			length.set(array$1.length);
+		}
+		return result;
+	};
 }
-const lengthAffectingMethods = /* @__PURE__ */ new Set([
-  "pop",
-  "push",
-  "shift",
-  "unshift"
-]);
-const updateMethods = /* @__PURE__ */ new Set([
-  ...lengthAffectingMethods,
-  "copyWithin",
-  "fill",
-  "reverse",
-  "sort",
-  "splice"
-]);
-export {
-  ReactiveArray,
-  array
-};
+function setAtIndex(array$1, index, value) {
+	const actual = index < 0 ? array$1.length + index : index;
+	if (actual > -1) array$1[actual] = value;
+}
+export { ReactiveArray, array };

package/dist/value/computed.js

@@ -1,61 +1,36 @@
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-import { batchedHandlers, batchDepth } from "../batch.js";
-import { effect, activeEffect, runEffect } from "../effect.js";
-import { computedName } from "../helpers/is.js";
+import { ACTIVE, BATCH, NAME_COMPUTED } from "../constants.js";
+import { effect, runEffect } from "../effect.js";
 import { Reactive } from "./reactive.js";
-let activeComputed;
-class Computed extends Reactive {
-  constructor(callback, options) {
-    super(computedName, void 0, options);
-    __publicField(this, "effect", {
-      dirty: true,
-      instance: void 0
-    });
-    this.effect.instance = effect(() => {
-      if (this.effect.dirty) {
-        const previousComputed = activeComputed;
-        activeComputed = this;
-        const value = callback();
-        activeComputed = previousComputed;
-        if (!this.state.equal(this.state.value, value)) {
-          this.state.value = value;
-          for (const computed2 of this.state.computeds) {
-            computed2.effect.dirty = true;
-          }
-          for (const effect2 of this.state.effects) {
-            batchedHandlers.add(effect2);
-          }
-          for (const [, subscription] of this.state.subscriptions) {
-            subscription.callback(value);
-          }
-        }
-        this.effect.dirty = false;
-      }
-    });
-  }
-  /**
-   * @inheritdoc
-   */
-  get() {
-    if (activeComputed != null && this !== activeComputed) {
-      this.state.computeds.add(activeComputed);
-    }
-    if (activeEffect != null && activeEffect !== this.effect.instance) {
-      this.state.effects.add(activeEffect);
-    }
-    if (this.effect.dirty && batchDepth === 0) {
-      runEffect(this.effect.instance);
-    }
-    return this.state.value;
-  }
-}
+var Computed = class extends Reactive {
+	effect = {
+		dirty: true,
+		instance: void 0
+	};
+	constructor(callback, options) {
+		super(NAME_COMPUTED, void 0, options);
+		this.effect.instance = effect(() => {
+			if (!this.effect.dirty) return;
+			const previousComputed = ACTIVE.computed;
+			ACTIVE.computed = this;
+			const value = callback();
+			ACTIVE.computed = previousComputed;
+			if (!this.state.equal(this.state.value, value)) {
+				this.state.value = value;
+				for (const computed$1 of this.state.computeds) computed$1.effect.dirty = true;
+				for (const effect$1 of this.state.effects) BATCH.handlers.add(effect$1);
+				for (const [, subscription] of this.state.subscriptions) subscription.callback(value);
+			}
+			this.effect.dirty = false;
+		});
+	}
+	get() {
+		if (ACTIVE.computed != null && this !== ACTIVE.computed) this.state.computeds.add(ACTIVE.computed);
+		if (ACTIVE.effect != null && ACTIVE.effect !== this.effect.instance) this.state.effects.add(ACTIVE.effect);
+		if (this.effect.dirty && BATCH.depth === 0) runEffect(this.effect.instance);
+		return this.state.value;
+	}
+};
 function computed(callback, options) {
-  return new Computed(callback, options);
+	return new Computed(callback, options);
 }
-export {
-  Computed,
-  activeComputed,
-  computed
-};
+export { Computed, computed };

package/dist/value/reactive.js

@@ -1,55 +1,31 @@
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 import { subscribe, unsubscribe } from "../subscription.js";
-class Reactive {
-  constructor(name, value, options) {
-    __publicField(this, "state", {
-      computeds: /* @__PURE__ */ new Set(),
-      effects: /* @__PURE__ */ new Set(),
-      equal: Object.is,
-      subscriptions: /* @__PURE__ */ new Map(),
-      value: void 0
-    });
-    this.state.value = value;
-    if (typeof options === "object" && typeof options.equal === "function") {
-      this.state.equal = options.equal;
-    }
-    Object.defineProperty(this, "$mora", {
-      value: name
-    });
-  }
-  /**
-   * Get the value _(without reactivity)_
-   */
-  peek() {
-    return this.state.value;
-  }
-  /**
-   * Subscribe to changes
-   */
-  subscribe(callback) {
-    return subscribe(this.state, callback);
-  }
-  /**
-   * JSON representation of the value
-   */
-  toJSON() {
-    return this.get();
-  }
-  /**
-   * String representation of the value
-   */
-  toString() {
-    return String(this.get());
-  }
-  /**
-   * Unsubscribe from changes
-   */
-  unsubscribe(callback) {
-    unsubscribe(this.state, callback);
-  }
-}
-export {
-  Reactive
+var Reactive = class {
+	state = {
+		computeds: /* @__PURE__ */ new Set(),
+		effects: /* @__PURE__ */ new Set(),
+		equal: Object.is,
+		subscriptions: /* @__PURE__ */ new Map(),
+		value: void 0
+	};
+	constructor(name, value, options) {
+		this.state.value = value;
+		if (typeof options === "object" && typeof options.equal === "function") this.state.equal = options.equal;
+		Object.defineProperty(this, "$mora", { value: name });
+	}
+	peek() {
+		return this.state.value;
+	}
+	subscribe(callback) {
+		return subscribe(this.state, callback);
+	}
+	toJSON() {
+		return this.get();
+	}
+	toString() {
+		return String(this.get());
+	}
+	unsubscribe(callback) {
+		unsubscribe(this.state, callback);
+	}
 };
+export { Reactive };

package/dist/value/signal.js

@@ -1,36 +1,24 @@
-import { signalName } from "../helpers/is.js";
-import { getValue, emitValue } from "../helpers/value.js";
+import { NAME_SIGNAL } from "../constants.js";
 import { Reactive } from "./reactive.js";
-class Signal extends Reactive {
-  constructor(value, options) {
-    super(signalName, value, options);
-  }
-  /**
-   * @inheritdoc
-   */
-  get() {
-    return getValue(this.state);
-  }
-  /**
-   * Set the value
-   */
-  set(value) {
-    if (!this.state.equal(this.state.value, value)) {
-      this.state.value = value;
-      emitValue(this.state);
-    }
-  }
-  /**
-   * Update the value _(based on the current value)_
-   */
-  update(callback) {
-    this.set(callback(this.state.value));
-  }
-}
+import { emitValue, getValue } from "../helpers/value.js";
+var Signal = class extends Reactive {
+	constructor(value, options) {
+		super(NAME_SIGNAL, value, options);
+	}
+	get() {
+		return getValue(this.state);
+	}
+	set(value) {
+		if (!this.state.equal(this.state.value, value)) {
+			this.state.value = value;
+			emitValue(this.state);
+		}
+	}
+	update(callback) {
+		this.set(callback(this.state.value));
+	}
+};
 function signal(value, options) {
-  return new Signal(value, options);
+	return new Signal(value, options);
 }
-export {
-  Signal,
-  signal
-};
+export { Signal, signal };

package/dist/value/store.js

@@ -1,63 +1,40 @@
-var __typeError = (msg) => {
-  throw TypeError(msg);
-};
-var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
-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 _keyed;
-import { isPlainObject, isKey } from "../node_modules/@oscarpalmer/atoms/dist/internal/is.js";
-import { storeName } from "../helpers/is.js";
-import { setValueInProxy, getReactiveValueInProxy, setProxyValue } from "../helpers/proxy.js";
-import { getValue } from "../helpers/value.js";
-import { subscribe, noop } from "../subscription.js";
+import { noop, subscribe } from "../subscription.js";
+import { NAME_STORE } from "../constants.js";
 import { Reactive } from "./reactive.js";
-class Store extends Reactive {
-  constructor(value, options) {
-    super(
-      storeName,
-      new Proxy(value, {
-        set: (target, property, value2) => setValueInProxy(target, property, value2, this.state, false)
-      }),
-      options
-    );
-    __privateAdd(this, _keyed, /* @__PURE__ */ new Map());
-  }
-  get(key) {
-    return isKey(key) ? getReactiveValueInProxy(this, __privateGet(this, _keyed), key, false).get() : getValue(this.state);
-  }
-  peek(key) {
-    return isKey(key) ? this.state.value[key] : { ...this.state.value };
-  }
-  set(first, second) {
-    if (isKey(first)) {
-      this.state.value[first] = second;
-    } else if (first == null || isPlainObject(first)) {
-      setProxyValue(this.state.value, first ?? {});
-    }
-  }
-  subscribe(first, second) {
-    if (isKey(first) && typeof second === "function") {
-      return getReactiveValueInProxy(this, __privateGet(this, _keyed), first, false).subscribe(
-        second
-      );
-    }
-    return typeof first === "function" ? subscribe(this.state, first) : noop;
-  }
-  /**
-   * Update the value _(based on the current value)_
-   */
-  update(callback) {
-    const updated = callback({ ...this.state.value });
-    if (updated == null || isPlainObject(updated)) {
-      setProxyValue(this.state.value, updated ?? {});
-    }
-  }
-}
-_keyed = new WeakMap();
+import { getValue } from "../helpers/value.js";
+import { getReactiveValueInProxy, setProxyValue, setValueInProxy } from "../helpers/proxy.js";
+import { isKey, isPlainObject } from "@oscarpalmer/atoms/is";
+var Store = class extends Reactive {
+	#keyed = /* @__PURE__ */ new Map();
+	constructor(value, options) {
+		super(NAME_STORE, new Proxy(value, { set: (target, property, value$1) => setValueInProxy({
+			target,
+			property,
+			value: value$1,
+			isArray: false,
+			state: this.state
+		}) }), options);
+	}
+	get(key) {
+		return isKey(key) ? getReactiveValueInProxy(this, this.#keyed, key, false).get() : getValue(this.state);
+	}
+	peek(key) {
+		return isKey(key) ? this.state.value[key] : { ...this.state.value };
+	}
+	set(first, second) {
+		if (isKey(first)) this.state.value[first] = second;
+		else if (first == null || isPlainObject(first)) setProxyValue(this.state.value, first ?? {});
+	}
+	subscribe(first, second) {
+		if (isKey(first) && typeof second === "function") return getReactiveValueInProxy(this, this.#keyed, first, false).subscribe(second);
+		return typeof first === "function" ? subscribe(this.state, first) : noop;
+	}
+	update(callback) {
+		const updated = callback({ ...this.state.value });
+		if (updated == null || isPlainObject(updated)) setProxyValue(this.state.value, updated ?? {});
+	}
+};
 function store(value, options) {
-  return new Store(isPlainObject(value) ? value : {}, options);
+	return new Store(isPlainObject(value) ? value : {}, options);
 }
-export {
-  Store,
-  store
-};
+export { Store, store };