@oscarpalmer/mora 0.13.0 → 0.15.0

package/dist/mora.full.js

@@ -1,3 +1,143 @@
+/**
+ * Is the value a reactive array?
+ */
+function isArray(value) {
+    return isMora(value, arrayName);
+}
+/**
+ * Is the value a computed signal?
+ */
+function isComputed(value) {
+    return isMora(value, computedName);
+}
+/**
+ * Is the value an effect?
+ */
+function isEffect(value) {
+    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)));
+}
+function isReactive(value) {
+    return isMora(value, reactiveNames);
+}
+/**
+ * Is the value a signal?
+ */
+function isSignal(value) {
+    return isMora(value, signalName);
+}
+const arrayName = 'array';
+const computedName = 'computed';
+const effectName = 'effect';
+const signalName = 'signal';
+const reactiveNames = new Set([arrayName, computedName, signalName]);
+
+class Effect {
+    constructor(callback) {
+        Object.defineProperty(this, '$mora', {
+            value: effectName,
+        });
+        this.state = {
+            callback,
+        };
+        runEffect(this);
+    }
+}
+function runEffect(effect) {
+    const previousEffect = activeEffect;
+    activeEffect = effect;
+    try {
+        effect.state.callback();
+    }
+    finally {
+        activeEffect = previousEffect;
+    }
+}
+/**
+ * Create an effect
+ */
+function effect(callback) {
+    return new Effect(callback);
+}
+let activeEffect;
+
+function flushEffects() {
+    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);
+            }
+        }
+    }
+}
+/**
+ * Start batching effects _(use `stopBatch` to flush and run batched effects)_
+ */
+function startBatch() {
+    batchDepth += 1;
+}
+/**
+ * Stop batching effects and flush _(run)_ them
+ */
+function stopBatch() {
+    if (batchDepth > 0) {
+        batchDepth -= 1;
+    }
+    flushEffects();
+}
+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;
@@ -71,95 +211,6 @@ class Reactive {
     }
 }
 
-class Effect {
-    constructor(callback) {
-        Object.defineProperty(this, '$mora', {
-            value: 'effect',
-        });
-        this.state = {
-            callback,
-        };
-        runEffect(this);
-    }
-}
-function runEffect(effect) {
-    const previousEffect = activeEffect;
-    activeEffect = effect;
-    try {
-        effect.state.callback();
-    }
-    finally {
-        activeEffect = previousEffect;
-    }
-}
-/**
- * Create an effect
- */
-function effect(callback) {
-    return new Effect(callback);
-}
-let activeEffect;
-
-/**
- * Is the value a computed signal?
- */
-function isComputed(value) {
-    return isMora(value, 'computed');
-}
-/**
- * Is the value an effect?
- */
-function isEffect(value) {
-    return isMora(value, 'effect');
-}
-function isMora(value, name) {
-    return (typeof value === 'object' &&
-        value != null &&
-        '$mora' in value &&
-        value.$mora === name);
-}
-function isReactive(value) {
-    return isComputed(value) || isSignal(value);
-}
-/**
- * Is the value a signal?
- */
-function isSignal(value) {
-    return isMora(value, 'signal');
-}
-
-function flushEffects() {
-    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);
-            }
-        }
-    }
-}
-/**
- * Start batching effects _(use `stopBatch` to flush and run batched effects)_
- */
-function startBatch() {
-    batchDepth += 1;
-}
-/**
- * Stop batching effects and flush _(run)_ them
- */
-function stopBatch() {
-    if (batchDepth > 0) {
-        batchDepth -= 1;
-    }
-    flushEffects();
-}
-const batchedHandlers = new Set();
-let batchDepth = 0;
-
 let activeComputed;
 class Computed extends Reactive {
     effect = {
@@ -167,7 +218,7 @@ class Computed extends Reactive {
         instance: undefined,
     };
     constructor(callback) {
-        super('computed', undefined);
+        super(computedName, undefined);
         this.effect.instance = effect(() => {
             if (this.effect.dirty) {
                 const previousComputed = activeComputed;
@@ -213,20 +264,6 @@ function computed(callback) {
     return new Computed(callback);
 }
 
-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();
-    }
-}
 function getValue(state) {
     if (activeComputed != null) {
         state.computeds.add(activeComputed);
@@ -237,16 +274,15 @@ function getValue(state) {
     return state.value;
 }
 function setValue$1(state, value) {
-    if (Object.is(state.value, value)) {
-        return;
+    if (!Object.is(state.value, value)) {
+        state.value = value;
+        emitValue(state);
     }
-    state.value = value;
-    emitValue(state);
 }
 
 class Signal extends Reactive {
     constructor(value) {
-        super('signal', value);
+        super(signalName, value);
     }
     /**
      * @inheritdoc
@@ -293,7 +329,7 @@ class ReactiveArray extends Reactive {
         }
     }
     constructor(value) {
-        super('array', new Proxy(value, {
+        super(arrayName, new Proxy(value, {
             get: (target, property) => updateMethods.has(property)
                 ? updateArray(property, target, this.state, this.#size)
                 : Reflect.get(target, property),
@@ -301,15 +337,45 @@ class ReactiveArray extends Reactive {
         }));
         this.#size.set(value.length);
     }
+    /**
+     * Get an indexed item
+     */
+    at(index) {
+        return this.get().at(index);
+    }
     /**
      * @inheritdoc
      */
     get() {
         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(length) {
         return length === true ? this.#size.peek() : [...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 (Array.isArray(first)) {
             this.state.value.splice(0, this.state.value.length, ...first);
@@ -321,6 +387,24 @@ class ReactiveArray extends Reactive {
             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);
+    }
+    /**
+     * Add items to the beginning of the array
+     */
+    unshift(...items) {
+        return this.state.value.unshift(...items);
+    }
 }
 /**
  * Create a reactive array
@@ -328,29 +412,6 @@ class ReactiveArray extends Reactive {
 function array(value) {
     return new ReactiveArray(Array.isArray(value) ? value : []);
 }
-function emit(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 setValue(target, property, value, state, length) {
     const isIndex = !Number.isNaN(Number(property));
     const isLength = property === 'length';
@@ -358,12 +419,11 @@ function setValue(target, property, value, state, length) {
         return Reflect.set(target, property, value);
     }
     const previous = Reflect.get(target, property);
-    if (Object.is(previous, value)) {
-        return true;
+    if (!Object.is(previous, value)) {
+        Reflect.set(target, property, value);
+        emitValue(state);
+        length.set(target.length);
     }
-    Reflect.set(target, property, value);
-    emitValue(state);
-    length.set(target.length);
     return true;
 }
 function updateArray(type, array, state, length) {
@@ -374,7 +434,7 @@ function updateArray(type, array, state, length) {
         const result = array[type](...args);
         if (affectsLength
             ? array.length !== previousLength
-            : emit(previousArray, array)) {
+            : emitArrayChanges(previousArray, array)) {
             emitValue(state);
             length.set(array.length);
         }
@@ -396,4 +456,4 @@ const updateMethods = new Set([
     'splice',
 ]);
 
-export { array, computed, effect, isComputed, isEffect, isReactive, isSignal, signal, startBatch, stopBatch };
+export { array, computed, effect, isArray, isComputed, isEffect, isReactive, isSignal, signal, startBatch, stopBatch };

package/dist/value/array.cjs

@@ -0,0 +1,161 @@
+"use strict";
+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 _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");
+const value_reactive = require("./reactive.cjs");
+const value_signal = require("./signal.cjs");
+class ReactiveArray extends value_reactive.Reactive {
+  constructor(value) {
+    super(
+      helpers_is.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) => setValue(target, property, value2, this.state, __privateGet(this, _size))
+      })
+    );
+    __privateAdd(this, _size, value_signal.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;
+    }
+  }
+  /**
+   * Get an indexed item
+   */
+  at(index) {
+    return this.get().at(index);
+  }
+  /**
+   * @inheritdoc
+   */
+  get() {
+    return helpers_value.getValue(this.state);
+  }
+  /**
+   * Create a computed, filtered array
+   */
+  filter(callback) {
+    return value_computed.computed(() => this.get().filter(callback));
+  }
+  /**
+   * Create a computed, mapped array
+   */
+  map(callback) {
+    return value_computed.computed(() => this.get().map(callback));
+  }
+  peek(length) {
+    return length === true ? __privateGet(this, _size).peek() : [...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 (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
+    );
+  }
+  /**
+   * Add items to the beginning of the array
+   */
+  unshift(...items) {
+    return this.state.value.unshift(...items);
+  }
+}
+_size = new WeakMap();
+function array(value) {
+  return new ReactiveArray(Array.isArray(value) ? value : []);
+}
+function setValue(target, property, value, state, length) {
+  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 (!Object.is(previous, value)) {
+    Reflect.set(target, property, value);
+    helpers_emit.emitValue(state);
+    length.set(target.length);
+  }
+  return true;
+}
+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 : helpers_emit.emitArrayChanges(previousArray, array2)) {
+      helpers_emit.emitValue(state);
+      length.set(array2.length);
+    }
+    return result;
+  };
+}
+const lengthAffectingMethods = /* @__PURE__ */ new Set([
+  "pop",
+  "push",
+  "shift",
+  "unshift"
+]);
+const updateMethods = /* @__PURE__ */ new Set([
+  ...lengthAffectingMethods,
+  "copyWithin",
+  "fill",
+  "reverse",
+  "sort",
+  "splice"
+]);
+exports.ReactiveArray = ReactiveArray;
+exports.array = array;