@oscarpalmer/mora 0.13.0 → 0.15.0

package/types/value/array.d.ts

@@ -0,0 +1,74 @@
+import { type Computed } from './computed';
+import { Reactive } from './reactive';
+export declare class ReactiveArray<Item> extends Reactive<Item[]> {
+    #private;
+    /**
+     * The length of the array
+     */
+    get length(): number;
+    /**
+     * Set the length of the array
+     */
+    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
+     */
+    peek(): 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
+     */
+    set(value: Item[]): void;
+    /**
+     * Set the value at an index
+     */
+    set(index: number, value: Item): void;
+    /**
+     * 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
+ */
+export declare function array<Item>(value: Item[]): ReactiveArray<Item>;

package/types/{computed.d.ts → value/computed.d.ts}

@@ -1,4 +1,4 @@
-import { type Effect } from './effect';
+import { type Effect } from '../effect';
 import { Reactive, type ReactiveState } from './reactive';
 type ComputedEffect = {
     dirty: boolean;

package/types/{reactive.d.ts → value/reactive.d.ts}

@@ -1,6 +1,6 @@
+import type { Effect } from '../effect';
+import { type Subscription, type Unsubscribe } from '../subscription';
 import type { Computed } from './computed';
-import type { Effect } from './effect';
-import { type Subscription, type Unsubscribe } from './subscription';
 export declare abstract class Reactive<Value> {
     protected readonly state: ReactiveState<Value>;
     constructor(name: string, value: Value);

package/dist/array.cjs

@@ -1,130 +0,0 @@
-"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, value2) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value2);
-var _size;
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const reactive = require("./reactive.cjs");
-const signal = require("./signal.cjs");
-const value = require("./value.cjs");
-class ReactiveArray extends reactive.Reactive {
-  constructor(value2) {
-    super(
-      "array",
-      new Proxy(value2, {
-        get: (target, property) => updateMethods.has(property) ? updateArray(property, target, this.state, __privateGet(this, _size)) : Reflect.get(target, property),
-        set: (target, property, value22) => setValue(target, property, value22, this.state, __privateGet(this, _size))
-      })
-    );
-    __privateAdd(this, _size, signal.signal(0));
-    __privateGet(this, _size).set(value2.length);
-  }
-  /**
-   * The length of the array
-   */
-  get length() {
-    return __privateGet(this, _size).get();
-  }
-  /**
-   * Set the length of the array
-   */
-  set length(value2) {
-    if (typeof value2 === "number" && value2 >= 0 && value2 !== this.state.value.length) {
-      this.get().length = value2;
-    }
-  }
-  /**
-   * @inheritdoc
-   */
-  get() {
-    return value.getValue(this.state);
-  }
-  peek(length) {
-    return length === true ? __privateGet(this, _size).peek() : [...this.state.value];
-  }
-  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;
-    }
-  }
-}
-_size = new WeakMap();
-function array(value2) {
-  return new ReactiveArray(Array.isArray(value2) ? value2 : []);
-}
-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$1, state, length) {
-  const isIndex = !Number.isNaN(Number(property));
-  const isLength = property === "length";
-  if (!isIndex && !isLength) {
-    return Reflect.set(target, property, value$1);
-  }
-  const previous = Reflect.get(target, property);
-  if (Object.is(previous, value$1)) {
-    return true;
-  }
-  Reflect.set(target, property, value$1);
-  value.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 : emit(previousArray, array2)) {
-      value.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;

package/dist/is.cjs

@@ -1,21 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-function isComputed(value) {
-  return isMora(value, "computed");
-}
-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);
-}
-function isSignal(value) {
-  return isMora(value, "signal");
-}
-exports.isComputed = isComputed;
-exports.isEffect = isEffect;
-exports.isReactive = isReactive;
-exports.isSignal = isSignal;

package/dist/is.js

@@ -1,21 +0,0 @@
-function isComputed(value) {
-  return isMora(value, "computed");
-}
-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);
-}
-function isSignal(value) {
-  return isMora(value, "signal");
-}
-export {
-  isComputed,
-  isEffect,
-  isReactive,
-  isSignal
-};

package/dist/signal.cjs

@@ -1,32 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const reactive = require("./reactive.cjs");
-const value = require("./value.cjs");
-class Signal extends reactive.Reactive {
-  constructor(value2) {
-    super("signal", value2);
-  }
-  /**
-   * @inheritdoc
-   */
-  get() {
-    return value.getValue(this.state);
-  }
-  /**
-   * Set the value
-   */
-  set(value$1) {
-    value.setValue(this.state, value$1);
-  }
-  /**
-   * Update the value
-   */
-  update(callback) {
-    this.set(callback(this.state.value));
-  }
-}
-function signal(value2) {
-  return new Signal(value2);
-}
-exports.Signal = Signal;
-exports.signal = signal;

package/dist/value.cjs

@@ -1,38 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const batch = require("./batch.cjs");
-const computed = require("./computed.cjs");
-const effect = require("./effect.cjs");
-function emitValue(state) {
-  for (const computed2 of state.computeds) {
-    computed2.effect.dirty = true;
-  }
-  for (const effect2 of state.effects) {
-    batch.batchedHandlers.add(effect2);
-  }
-  for (const [, subscription] of state.subscriptions) {
-    batch.batchedHandlers.add(subscription);
-  }
-  if (batch.batchDepth === 0) {
-    batch.flushEffects();
-  }
-}
-function getValue(state) {
-  if (computed.activeComputed != null) {
-    state.computeds.add(computed.activeComputed);
-  }
-  if (effect.activeEffect != null) {
-    state.effects.add(effect.activeEffect);
-  }
-  return state.value;
-}
-function setValue(state, value) {
-  if (Object.is(state.value, value)) {
-    return;
-  }
-  state.value = value;
-  emitValue(state);
-}
-exports.emitValue = emitValue;
-exports.getValue = getValue;
-exports.setValue = setValue;

package/dist/value.js

@@ -1,38 +0,0 @@
-import { batchedHandlers, flushEffects, batchDepth } from "./batch.js";
-import { activeComputed } from "./computed.js";
-import { activeEffect } from "./effect.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) {
-    flushEffects();
-  }
-}
-function getValue(state) {
-  if (activeComputed != null) {
-    state.computeds.add(activeComputed);
-  }
-  if (activeEffect != null) {
-    state.effects.add(activeEffect);
-  }
-  return state.value;
-}
-function setValue(state, value) {
-  if (Object.is(state.value, value)) {
-    return;
-  }
-  state.value = value;
-  emitValue(state);
-}
-export {
-  emitValue,
-  getValue,
-  setValue
-};

package/src/is.ts

@@ -1,39 +0,0 @@
-import type {PlainObject} from '@oscarpalmer/atoms/models';
-import type {Computed} from './computed';
-import type {Effect} from './effect';
-import type {Reactive} from './reactive';
-import type {Signal} from './signal';
-
-/**
- * Is the value a computed signal?
- */
-export function isComputed(value: unknown): value is Computed<unknown> {
-	return isMora<Computed<unknown>>(value, 'computed');
-}
-
-/**
- * Is the value an effect?
- */
-export function isEffect(value: unknown): value is Effect {
-	return isMora<Effect>(value, 'effect');
-}
-
-function isMora<T>(value: unknown, name: string): value is T {
-	return (
-		typeof value === 'object' &&
-		value != null &&
-		'$mora' in value &&
-		(value as PlainObject).$mora === name
-	);
-}
-
-export function isReactive(value: unknown): value is Reactive<unknown> {
-	return isComputed(value) || isSignal(value);
-}
-
-/**
- * Is the value a signal?
- */
-export function isSignal(value: unknown): value is Signal<unknown> {
-	return isMora<Signal<unknown>>(value, 'signal');
-}

package/src/value.ts

@@ -1,47 +0,0 @@
-import {batchDepth, batchedHandlers, flushEffects} from './batch';
-import {type InternalComputed, activeComputed} from './computed';
-import {activeEffect} from './effect';
-import type {ReactiveState} from './reactive';
-
-export function emitValue<Value>(state: ReactiveState<Value>): void {
-	for (const computed of state.computeds) {
-		(computed as unknown as InternalComputed).effect.dirty = true;
-	}
-
-	for (const effect of state.effects) {
-		batchedHandlers.add(effect);
-	}
-
-	for (const [, subscription] of state.subscriptions) {
-		batchedHandlers.add(subscription as never);
-	}
-
-	if (batchDepth === 0) {
-		flushEffects();
-	}
-}
-
-export function getValue<Value>(state: ReactiveState<Value>): Value {
-	if (activeComputed != null) {
-		state.computeds.add(activeComputed);
-	}
-
-	if (activeEffect != null) {
-		state.effects.add(activeEffect);
-	}
-
-	return state.value;
-}
-
-export function setValue<Value>(
-	state: ReactiveState<Value>,
-	value: Value,
-): void {
-	if (Object.is(state.value, value)) {
-		return;
-	}
-
-	state.value = value;
-
-	emitValue(state);
-}

package/types/array.d.ts

@@ -1,41 +0,0 @@
-import { Reactive } from './reactive';
-export declare class ReactiveArray<Item> extends Reactive<Item[]> {
-    #private;
-    /**
-     * The length of the array
-     */
-    get length(): number;
-    /**
-     * Set the length of the array
-     */
-    set length(value: number);
-    constructor(value: Item[]);
-    /**
-     * @inheritdoc
-     */
-    get(): Item[];
-    /**
-     * @inheritdoc
-     */
-    peek(): Item[];
-    /**
-     * Get the length of the array _(without reactivity)_
-     */
-    peek(length: true): number;
-    /**
-     * Set the value
-     */
-    set(value: Item[]): void;
-    /**
-     * Set the value at an index
-     */
-    set(index: number, value: Item): void;
-    /**
-     * Set the length of the array
-     */
-    set(property: 'length', value: number): void;
-}
-/**
- * Create a reactive array
- */
-export declare function array<Item>(value: Item[]): ReactiveArray<Item>;

package/types/is.d.ts

@@ -1,17 +0,0 @@
-import type { Computed } from './computed';
-import type { Effect } from './effect';
-import type { Reactive } from './reactive';
-import type { Signal } from './signal';
-/**
- * Is the value a computed signal?
- */
-export declare function isComputed(value: unknown): value is Computed<unknown>;
-/**
- * Is the value an effect?
- */
-export declare function isEffect(value: unknown): value is Effect;
-export declare function isReactive(value: unknown): value is Reactive<unknown>;
-/**
- * Is the value a signal?
- */
-export declare function isSignal(value: unknown): value is Signal<unknown>;

package/types/{computed.d.cts → value/computed.d.cts}

@@ -27,15 +27,6 @@ export declare class Computed<Value> extends Reactive<Value> {
  * Create a computed value
  */
 export declare function computed<Value>(callback: () => Value): Computed<Value>;
-declare class Subscription<Value> {
-	state: ReactiveState<Value>;
-	callback: GenericCallback;
-	constructor(state: ReactiveState<Value>, callback: GenericCallback);
-}
-/**
- * Unsubscribe from changes
- */
-export type Unsubscribe = () => void;
 declare abstract class Reactive<Value> {
 	protected readonly state: ReactiveState<Value>;
 	constructor(name: string, value: Value);
@@ -70,5 +61,14 @@ export type ReactiveState<Value> = {
 	subscriptions: Map<(value: Value) => void, Subscription<Value>>;
 	value: Value;
 };
+declare class Subscription<Value> {
+	state: ReactiveState<Value>;
+	callback: GenericCallback;
+	constructor(state: ReactiveState<Value>, callback: GenericCallback);
+}
+/**
+ * Unsubscribe from changes
+ */
+export type Unsubscribe = () => void;
 
 export {};

package/types/{reactive.d.cts → value/reactive.d.cts}

@@ -14,15 +14,6 @@ declare class Computed<Value> extends Reactive<Value> {
 	 */
 	get(): Value;
 }
-declare class Subscription<Value> {
-	state: ReactiveState<Value>;
-	callback: GenericCallback;
-	constructor(state: ReactiveState<Value>, callback: GenericCallback);
-}
-/**
- * Unsubscribe from changes
- */
-export type Unsubscribe = () => void;
 export declare abstract class Reactive<Value> {
 	protected readonly state: ReactiveState<Value>;
 	constructor(name: string, value: Value);
@@ -57,5 +48,14 @@ export type ReactiveState<Value> = {
 	subscriptions: Map<(value: Value) => void, Subscription<Value>>;
 	value: Value;
 };
+declare class Subscription<Value> {
+	state: ReactiveState<Value>;
+	callback: GenericCallback;
+	constructor(state: ReactiveState<Value>, callback: GenericCallback);
+}
+/**
+ * Unsubscribe from changes
+ */
+export type Unsubscribe = () => void;
 
 export {};

package/types/{signal.d.cts → value/signal.d.cts}

@@ -14,15 +14,6 @@ declare class Computed<Value> extends Reactive<Value> {
 	 */
 	get(): Value;
 }
-declare class Subscription<Value> {
-	state: ReactiveState<Value>;
-	callback: GenericCallback;
-	constructor(state: ReactiveState<Value>, callback: GenericCallback);
-}
-/**
- * Unsubscribe from changes
- */
-export type Unsubscribe = () => void;
 declare abstract class Reactive<Value> {
 	protected readonly state: ReactiveState<Value>;
 	constructor(name: string, value: Value);
@@ -57,6 +48,15 @@ export type ReactiveState<Value> = {
 	subscriptions: Map<(value: Value) => void, Subscription<Value>>;
 	value: Value;
 };
+declare class Subscription<Value> {
+	state: ReactiveState<Value>;
+	callback: GenericCallback;
+	constructor(state: ReactiveState<Value>, callback: GenericCallback);
+}
+/**
+ * Unsubscribe from changes
+ */
+export type Unsubscribe = () => void;
 export declare class Signal<Value> extends Reactive<Value> {
 	constructor(value: Value);
 	/**