@oscarpalmer/mora 0.18.1 → 0.19.0

package/dist/helpers/proxy.cjs

@@ -1,7 +1,19 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const batch = require("../batch.cjs");
+const value_computed = require("../value/computed.cjs");
 const helpers_value = require("./value.cjs");
+function getReactiveValueInProxy(reactive, mapped, key, isArray) {
+  let item = mapped.get(key);
+  if (item == null) {
+    item = value_computed.computed(() => {
+      const value = reactive.get();
+      return isArray ? value.at(key) : value[key];
+    });
+    mapped.set(key, item);
+  }
+  return item.get();
+}
 function setProxyValue(proxy, value) {
   batch.startBatch();
   const proxyKeys = Object.keys(proxy);
@@ -39,5 +51,6 @@ function setValueInProxy(target, property, value, state, isArray, length) {
   }
   return true;
 }
+exports.getReactiveValueInProxy = getReactiveValueInProxy;
 exports.setProxyValue = setProxyValue;
 exports.setValueInProxy = setValueInProxy;

package/dist/helpers/proxy.js

@@ -1,5 +1,17 @@
 import { startBatch, stopBatch } from "../batch.js";
+import { computed } from "../value/computed.js";
 import { emitValue } from "./value.js";
+function getReactiveValueInProxy(reactive, mapped, key, isArray) {
+  let item = mapped.get(key);
+  if (item == null) {
+    item = computed(() => {
+      const value = reactive.get();
+      return isArray ? value.at(key) : value[key];
+    });
+    mapped.set(key, item);
+  }
+  return item.get();
+}
 function setProxyValue(proxy, value) {
   startBatch();
   const proxyKeys = Object.keys(proxy);
@@ -38,6 +50,7 @@ function setValueInProxy(target, property, value, state, isArray, length) {
   return true;
 }
 export {
+  getReactiveValueInProxy,
   setProxyValue,
   setValueInProxy
 };

package/dist/mora.full.js

@@ -278,6 +278,19 @@ function getValue(state) {
     return state.value;
 }
 
+function getReactiveValueInProxy(reactive, mapped, key, isArray) {
+    let item = mapped.get(key);
+    if (item == null) {
+        item = computed(() => {
+            const value = reactive.get();
+            return isArray
+                ? value.at(key)
+                : value[key];
+        });
+        mapped.set(key, item);
+    }
+    return item.get();
+}
 function setProxyValue(proxy, value) {
     startBatch();
     const proxyKeys = Object.keys(proxy);
@@ -352,6 +365,7 @@ function signal(value, options) {
 }
 
 class ReactiveArray extends Reactive {
+    #indiced = new Map();
     #size = signal(0);
     /**
      * The length of the array
@@ -378,22 +392,19 @@ class ReactiveArray extends Reactive {
         }), options);
         this.#size.set(value.length);
     }
-    /**
-     * Get an indexed item
-     */
-    at(index) {
-        return this.get().at(index);
-    }
     /**
      * Clear the array
      */
     clear() {
         this.length = 0;
     }
-    /**
-     * @inheritdoc
-     */
-    get() {
+    get(first) {
+        if (typeof first === 'number') {
+            return getReactiveValueInProxy(this, this.#indiced, first, true);
+        }
+        if (first === 'length') {
+            return this.length;
+        }
         return getValue(this.state);
     }
     /**
@@ -504,13 +515,16 @@ function isPlainObject(value) {
 }
 
 class Store extends Reactive {
+    #keyed = new Map();
     constructor(value, options) {
         super(storeName, new Proxy(value, {
             set: (target, property, value) => setValueInProxy(target, property, value, this.state, false),
         }), options);
     }
     get(key) {
-        return isKey(key) ? this.state.value[key] : getValue(this.state);
+        return isKey(key)
+            ? getReactiveValueInProxy(this, this.#keyed, key, false)
+            : getValue(this.state);
     }
     peek(key) {
         return isKey(key) ? this.state.value[key] : { ...this.state.value };

package/dist/value/array.cjs

@@ -5,7 +5,7 @@ var __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;
+var _indiced, _size;
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const helpers_is = require("../helpers/is.cjs");
 const helpers_proxy = require("../helpers/proxy.cjs");
@@ -30,6 +30,7 @@ class ReactiveArray extends value_reactive.Reactive {
       }),
       options
     );
+    __privateAdd(this, _indiced, /* @__PURE__ */ new Map());
     __privateAdd(this, _size, value_signal.signal(0));
     __privateGet(this, _size).set(value.length);
   }
@@ -47,22 +48,19 @@ class ReactiveArray extends value_reactive.Reactive {
       this.get().length = value;
     }
   }
-  /**
-   * Get an indexed item
-   */
-  at(index) {
-    return this.get().at(index);
-  }
   /**
    * Clear the array
    */
   clear() {
     this.length = 0;
   }
-  /**
-   * @inheritdoc
-   */
-  get() {
+  get(first) {
+    if (typeof first === "number") {
+      return helpers_proxy.getReactiveValueInProxy(this, __privateGet(this, _indiced), first, true);
+    }
+    if (first === "length") {
+      return this.length;
+    }
     return helpers_value.getValue(this.state);
   }
   /**
@@ -124,6 +122,7 @@ class ReactiveArray extends value_reactive.Reactive {
     return this.state.value.unshift(...items);
   }
 }
+_indiced = new WeakMap();
 _size = new WeakMap();
 function array(value, options) {
   return new ReactiveArray(Array.isArray(value) ? value : [], options);

package/dist/value/array.js

@@ -4,9 +4,9 @@ var __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;
+var _indiced, _size;
 import { arrayName } from "../helpers/is.js";
-import { setValueInProxy } from "../helpers/proxy.js";
+import { setValueInProxy, getReactiveValueInProxy } from "../helpers/proxy.js";
 import { getValue, equalArrays, emitValue } from "../helpers/value.js";
 import { computed } from "./computed.js";
 import { Reactive } from "./reactive.js";
@@ -28,6 +28,7 @@ class ReactiveArray extends Reactive {
       }),
       options
     );
+    __privateAdd(this, _indiced, /* @__PURE__ */ new Map());
     __privateAdd(this, _size, signal(0));
     __privateGet(this, _size).set(value.length);
   }
@@ -45,22 +46,19 @@ class ReactiveArray extends Reactive {
       this.get().length = value;
     }
   }
-  /**
-   * Get an indexed item
-   */
-  at(index) {
-    return this.get().at(index);
-  }
   /**
    * Clear the array
    */
   clear() {
     this.length = 0;
   }
-  /**
-   * @inheritdoc
-   */
-  get() {
+  get(first) {
+    if (typeof first === "number") {
+      return getReactiveValueInProxy(this, __privateGet(this, _indiced), first, true);
+    }
+    if (first === "length") {
+      return this.length;
+    }
     return getValue(this.state);
   }
   /**
@@ -122,6 +120,7 @@ class ReactiveArray extends Reactive {
     return this.state.value.unshift(...items);
   }
 }
+_indiced = new WeakMap();
 _size = new WeakMap();
 function array(value, options) {
   return new ReactiveArray(Array.isArray(value) ? value : [], options);

package/dist/value/store.cjs

@@ -1,4 +1,11 @@
 "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 _keyed;
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const is = require("../node_modules/@oscarpalmer/atoms/dist/internal/is.cjs");
 const helpers_is = require("../helpers/is.cjs");
@@ -14,9 +21,10 @@ class Store extends value_reactive.Reactive {
       }),
       options
     );
+    __privateAdd(this, _keyed, /* @__PURE__ */ new Map());
   }
   get(key) {
-    return is.isKey(key) ? this.state.value[key] : helpers_value.getValue(this.state);
+    return is.isKey(key) ? helpers_proxy.getReactiveValueInProxy(this, __privateGet(this, _keyed), key, false) : helpers_value.getValue(this.state);
   }
   peek(key) {
     return is.isKey(key) ? this.state.value[key] : { ...this.state.value };
@@ -29,6 +37,7 @@ class Store extends value_reactive.Reactive {
     }
   }
 }
+_keyed = new WeakMap();
 function store(value, options) {
   return new Store(is.isPlainObject(value) ? value : {}, options);
 }

package/dist/value/store.js

@@ -1,6 +1,13 @@
+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, setProxyValue } from "../helpers/proxy.js";
+import { setValueInProxy, getReactiveValueInProxy, setProxyValue } from "../helpers/proxy.js";
 import { getValue } from "../helpers/value.js";
 import { Reactive } from "./reactive.js";
 class Store extends Reactive {
@@ -12,9 +19,10 @@ class Store extends Reactive {
       }),
       options
     );
+    __privateAdd(this, _keyed, /* @__PURE__ */ new Map());
   }
   get(key) {
-    return isKey(key) ? this.state.value[key] : getValue(this.state);
+    return isKey(key) ? getReactiveValueInProxy(this, __privateGet(this, _keyed), key, false) : getValue(this.state);
   }
   peek(key) {
     return isKey(key) ? this.state.value[key] : { ...this.state.value };
@@ -27,6 +35,7 @@ class Store extends Reactive {
     }
   }
 }
+_keyed = new WeakMap();
 function store(value, options) {
   return new Store(isPlainObject(value) ? value : {}, options);
 }

package/package.json

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

package/src/helpers/proxy.ts

@@ -1,9 +1,53 @@
-import type {ArrayOrPlainObject, PlainObject} from '@oscarpalmer/atoms/models';
+import type {
+	ArrayOrPlainObject,
+	Key,
+	PlainObject,
+} from '@oscarpalmer/atoms/models';
 import {startBatch, stopBatch} from '../batch';
+import type {ReactiveArray} from '../value/array';
+import {type Computed, computed} from '../value/computed';
 import type {ReactiveState} from '../value/reactive';
 import type {Signal} from '../value/signal';
+import type {Store} from '../value/store';
 import {emitValue} from './value';
 
+export function getReactiveValueInProxy<Value>(
+	array: ReactiveArray<Value>,
+	mapped: Map<Key, Computed<unknown>>,
+	index: number,
+	isArray: true,
+): unknown;
+
+export function getReactiveValueInProxy<Value extends PlainObject>(
+	store: Store<Value>,
+	mapped: Map<Key, Computed<unknown>>,
+	key: Key,
+	isArray: false,
+): unknown;
+
+export function getReactiveValueInProxy(
+	reactive: ReactiveArray<unknown> | Store<PlainObject>,
+	mapped: Map<Key, Computed<unknown>>,
+	key: Key,
+	isArray: boolean,
+): unknown {
+	let item = mapped.get(key);
+
+	if (item == null) {
+		item = computed(() => {
+			const value = reactive.get();
+
+			return isArray
+				? (value as unknown[]).at(key as number)
+				: (value as PlainObject)[key];
+		}) as Computed<unknown>;
+
+		mapped.set(key, item);
+	}
+
+	return item.get();
+}
+
 export function setProxyValue(
 	proxy: ArrayOrPlainObject,
 	value: ArrayOrPlainObject,

package/src/index.ts

@@ -12,3 +12,4 @@ export {computed, type Computed} from './value/computed';
 export type {Reactive} from './value/reactive';
 export {signal, type Signal} from './value/signal';
 export {store, type Store} from './value/store';
+

package/src/value/array.ts

@@ -1,11 +1,12 @@
 import {arrayName} from '../helpers/is';
-import {setValueInProxy} from '../helpers/proxy';
+import {getReactiveValueInProxy, setValueInProxy} from '../helpers/proxy';
 import {emitValue, equalArrays, getValue} from '../helpers/value';
 import {type Computed, computed} from './computed';
 import {Reactive, type ReactiveOptions, type ReactiveState} from './reactive';
 import {type Signal, signal} from './signal';
 
 export class ReactiveArray<Item> extends Reactive<Item[], Item> {
+	#indiced = new Map<number, Computed<unknown>>();
 	#size = signal(0);
 
 	/**
@@ -52,13 +53,6 @@ export class ReactiveArray<Item> extends Reactive<Item[], Item> {
 		this.#size.set(value.length);
 	}
 
-	/**
-	 * Get an indexed item
-	 */
-	at(index: number): Item | undefined {
-		return this.get().at(index);
-	}
-
 	/**
 	 * Clear the array
 	 */
@@ -69,7 +63,21 @@ export class ReactiveArray<Item> extends Reactive<Item[], Item> {
 	/**
 	 * @inheritdoc
 	 */
-	get(): Item[] {
+	get(): Item[];
+
+	get(index: number): Item | undefined;
+
+	get(property: 'length'): number;
+
+	get(first?: unknown): unknown {
+		if (typeof first === 'number') {
+			return getReactiveValueInProxy(this, this.#indiced, first, true);
+		}
+
+		if (first === 'length') {
+			return this.length;
+		}
+
 		return getValue(this.state);
 	}
 

package/src/value/store.ts

@@ -1,11 +1,18 @@
 import {isKey, isPlainObject} from '@oscarpalmer/atoms/is';
 import type {Key, PlainObject} from '@oscarpalmer/atoms/models';
 import {storeName} from '../helpers/is';
-import {setProxyValue, setValueInProxy} from '../helpers/proxy';
+import {
+	getReactiveValueInProxy,
+	setProxyValue,
+	setValueInProxy,
+} from '../helpers/proxy';
 import {getValue} from '../helpers/value';
+import type {Computed} from './computed';
 import {Reactive, type ReactiveOptions} from './reactive';
 
 export class Store<Value extends PlainObject> extends Reactive<Value, Value> {
+	#keyed = new Map<Key, Computed<unknown>>();
+
 	constructor(value: Value, options?: ReactiveOptions<Value>) {
 		super(
 			storeName,
@@ -33,7 +40,9 @@ export class Store<Value extends PlainObject> extends Reactive<Value, Value> {
 	get(key: Key): unknown;
 
 	get(key?: unknown): unknown {
-		return isKey(key) ? this.state.value[key] : getValue(this.state);
+		return isKey(key)
+			? getReactiveValueInProxy(this, this.#keyed, key, false)
+			: getValue(this.state);
 	}
 
 	/**

package/types/batch.d.cts

@@ -0,0 +1,79 @@
+// Generated by dts-bundle-generator v9.5.1
+
+export type GenericCallback = (...args: any[]) => any;
+declare class Effect {
+	private readonly $mora;
+	private readonly state;
+	constructor(callback: GenericCallback);
+}
+declare class Computed<Value> extends Reactive<Value> {
+	private readonly effect;
+	constructor(callback: () => Value, options?: ReactiveOptions<Value>);
+	/**
+	 * @inheritdoc
+	 */
+	get(): Value;
+}
+declare abstract class Reactive<Value, Equal = Value> {
+	protected readonly state: ReactiveState<Value, Equal>;
+	constructor(name: string, value: Value, options?: ReactiveOptions<Equal>);
+	/**
+	 * Get the value
+	 */
+	abstract get(): Value;
+	/**
+	 * Get the value _(without reactivity)_
+	 */
+	peek(): Value;
+	/**
+	 * Subscribe to changes
+	 */
+	subscribe(callback: (value: Value) => void): Unsubscribe;
+	/**
+	 * JSON representation of the value
+	 */
+	toJSON(): Value;
+	/**
+	 * String representation of the value
+	 */
+	toString(): string;
+	/**
+	 * Unsubscribe from changes
+	 */
+	unsubscribe(callback: (value: Value) => void): void;
+}
+export type ReactiveOptions<Value> = {
+	/**
+	 * Method to compare values for equality
+	 */
+	equal?: (first: Value, second: Value) => boolean;
+};
+export type ReactiveState<Value, Equal> = {
+	computeds: Set<Computed<unknown>>;
+	effects: Set<Effect>;
+	equal: (first: Equal, second: Equal) => boolean;
+	subscriptions: Map<(value: Value) => void, Subscription<Value>>;
+	value: Value;
+};
+declare class Subscription<Value> {
+	state: ReactiveState<Value, never>;
+	callback: GenericCallback;
+	constructor(state: ReactiveState<Value, never>, callback: GenericCallback);
+}
+/**
+ * Unsubscribe from changes
+ */
+export type Unsubscribe = () => void;
+export declare function flushHandlers(): void;
+/**
+ * Start batching effects _(use `stopBatch` to flush and run batched effects)_
+ */
+export declare function startBatch(): void;
+/**
+ * Stop batching effects and flush _(run)_ them
+ */
+export declare function stopBatch(): void;
+export declare const batchedHandlers: Set<Effect | Subscription<unknown>>;
+export declare let batchDepth: number;
+
+export {};

package/types/effect.d.cts

@@ -0,0 +1,16 @@
+// Generated by dts-bundle-generator v9.5.1
+
+export type GenericCallback = (...args: any[]) => any;
+export declare class Effect {
+	private readonly $mora;
+	private readonly state;
+	constructor(callback: GenericCallback);
+}
+export declare function runEffect(effect: Effect): void;
+/**
+ * Create an effect
+ */
+export declare function effect(callback: GenericCallback): Effect;
+export declare let activeEffect: Effect | undefined;
+
+export {};