@oscarpalmer/mora 0.18.2 → 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.2"
+	"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/helpers/is.d.cts

@@ -83,10 +83,6 @@ declare class ReactiveArray<Item> extends Reactive<Item[], Item> {
 	 */
 	set length(value: number);
 	constructor(value: Item[], options?: ReactiveOptions<Item>);
-	/**
-	 * Get an indexed item
-	 */
-	at(index: number): Item | undefined;
 	/**
 	 * Clear the array
 	 */
@@ -95,6 +91,8 @@ declare class ReactiveArray<Item> extends Reactive<Item[], Item> {
 	 * @inheritdoc
 	 */
 	get(): Item[];
+	get(index: number): Item | undefined;
+	get(property: "length"): number;
 	/**
 	 * Create a computed, filtered array
 	 */
@@ -160,6 +158,7 @@ declare class Signal<Value> extends Reactive<Value> {
 	update(callback: (value: Value) => Value): void;
 }
 declare class Store<Value extends PlainObject> extends Reactive<Value, Value> {
+	#private;
 	constructor(value: Value, options?: ReactiveOptions<Value>);
 	/**
 	 * @inheritdoc

package/types/helpers/proxy.d.cts

@@ -5,6 +5,14 @@
  */
 export type ArrayOrPlainObject = unknown[] | Record<PropertyKey, unknown>;
 export type GenericCallback = (...args: any[]) => any;
+/**
+ * A useful key type
+ */
+export type Key = number | string;
+/**
+ * A generic object
+ */
+export type PlainObject = Record<PropertyKey, unknown>;
 declare class Effect {
 	private readonly $mora;
 	private readonly state;
@@ -68,6 +76,76 @@ declare class Subscription<Value> {
  * Unsubscribe from changes
  */
 export type Unsubscribe = () => void;
+declare class ReactiveArray<Item> extends Reactive<Item[], Item> {
+	#private;
+	/**
+	 * The length of the array
+	 */
+	get length(): number;
+	/**
+	 * Set the length of the array
+	 */
+	set length(value: number);
+	constructor(value: Item[], options?: ReactiveOptions<Item>);
+	/**
+	 * Clear the array
+	 */
+	clear(): void;
+	/**
+	 * @inheritdoc
+	 */
+	get(): Item[];
+	get(index: number): Item | undefined;
+	get(property: "length"): number;
+	/**
+	 * 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;
+}
 declare class Signal<Value> extends Reactive<Value> {
 	constructor(value: Value, options?: ReactiveOptions<Value>);
 	/**
@@ -83,6 +161,48 @@ declare class Signal<Value> extends Reactive<Value> {
 	 */
 	update(callback: (value: Value) => Value): void;
 }
+declare class Store<Value extends PlainObject> extends Reactive<Value, Value> {
+	#private;
+	constructor(value: Value, options?: ReactiveOptions<Value>);
+	/**
+	 * @inheritdoc
+	 */
+	get(): Value;
+	/**
+	 * Get a value by key _(without reactivity)_
+	 */
+	get(key: keyof Value): Value[keyof Value];
+	/**
+	 * Get a value by key _(without reactivity)_
+	 */
+	get(key: Key): unknown;
+	/**
+	 * Get the value _(without reactivity)_
+	 */
+	peek(): Value;
+	/**
+	 * Get a value by key _(without reactivity)_
+	 */
+	peek(key: keyof Value): Value[keyof Value];
+	/**
+	 * Get a value by key _(without reactivity)_
+	 */
+	peek(key: Key): unknown;
+	/**
+	 * Set the value
+	 */
+	set(value?: Value): void;
+	/**
+	 * Set a value by key
+	 */
+	set(key: keyof Value, value: Value[keyof Value]): void;
+	/**
+	 * Set a value by key
+	 */
+	set(key: Key, value: unknown): void;
+}
+export declare function getReactiveValueInProxy<Value>(array: ReactiveArray<Value>, mapped: Map<Key, Computed<unknown>>, index: number, isArray: true): unknown;
+export declare function getReactiveValueInProxy<Value extends PlainObject>(store: Store<Value>, mapped: Map<Key, Computed<unknown>>, key: Key, isArray: false): unknown;
 export declare function setProxyValue(proxy: ArrayOrPlainObject, value: ArrayOrPlainObject): void;
 export declare function setValueInProxy<Value extends ArrayOrPlainObject, Equal>(target: Value, property: PropertyKey, value: unknown, state: ReactiveState<Value, Equal>, isArray: boolean, length?: Signal<number>): boolean;
 

package/types/helpers/proxy.d.ts

@@ -1,5 +1,10 @@
-import type { ArrayOrPlainObject } from '@oscarpalmer/atoms/models';
+import type { ArrayOrPlainObject, Key, PlainObject } from '@oscarpalmer/atoms/models';
+import type { ReactiveArray } from '../value/array';
+import { type Computed } from '../value/computed';
 import type { ReactiveState } from '../value/reactive';
 import type { Signal } from '../value/signal';
+import type { Store } from '../value/store';
+export declare function getReactiveValueInProxy<Value>(array: ReactiveArray<Value>, mapped: Map<Key, Computed<unknown>>, index: number, isArray: true): unknown;
+export declare function getReactiveValueInProxy<Value extends PlainObject>(store: Store<Value>, mapped: Map<Key, Computed<unknown>>, key: Key, isArray: false): unknown;
 export declare function setProxyValue(proxy: ArrayOrPlainObject, value: ArrayOrPlainObject): void;
 export declare function setValueInProxy<Value extends ArrayOrPlainObject, Equal>(target: Value, property: PropertyKey, value: unknown, state: ReactiveState<Value, Equal>, isArray: boolean, length?: Signal<number>): boolean;

package/types/index.d.cts

@@ -99,10 +99,6 @@ export declare class ReactiveArray<Item> extends Reactive<Item[], Item> {
 	 */
 	set length(value: number);
 	constructor(value: Item[], options?: ReactiveOptions<Item>);
-	/**
-	 * Get an indexed item
-	 */
-	at(index: number): Item | undefined;
 	/**
 	 * Clear the array
 	 */
@@ -111,6 +107,8 @@ export declare class ReactiveArray<Item> extends Reactive<Item[], Item> {
 	 * @inheritdoc
 	 */
 	get(): Item[];
+	get(index: number): Item | undefined;
+	get(property: "length"): number;
 	/**
 	 * Create a computed, filtered array
 	 */
@@ -184,6 +182,7 @@ export declare class Signal<Value> extends Reactive<Value> {
  */
 export declare function signal<Value>(value: Value, options?: ReactiveOptions<Value>): Signal<Value>;
 export declare class Store<Value extends PlainObject> extends Reactive<Value, Value> {
+	#private;
 	constructor(value: Value, options?: ReactiveOptions<Value>);
 	/**
 	 * @inheritdoc

package/types/value/array.d.cts

@@ -75,10 +75,6 @@ export declare class ReactiveArray<Item> extends Reactive<Item[], Item> {
 	 */
 	set length(value: number);
 	constructor(value: Item[], options?: ReactiveOptions<Item>);
-	/**
-	 * Get an indexed item
-	 */
-	at(index: number): Item | undefined;
 	/**
 	 * Clear the array
 	 */
@@ -87,6 +83,8 @@ export declare class ReactiveArray<Item> extends Reactive<Item[], Item> {
 	 * @inheritdoc
 	 */
 	get(): Item[];
+	get(index: number): Item | undefined;
+	get(property: "length"): number;
 	/**
 	 * Create a computed, filtered array
 	 */

package/types/value/array.d.ts

@@ -11,10 +11,6 @@ export declare class ReactiveArray<Item> extends Reactive<Item[], Item> {
      */
     set length(value: number);
     constructor(value: Item[], options?: ReactiveOptions<Item>);
-    /**
-     * Get an indexed item
-     */
-    at(index: number): Item | undefined;
     /**
      * Clear the array
      */
@@ -23,6 +19,8 @@ export declare class ReactiveArray<Item> extends Reactive<Item[], Item> {
      * @inheritdoc
      */
     get(): Item[];
+    get(index: number): Item | undefined;
+    get(property: 'length'): number;
     /**
      * Create a computed, filtered array
      */

package/types/value/store.d.cts

@@ -73,6 +73,7 @@ declare class Subscription<Value> {
  */
 export type Unsubscribe = () => void;
 export declare class Store<Value extends PlainObject> extends Reactive<Value, Value> {
+	#private;
 	constructor(value: Value, options?: ReactiveOptions<Value>);
 	/**
 	 * @inheritdoc

package/types/value/store.d.ts

@@ -1,6 +1,7 @@
 import type { Key, PlainObject } from '@oscarpalmer/atoms/models';
 import { Reactive, type ReactiveOptions } from './reactive';
 export declare class Store<Value extends PlainObject> extends Reactive<Value, Value> {
+    #private;
     constructor(value: Value, options?: ReactiveOptions<Value>);
     /**
      * @inheritdoc