@oscarpalmer/mora 0.14.0 → 0.15.0

package/dist/mora.full.js

@@ -337,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);
@@ -357,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

package/dist/value/array.cjs

@@ -10,6 +10,7 @@ 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 {
@@ -38,15 +39,45 @@ class ReactiveArray extends value_reactive.Reactive {
       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);
@@ -56,6 +87,28 @@ class ReactiveArray extends value_reactive.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);
+  }
 }
 _size = new WeakMap();
 function array(value) {

package/dist/value/array.js

@@ -8,6 +8,7 @@ var _size;
 import { emitValue, emitArrayChanges } from "../helpers/emit.js";
 import { arrayName } from "../helpers/is.js";
 import { getValue } from "../helpers/value.js";
+import { computed } from "./computed.js";
 import { Reactive } from "./reactive.js";
 import { signal } from "./signal.js";
 class ReactiveArray extends Reactive {
@@ -36,15 +37,45 @@ class ReactiveArray extends Reactive {
       this.get().length = value;
     }
   }
+  /**
+   * 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 ? __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);
@@ -54,6 +85,28 @@ 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);
+  }
 }
 _size = new WeakMap();
 function array(value) {

package/package.json

@@ -54,5 +54,5 @@
 	},
 	"type": "module",
 	"types": "./types/index.d.ts",
-	"version": "0.14.0"
+	"version": "0.15.0"
 }

package/src/value/array.ts

@@ -1,6 +1,7 @@
 import {emitArrayChanges, emitValue} from '../helpers/emit';
 import {arrayName} from '../helpers/is';
 import {getValue} from '../helpers/value';
+import {type Computed, computed} from './computed';
 import {Reactive, type ReactiveState} from './reactive';
 import {type Signal, signal} from './signal';
 
@@ -43,6 +44,13 @@ export class ReactiveArray<Item> extends Reactive<Item[]> {
 		this.#size.set(value.length);
 	}
 
+	/**
+	 * Get an indexed item
+	 */
+	at(index: number): Item | undefined {
+		return this.get().at(index);
+	}
+
 	/**
 	 * @inheritdoc
 	 */
@@ -50,6 +58,24 @@ export class ReactiveArray<Item> extends Reactive<Item[]> {
 		return getValue(this.state);
 	}
 
+	/**
+	 * Create a computed, filtered array
+	 */
+	filter(
+		callback: (item: Item, index: number, array: Item[]) => boolean,
+	): Computed<Item[]> {
+		return computed(() => this.get().filter(callback));
+	}
+
+	/**
+	 * Create a computed, mapped array
+	 */
+	map<Mapped>(
+		callback: (item: Item, index: number, array: Item[]) => Mapped,
+	): Computed<Mapped[]> {
+		return computed(() => this.get().map(callback));
+	}
+
 	/**
 	 * @inheritdoc
 	 */
@@ -64,6 +90,20 @@ export class ReactiveArray<Item> extends Reactive<Item[]> {
 		return length === true ? this.#size.peek() : [...this.state.value];
 	}
 
+	/**
+	 * Remove and return the last item of the array
+	 */
+	pop(): Item | undefined {
+		return this.state.value.pop();
+	}
+
+	/**
+	 * Add items to the end of the array
+	 */
+	push(...items: Item[]): number {
+		return this.state.value.push(...items);
+	}
+
 	/**
 	 * Set the value
 	 */
@@ -88,6 +128,31 @@ export class ReactiveArray<Item> extends Reactive<Item[]> {
 			this.state.value[first] = second as Item;
 		}
 	}
+
+	/**
+	 * Remove and return the first item of the array
+	 */
+	shift(): Item | undefined {
+		return this.state.value.shift();
+	}
+
+	/**
+	 * Remove and return items from the array _(and optionally add new items)_
+	 */
+	splice(from: number, to?: number, ...items: Item[]): Item[] {
+		return this.state.value.splice(
+			from,
+			to ?? this.state.value.length,
+			...items,
+		);
+	}
+
+	/**
+	 * Add items to the beginning of the array
+	 */
+	unshift(...items: Item[]): number {
+		return this.state.value.unshift(...items);
+	}
 }
 
 /**

package/types/helpers/is.d.cts

@@ -68,10 +68,22 @@ declare class ReactiveArray<Item> extends Reactive<Item[]> {
 	 */
 	set length(value: number);
 	constructor(value: Item[]);
+	/**
+	 * Get an indexed item
+	 */
+	at(index: number): Item | undefined;
 	/**
 	 * @inheritdoc
 	 */
 	get(): Item[];
+	/**
+	 * Create a computed, filtered array
+	 */
+	filter(callback: (item: Item, index: number, array: Item[]) => boolean): Computed<Item[]>;
+	/**
+	 * Create a computed, mapped array
+	 */
+	map<Mapped>(callback: (item: Item, index: number, array: Item[]) => Mapped): Computed<Mapped[]>;
 	/**
 	 * @inheritdoc
 	 */
@@ -80,6 +92,14 @@ declare class ReactiveArray<Item> extends Reactive<Item[]> {
 	 * Get the length of the array _(without reactivity)_
 	 */
 	peek(length: true): number;
+	/**
+	 * Remove and return the last item of the array
+	 */
+	pop(): Item | undefined;
+	/**
+	 * Add items to the end of the array
+	 */
+	push(...items: Item[]): number;
 	/**
 	 * Set the value
 	 */
@@ -92,6 +112,18 @@ declare class ReactiveArray<Item> extends Reactive<Item[]> {
 	 * Set the length of the array
 	 */
 	set(property: "length", value: number): void;
+	/**
+	 * Remove and return the first item of the array
+	 */
+	shift(): Item | undefined;
+	/**
+	 * Remove and return items from the array _(and optionally add new items)_
+	 */
+	splice(from: number, to?: number, ...items: Item[]): Item[];
+	/**
+	 * Add items to the beginning of the array
+	 */
+	unshift(...items: Item[]): number;
 }
 declare class Signal<Value> extends Reactive<Value> {
 	constructor(value: Value);

package/types/index.d.cts

@@ -84,10 +84,22 @@ export declare class ReactiveArray<Item> extends Reactive<Item[]> {
 	 */
 	set length(value: number);
 	constructor(value: Item[]);
+	/**
+	 * Get an indexed item
+	 */
+	at(index: number): Item | undefined;
 	/**
 	 * @inheritdoc
 	 */
 	get(): Item[];
+	/**
+	 * Create a computed, filtered array
+	 */
+	filter(callback: (item: Item, index: number, array: Item[]) => boolean): Computed<Item[]>;
+	/**
+	 * Create a computed, mapped array
+	 */
+	map<Mapped>(callback: (item: Item, index: number, array: Item[]) => Mapped): Computed<Mapped[]>;
 	/**
 	 * @inheritdoc
 	 */
@@ -96,6 +108,14 @@ export declare class ReactiveArray<Item> extends Reactive<Item[]> {
 	 * Get the length of the array _(without reactivity)_
 	 */
 	peek(length: true): number;
+	/**
+	 * Remove and return the last item of the array
+	 */
+	pop(): Item | undefined;
+	/**
+	 * Add items to the end of the array
+	 */
+	push(...items: Item[]): number;
 	/**
 	 * Set the value
 	 */
@@ -108,6 +128,18 @@ export declare class ReactiveArray<Item> extends Reactive<Item[]> {
 	 * Set the length of the array
 	 */
 	set(property: "length", value: number): void;
+	/**
+	 * Remove and return the first item of the array
+	 */
+	shift(): Item | undefined;
+	/**
+	 * Remove and return items from the array _(and optionally add new items)_
+	 */
+	splice(from: number, to?: number, ...items: Item[]): Item[];
+	/**
+	 * Add items to the beginning of the array
+	 */
+	unshift(...items: Item[]): number;
 }
 /**
  * Create a reactive array

package/types/value/array.d.cts

@@ -68,10 +68,22 @@ export declare class ReactiveArray<Item> extends Reactive<Item[]> {
 	 */
 	set length(value: number);
 	constructor(value: Item[]);
+	/**
+	 * Get an indexed item
+	 */
+	at(index: number): Item | undefined;
 	/**
 	 * @inheritdoc
 	 */
 	get(): Item[];
+	/**
+	 * Create a computed, filtered array
+	 */
+	filter(callback: (item: Item, index: number, array: Item[]) => boolean): Computed<Item[]>;
+	/**
+	 * Create a computed, mapped array
+	 */
+	map<Mapped>(callback: (item: Item, index: number, array: Item[]) => Mapped): Computed<Mapped[]>;
 	/**
 	 * @inheritdoc
 	 */
@@ -80,6 +92,14 @@ export declare class ReactiveArray<Item> extends Reactive<Item[]> {
 	 * Get the length of the array _(without reactivity)_
 	 */
 	peek(length: true): number;
+	/**
+	 * Remove and return the last item of the array
+	 */
+	pop(): Item | undefined;
+	/**
+	 * Add items to the end of the array
+	 */
+	push(...items: Item[]): number;
 	/**
 	 * Set the value
 	 */
@@ -92,6 +112,18 @@ export declare class ReactiveArray<Item> extends Reactive<Item[]> {
 	 * Set the length of the array
 	 */
 	set(property: "length", value: number): void;
+	/**
+	 * Remove and return the first item of the array
+	 */
+	shift(): Item | undefined;
+	/**
+	 * Remove and return items from the array _(and optionally add new items)_
+	 */
+	splice(from: number, to?: number, ...items: Item[]): Item[];
+	/**
+	 * Add items to the beginning of the array
+	 */
+	unshift(...items: Item[]): number;
 }
 /**
  * Create a reactive array

package/types/value/array.d.ts

@@ -1,3 +1,4 @@
+import { type Computed } from './computed';
 import { Reactive } from './reactive';
 export declare class ReactiveArray<Item> extends Reactive<Item[]> {
     #private;
@@ -10,10 +11,22 @@ export declare class ReactiveArray<Item> extends Reactive<Item[]> {
      */
     set length(value: number);
     constructor(value: Item[]);
+    /**
+     * Get an indexed item
+     */
+    at(index: number): Item | undefined;
     /**
      * @inheritdoc
      */
     get(): Item[];
+    /**
+     * Create a computed, filtered array
+     */
+    filter(callback: (item: Item, index: number, array: Item[]) => boolean): Computed<Item[]>;
+    /**
+     * Create a computed, mapped array
+     */
+    map<Mapped>(callback: (item: Item, index: number, array: Item[]) => Mapped): Computed<Mapped[]>;
     /**
      * @inheritdoc
      */
@@ -22,6 +35,14 @@ export declare class ReactiveArray<Item> extends Reactive<Item[]> {
      * Get the length of the array _(without reactivity)_
      */
     peek(length: true): number;
+    /**
+     * Remove and return the last item of the array
+     */
+    pop(): Item | undefined;
+    /**
+     * Add items to the end of the array
+     */
+    push(...items: Item[]): number;
     /**
      * Set the value
      */
@@ -34,6 +55,18 @@ export declare class ReactiveArray<Item> extends Reactive<Item[]> {
      * Set the length of the array
      */
     set(property: 'length', value: number): void;
+    /**
+     * Remove and return the first item of the array
+     */
+    shift(): Item | undefined;
+    /**
+     * Remove and return items from the array _(and optionally add new items)_
+     */
+    splice(from: number, to?: number, ...items: Item[]): Item[];
+    /**
+     * Add items to the beginning of the array
+     */
+    unshift(...items: Item[]): number;
 }
 /**
  * Create a reactive array