@oscarpalmer/mora 0.26.0 → 0.27.0

package/dist/batch.d.mts

@@ -0,0 +1,14 @@
+//#region src/batch.d.ts
+declare function flushHandlers(): void;
+/**
+ * Start batching effects
+ *
+ * _(Use {@link stopBatch} to flush and run batched effects)_
+ */
+declare function startBatch(): void;
+/**
+ * Stop batching effects and flush _(run)_ them
+ */
+declare function stopBatch(): void;
+//#endregion
+export { flushHandlers, startBatch, stopBatch };

package/dist/{batch.js → batch.mjs}

@@ -1,6 +1,7 @@
-import { BATCH } from "./constants.js";
-import { runEffect } from "./effect.js";
-import { isEffect } from "./helpers/is.js";
+import { BATCH } from "./constants.mjs";
+import { runEffect } from "./effect.mjs";
+import { isEffect } from "./helpers/is.mjs";
+//#region src/batch.ts
 function flushHandlers() {
 	while (BATCH.depth === 0 && BATCH.handlers.size > 0) {
 		const handlers = [...BATCH.handlers];
@@ -9,11 +10,20 @@ function flushHandlers() {
 		else handler.callback(handler.state.value);
 	}
 }
+/**
+* Start batching effects
+*
+* _(Use {@link stopBatch} to flush and run batched effects)_
+*/
 function startBatch() {
 	BATCH.depth += 1;
 }
+/**
+* Stop batching effects and flush _(run)_ them
+*/
 function stopBatch() {
 	if (BATCH.depth > 0) BATCH.depth -= 1;
 	flushHandlers();
 }
+//#endregion
 export { flushHandlers, startBatch, stopBatch };

package/dist/constants-Cy6_M9Vk.d.mts

@@ -0,0 +1,20 @@
+import { n as Batch, t as Active } from "./models-QwNga87R.mjs";
+
+//#region src/constants.d.ts
+declare const ACTIVE: Active;
+declare const ARRAY_THRESHOLD = 100;
+declare const ARRAY_OFFSET = 25;
+declare const ARRAY_PEEK = 10;
+declare const BATCH: Batch;
+declare const METHODS_AFFECTING_LENGTH: Set<string>;
+declare const METHODS_UPDATE: Set<string>;
+declare const NAME_ARRAY = "array";
+declare const NAME_COMPUTED = "computed";
+declare const NAME_EFFECT = "effect";
+declare const NAME_MORA = "$mora";
+declare const NAME_SIGNAL = "signal";
+declare const NAME_STORE = "store";
+declare const NAME_ALL: Set<string>;
+declare const PROPERTY_LENGTH = "length";
+//#endregion
+export { BATCH as a, NAME_ALL as c, NAME_EFFECT as d, NAME_MORA as f, PROPERTY_LENGTH as h, ARRAY_THRESHOLD as i, NAME_ARRAY as l, NAME_STORE as m, ARRAY_OFFSET as n, METHODS_AFFECTING_LENGTH as o, NAME_SIGNAL as p, ARRAY_PEEK as r, METHODS_UPDATE as s, ACTIVE as t, NAME_COMPUTED as u };

package/dist/constants.d.mts

@@ -0,0 +1,2 @@
+import { a as BATCH, c as NAME_ALL, d as NAME_EFFECT, f as NAME_MORA, h as PROPERTY_LENGTH, i as ARRAY_THRESHOLD, l as NAME_ARRAY, m as NAME_STORE, n as ARRAY_OFFSET, o as METHODS_AFFECTING_LENGTH, p as NAME_SIGNAL, r as ARRAY_PEEK, s as METHODS_UPDATE, t as ACTIVE, u as NAME_COMPUTED } from "./constants-Cy6_M9Vk.mjs";
+export { ACTIVE, ARRAY_OFFSET, ARRAY_PEEK, ARRAY_THRESHOLD, BATCH, METHODS_AFFECTING_LENGTH, METHODS_UPDATE, NAME_ALL, NAME_ARRAY, NAME_COMPUTED, NAME_EFFECT, NAME_MORA, NAME_SIGNAL, NAME_STORE, PROPERTY_LENGTH };

package/dist/{constants.js → constants.mjs}

@@ -1,3 +1,4 @@
+//#region src/constants.ts
 const ACTIVE = {};
 const ARRAY_THRESHOLD = 100;
 const ARRAY_OFFSET = 25;
@@ -33,4 +34,5 @@ const NAME_ALL = new Set([
 	NAME_STORE
 ]);
 const PROPERTY_LENGTH = "length";
+//#endregion
 export { ACTIVE, ARRAY_OFFSET, ARRAY_PEEK, ARRAY_THRESHOLD, BATCH, METHODS_AFFECTING_LENGTH, METHODS_UPDATE, NAME_ALL, NAME_ARRAY, NAME_COMPUTED, NAME_EFFECT, NAME_MORA, NAME_SIGNAL, NAME_STORE, PROPERTY_LENGTH };

package/dist/effect-BkupB1p9.d.mts

@@ -0,0 +1,17 @@
+import { GenericCallback } from "@oscarpalmer/atoms/models";
+
+//#region src/effect.d.ts
+declare class Effect {
+  private readonly $mora;
+  private readonly state;
+  constructor(callback: GenericCallback);
+}
+declare function runEffect(effect: Effect): void;
+/**
+ * Create an effect
+ * @param callback Callback for handling signal effects
+ * @returns Effect
+ */
+declare function effect(callback: GenericCallback): Effect;
+//#endregion
+export { effect as n, runEffect as r, Effect as t };

package/dist/effect.d.mts

@@ -0,0 +1,2 @@
+import { n as effect, r as runEffect, t as Effect } from "./effect-BkupB1p9.mjs";
+export { Effect, effect, runEffect };

package/dist/{effect.js → effect.mjs}

@@ -1,4 +1,5 @@
-import { ACTIVE, NAME_EFFECT, NAME_MORA } from "./constants.js";
+import { ACTIVE, NAME_EFFECT, NAME_MORA } from "./constants.mjs";
+//#region src/effect.ts
 var Effect = class {
 	constructor(callback) {
 		Object.defineProperty(this, NAME_MORA, { value: NAME_EFFECT });
@@ -6,16 +7,22 @@ var Effect = class {
 		runEffect(this);
 	}
 };
-function runEffect(effect$1) {
+function runEffect(effect) {
 	const previousEffect = ACTIVE.effect;
-	ACTIVE.effect = effect$1;
+	ACTIVE.effect = effect;
 	try {
-		effect$1.state.callback();
+		effect.state.callback();
 	} finally {
 		ACTIVE.effect = previousEffect;
 	}
 }
+/**
+* Create an effect
+* @param callback Callback for handling signal effects
+* @returns Effect
+*/
 function effect(callback) {
 	return typeof callback === "function" ? new Effect(callback) : void 0;
 }
+//#endregion
 export { Effect, effect, runEffect };

package/dist/helpers/is.d.mts

@@ -0,0 +1,45 @@
+import { t as Effect } from "../effect-BkupB1p9.mjs";
+import { d as Signal, h as Reactive, p as Computed } from "../models-QwNga87R.mjs";
+import { ReactiveArray } from "../value/array.mjs";
+import { Store } from "../value/store.mjs";
+import { PlainObject } from "@oscarpalmer/atoms/models";
+
+//#region src/helpers/is.d.ts
+/**
+ * Is the value a reactive array?
+ * @param value Value to check
+ * @returns True if value is a {@link ReactiveArray}
+ */
+declare function isArray<Item>(value: unknown): value is ReactiveArray<Item>;
+/**
+ * Is the value a computed signal?
+ * @param value Value to check
+ * @returns True if value is a {@link Computed}
+ */
+declare function isComputed<Value>(value: unknown): value is Computed<Value>;
+/**
+ * Is the value an effect?
+ * @param value Value to check
+ * @returns True if value is an {@link Effect}
+ */
+declare function isEffect(value: unknown): value is Effect;
+/**
+ * Is the value reactive?
+ * @param value Value to check
+ * @returns True if value is a {@link Reactive}
+ */
+declare function isReactive<Value, Equal = Value>(value: unknown): value is Reactive<Value, Equal>;
+/**
+ * Is the value a signal?
+ * @param value Value to check
+ * @returns True if value is a {@link Signal}
+ */
+declare function isSignal<Value>(value: unknown): value is Signal<Value>;
+/**
+ * Is the value a reactive store?
+ * @param value Value to check
+ * @returns True if value is a {@link Store}
+ */
+declare function isStore<Value extends PlainObject>(value: unknown): value is Store<Value>;
+//#endregion
+export { isArray, isComputed, isEffect, isReactive, isSignal, isStore };

package/dist/helpers/is.mjs

@@ -0,0 +1,55 @@
+import { NAME_ALL, NAME_ARRAY, NAME_COMPUTED, NAME_EFFECT, NAME_SIGNAL, NAME_STORE } from "../constants.mjs";
+//#region src/helpers/is.ts
+/**
+* Is the value a reactive array?
+* @param value Value to check
+* @returns True if value is a {@link ReactiveArray}
+*/
+function isArray(value) {
+	return isMora(value, NAME_ARRAY);
+}
+/**
+* Is the value a computed signal?
+* @param value Value to check
+* @returns True if value is a {@link Computed}
+*/
+function isComputed(value) {
+	return isMora(value, NAME_COMPUTED);
+}
+/**
+* Is the value an effect?
+* @param value Value to check
+* @returns True if value is an {@link Effect}
+*/
+function isEffect(value) {
+	return isMora(value, NAME_EFFECT);
+}
+function isMora(value, name) {
+	return typeof value === "object" && value != null && "$mora" in value && (typeof name === "string" ? value["$mora"] === name : name.has(value["$mora"]));
+}
+/**
+* Is the value reactive?
+* @param value Value to check
+* @returns True if value is a {@link Reactive}
+*/
+function isReactive(value) {
+	return isMora(value, NAME_ALL);
+}
+/**
+* Is the value a signal?
+* @param value Value to check
+* @returns True if value is a {@link Signal}
+*/
+function isSignal(value) {
+	return isMora(value, NAME_SIGNAL);
+}
+/**
+* Is the value a reactive store?
+* @param value Value to check
+* @returns True if value is a {@link Store}
+*/
+function isStore(value) {
+	return isMora(value, NAME_STORE);
+}
+//#endregion
+export { isArray, isComputed, isEffect, isReactive, isSignal, isStore };

package/dist/helpers/proxy.d.mts

@@ -0,0 +1,14 @@
+import { c as ReactiveState, l as SetValueInProxyParameters, p as Computed } from "../models-QwNga87R.mjs";
+import { ReactiveArray } from "../value/array.mjs";
+import { Store } from "../value/store.mjs";
+import { ArrayOrPlainObject, Key, PlainObject } from "@oscarpalmer/atoms/models";
+
+//#region src/helpers/proxy.d.ts
+declare function emityProxyValues<Value>(state: ReactiveState<Value, Value>, mapped: Map<Key, Computed<unknown>>): void;
+declare function emityProxyValues<Value>(state: ReactiveState<Value[], Value>, mapped: Map<Key, Computed<unknown>>): void;
+declare function getReactiveValueInProxy<Value>(array: ReactiveArray<Value>, mapped: Map<Key, Computed<unknown>>, index: number, isArray: true): Computed<unknown>;
+declare function getReactiveValueInProxy<Value extends PlainObject>(store: Store<Value>, mapped: Map<Key, Computed<unknown>>, key: Key, isArray: false): Computed<unknown>;
+declare function setProxyValue(proxy: ArrayOrPlainObject, value: ArrayOrPlainObject): void;
+declare function setValueInProxy<Value extends ArrayOrPlainObject, Equal>(parameters: SetValueInProxyParameters<Value, Equal>): boolean;
+//#endregion
+export { emityProxyValues, getReactiveValueInProxy, setProxyValue, setValueInProxy };

package/dist/helpers/{proxy.js → proxy.mjs}

@@ -1,7 +1,8 @@
-import { PROPERTY_LENGTH } from "../constants.js";
-import { startBatch, stopBatch } from "../batch.js";
-import { computed } from "../value/computed.js";
-import { emitValue } from "./value.js";
+import "../constants.mjs";
+import { startBatch, stopBatch } from "../batch.mjs";
+import { computed } from "../value/computed.mjs";
+import { emitValue } from "./value.mjs";
+//#region src/helpers/proxy.ts
 function emityProxyValues(state, mapped) {
 	const values = [...mapped.values()];
 	const { length } = values;
@@ -45,4 +46,5 @@ function setValueInProxy(parameters) {
 	}
 	return true;
 }
+//#endregion
 export { emityProxyValues, getReactiveValueInProxy, setProxyValue, setValueInProxy };

package/dist/helpers/value.d.mts

@@ -0,0 +1,8 @@
+import { c as ReactiveState } from "../models-QwNga87R.mjs";
+
+//#region src/helpers/value.d.ts
+declare function emitValue<Value>(state: ReactiveState<Value, never>): void;
+declare function equalArrays<Value>(state: ReactiveState<Value[], Value>, first: Value[], second: Value[]): boolean;
+declare function getValue<Value>(state: ReactiveState<Value, never>): Value;
+//#endregion
+export { emitValue, equalArrays, getValue };

package/dist/helpers/{value.js → value.mjs}

@@ -1,5 +1,6 @@
-import { ACTIVE, ARRAY_OFFSET, ARRAY_PEEK, ARRAY_THRESHOLD, BATCH } from "../constants.js";
-import { flushHandlers } from "../batch.js";
+import { ACTIVE, BATCH } from "../constants.mjs";
+import { flushHandlers } from "../batch.mjs";
+//#region src/helpers/value.ts
 function emitValue(state) {
 	for (const computed of state.computeds) computed.effect.dirty = true;
 	for (const effect of state.effects) BATCH.handlers.add(effect);
@@ -24,4 +25,5 @@ function getValue(state) {
 	if (ACTIVE.effect != null) state.effects.add(ACTIVE.effect);
 	return state.value;
 }
+//#endregion
 export { emitValue, equalArrays, getValue };

package/dist/index.d.mts

@@ -0,0 +1,7 @@
+import { startBatch, stopBatch } from "./batch.mjs";
+import { n as effect, t as Effect } from "./effect-BkupB1p9.mjs";
+import { d as Signal, f as signal, h as Reactive, m as computed, p as Computed, u as Unsubscribe } from "./models-QwNga87R.mjs";
+import { ReactiveArray, array } from "./value/array.mjs";
+import { Store, store } from "./value/store.mjs";
+import { isArray, isComputed, isEffect, isReactive, isSignal } from "./helpers/is.mjs";
+export { type Computed, type Effect, type Reactive, type ReactiveArray, type Signal, type Store, type Unsubscribe, array, computed, effect, isArray, isComputed, isEffect, isReactive, isSignal, signal, startBatch, stopBatch, store };

package/dist/index.mjs

@@ -0,0 +1,8 @@
+import { effect } from "./effect.mjs";
+import { isArray, isComputed, isEffect, isReactive, isSignal } from "./helpers/is.mjs";
+import { startBatch, stopBatch } from "./batch.mjs";
+import { computed } from "./value/computed.mjs";
+import { signal } from "./value/signal.mjs";
+import { array } from "./value/array.mjs";
+import { store } from "./value/store.mjs";
+export { array, computed, effect, isArray, isComputed, isEffect, isReactive, isSignal, signal, startBatch, stopBatch, store };

package/dist/models-QwNga87R.d.mts

@@ -0,0 +1,148 @@
+import { t as Effect } from "./effect-BkupB1p9.mjs";
+import { GenericCallback } from "@oscarpalmer/atoms/models";
+
+//#region src/subscription.d.ts
+declare class Subscription {
+  callback: GenericCallback;
+  state: ReactiveState<unknown, never>;
+  constructor(state: ReactiveState<unknown, never>, callback: GenericCallback);
+  destroy(): void;
+}
+declare function noop(): void;
+declare function subscribe<Value>(state: ReactiveState<Value, never>, callback: (value: Value) => void): Unsubscribe;
+declare function unsubscribe<Value>(state: ReactiveState<Value, never>, callback: (value: Value) => void): void;
+//#endregion
+//#region src/value/reactive.d.ts
+declare abstract class Reactive<Value, Equal = Value> {
+  protected readonly state: ReactiveState<Value, Equal>;
+  constructor(name: string, value: Value, options?: ReactiveOptions<Equal>);
+  /**
+   * Get the value
+   * @return Current value
+   */
+  abstract get(): Value;
+  /**
+   * Get the value _(without reactivity)_
+   * @return Current value
+   */
+  peek(): Value;
+  /**
+   * Subscribe to changes
+   * @param callback Callback for changes
+   * @return Unsubscribe callback
+   */
+  subscribe(callback: (value: Value) => void): Unsubscribe;
+  /**
+   * JSON representation of the value
+   * @return JSON value
+   */
+  toJSON(): Value;
+  /**
+   * String representation of the value
+   * @return Value as string
+   */
+  toString(): string;
+  /**
+   * Unsubscribe from changes
+   * @param callback Callback to unsubscribe
+   */
+  unsubscribe(callback: (value: Value) => void): void;
+}
+//#endregion
+//#region src/value/computed.d.ts
+declare class Computed<Value> extends Reactive<Value> {
+  private readonly effect;
+  constructor(callback: () => Value, options?: ReactiveOptions<Value>);
+  /**
+   * @inheritdoc
+   */
+  get(): Value;
+}
+/**
+ * Create a computed value
+ * @param callback Callback to compute the value
+ * @param options Reactivity options
+ * @returns Computed value
+ */
+declare function computed<Value>(callback: () => Value, options?: ReactiveOptions<Value>): Computed<Value>;
+//#endregion
+//#region src/value/signal.d.ts
+declare class Signal<Value> extends Reactive<Value> {
+  constructor(value: Value, options?: ReactiveOptions<Value>);
+  /**
+   * @inheritdoc
+   */
+  get(): Value;
+  /**
+   * Set the value
+   * @param value New value
+   */
+  set(value: Value): void;
+  /**
+   * Update the value _(based on the current value)_
+   * @param callback Callback to update the value
+   */
+  update(callback: (value: Value) => Value): void;
+}
+/**
+ * Create a reactive value
+ * @param value Initial value
+ * @param options Reactivity options
+ * @returns Reactive value
+ */
+declare function signal<Value>(value: Value, options?: ReactiveOptions<Value>): Signal<Value>;
+//#endregion
+//#region src/models.d.ts
+type Active = {
+  computed?: Computed<unknown>;
+  effect?: Effect;
+};
+type Batch = {
+  depth: number;
+  handlers: Set<Effect | Subscription>;
+};
+type ComputedEffect = {
+  dirty: boolean;
+  instance: Effect;
+};
+type EffectState = {
+  callback: GenericCallback;
+};
+type InternalComputed = {
+  readonly effect: ComputedEffect;
+  readonly state: ReactiveState<unknown, unknown>;
+};
+type InternalEffect = {
+  state: EffectState;
+};
+type ReactiveOptions<Value> = {
+  /**
+   * Method for comparing values for equality
+   * @param first First value
+   * @param second Second value
+   * @returns Are the values equal?
+   * @default Object.is
+   */
+  equal?: (first: Value, second: Value) => boolean;
+};
+type ReactiveState<Value, Equal> = {
+  computeds: Set<Computed<unknown>>;
+  effects: Set<Effect>;
+  equal: (first: Equal, second: Equal) => boolean;
+  subscriptions: Map<GenericCallback, Subscription>;
+  value: Value;
+};
+type SetValueInProxyParameters<Value, Equal> = {
+  target: Value;
+  property: PropertyKey;
+  value: unknown;
+  state: ReactiveState<Value, Equal>;
+  isArray: boolean;
+  length?: Signal<number>;
+};
+/**
+ * Unsubscribe from changes
+ */
+type Unsubscribe = () => void;
+//#endregion
+export { noop as _, InternalComputed as a, ReactiveState as c, Signal as d, signal as f, Subscription as g, Reactive as h, EffectState as i, SetValueInProxyParameters as l, computed as m, Batch as n, InternalEffect as o, Computed as p, ComputedEffect as r, ReactiveOptions as s, Active as t, Unsubscribe as u, subscribe as v, unsubscribe as y };

package/dist/models.d.mts

@@ -0,0 +1,2 @@
+import { a as InternalComputed, c as ReactiveState, i as EffectState, l as SetValueInProxyParameters, n as Batch, o as InternalEffect, r as ComputedEffect, s as ReactiveOptions, t as Active, u as Unsubscribe } from "./models-QwNga87R.mjs";
+export { Active, Batch, ComputedEffect, EffectState, InternalComputed, InternalEffect, ReactiveOptions, ReactiveState, SetValueInProxyParameters, Unsubscribe };

package/dist/models.mjs

@@ -0,0 +1 @@
+export {};