@anchorlib/svelte 1.0.0-beta.2 → 1.0.0-beta.21

package/dist/prop.js

@@ -0,0 +1,19 @@
+import "@anchorlib/core";
+
+//#region src/prop.ts
+/**
+* Creates a reactive state object from the provided props.
+* For each property in the input props:
+* - If the value is a State object, it will be converted to a derived state
+* - Otherwise, the value will be kept as is
+* @deprecated
+* @template T - The type of props extending Props
+* @param {T} props - The input props object containing KeyLike or State values
+* @returns {PropsRef<T>} A new object with State values converted to reactive states
+*/
+function propsRef(props) {
+	return props;
+}
+
+//#endregion
+export { propsRef };

package/dist/reactive.d.ts

@@ -0,0 +1,6 @@
+import { KeyLike, Linkable } from "@anchorlib/core";
+
+//#region src/reactive.d.ts
+declare const TRACKER_REGISTRY: WeakMap<Linkable, (prop: KeyLike) => void>;
+//#endregion
+export { TRACKER_REGISTRY };

package/dist/reactive.js

@@ -0,0 +1,51 @@
+import { createObserver, onGlobalCleanup, setCleanUpHandler, setTracker } from "@anchorlib/core";
+import { onDestroy } from "svelte";
+import { createSubscriber } from "svelte/reactivity";
+
+//#region src/reactive.ts
+const TRACKER_REGISTRY = /* @__PURE__ */ new WeakMap();
+let bindingInitialized = false;
+if (!bindingInitialized && typeof window !== "undefined") {
+	bindingInitialized = true;
+	/**
+	* Sets up a tracker function that integrates Anchor's reactivity system with Svelte's reactivity.
+	* This tracker is responsible for creating observers that watch for changes in reactive objects
+	* and properly subscribing/unsubscribing to Svelte's reactivity system.
+	*
+	* @param init - The initial linkable object to track
+	* @param observers - The observers collection to use for tracking
+	* @param key - The specific key/property to track on the object
+	*/
+	setTracker((init, observers, key) => {
+		if (!TRACKER_REGISTRY.has(init)) {
+			let track;
+			const subscribe$1 = createSubscriber((update) => {
+				const observer = createObserver(() => {
+					observer.reset();
+					update();
+				}, void 0, true);
+				track = observer.assign(init, observers);
+				return () => {
+					observer.destroy();
+					TRACKER_REGISTRY.delete(init);
+				};
+			});
+			const assign = (prop) => {
+				subscribe$1();
+				track?.(prop);
+			};
+			TRACKER_REGISTRY.set(init, assign);
+		}
+		TRACKER_REGISTRY.get(init)?.(key);
+	});
+	setCleanUpHandler((handler) => {
+		try {
+			return onDestroy(handler);
+		} catch (_error) {
+			return onGlobalCleanup(handler);
+		}
+	});
+}
+
+//#endregion
+export { TRACKER_REGISTRY };

package/dist/ref.d.ts

@@ -0,0 +1,52 @@
+import { ConstantRef, StateRef, VariableRef } from "./types.js";
+
+//#region src/ref.d.ts
+declare const REF_REGISTRY: WeakMap<ConstantRef<unknown>, StateRef<unknown>>;
+/**
+ * @deprecated Use 'mutable()' instead.
+ * Creates a readable reference that can be subscribed to for reactive updates.
+ * This function initializes a reactive reference with a given initial value and provides
+ * mechanisms for subscribing to changes and publishing updates to subscribers.
+ *
+ * @template T The type of the value being referenced
+ * @param init - The initial value for the reference
+ * @returns A readable reference object with subscribe and publish capabilities
+ */
+declare function variableRef<T>(init: T): VariableRef<T>;
+/**
+ * @deprecated Use 'mutable()' instead.
+ * Creates a constant (read-only) reference that can be subscribed to for reactive updates.
+ * This function initializes a reactive reference with a given initial value that cannot be modified
+ * after creation.
+ *
+ * @template T The type of the value being referenced
+ * @param init - The initial value for the reference
+ * @param constant - If true, the reference will be read-only and cannot be updated.
+ * @returns A constant reference object with subscribe capability but no write access
+ */
+declare function variableRef<T>(init: T, constant: true): ConstantRef<T>;
+/**
+ * @deprecated Use 'immutable()' instead.
+ * Creates a constant (read-only) reference that can be subscribed to for reactive updates.
+ * This function initializes a reactive reference with a given initial value that cannot be modified
+ * after creation. It's useful for values that should remain constant throughout the component lifecycle
+ * but still need to be reactively tracked.
+ *
+ * @template T The type of the value being referenced
+ * @param init - The initial value for the constant reference
+ * @returns A constant reference object with subscribe capability but no write access
+ */
+declare function constantRef<T>(init: T): ConstantRef<T>;
+/**
+ * @deprecated Use 'isValueRef()' instead.
+ * Checks if a given value is a writable reference.
+ * This function uses the REF_REGISTRY to determine if the provided value
+ * is a registered writable reference.
+ *
+ * @template T The type of the value that the reference holds
+ * @param ref - The value to check
+ * @returns True if the value is a writable reference, false otherwise
+ */
+declare function isRef<T>(ref: unknown): ref is VariableRef<T>;
+//#endregion
+export { REF_REGISTRY, constantRef, isRef, variableRef };

package/dist/ref.js

@@ -0,0 +1,67 @@
+import { anchor } from "@anchorlib/core";
+import { onDestroy } from "svelte";
+
+//#region src/ref.ts
+const REF_REGISTRY = /* @__PURE__ */ new WeakMap();
+/**
+* @deprecated Use 'mutable()' instead.
+* Creates a readable reference that can be subscribed to for reactive updates.
+* This function initializes a reactive reference with a given initial value and provides
+* mechanisms for subscribing to changes and publishing updates to subscribers.
+*
+* @template T The type of the value being referenced
+* @param init - The initial value for the reference
+* @param constant - If true, the reference will be read-only and cannot be updated.
+* @returns A readable reference object with subscribe and publish capabilities
+*/
+function variableRef(init, constant) {
+	const valueRef = anchor({ value: init }, { recursive: true });
+	const set = (value) => {
+		if (constant === true || value === valueRef.value) return;
+		valueRef.value = value;
+	};
+	onDestroy(() => {
+		REF_REGISTRY.delete(stateRef);
+		anchor.destroy(valueRef);
+	});
+	const stateRef = {
+		get value() {
+			return valueRef.value;
+		},
+		set value(value) {
+			set(value);
+		}
+	};
+	REF_REGISTRY.set(stateRef, valueRef);
+	return stateRef;
+}
+/**
+* @deprecated Use 'immutable()' instead.
+* Creates a constant (read-only) reference that can be subscribed to for reactive updates.
+* This function initializes a reactive reference with a given initial value that cannot be modified
+* after creation. It's useful for values that should remain constant throughout the component lifecycle
+* but still need to be reactively tracked.
+*
+* @template T The type of the value being referenced
+* @param init - The initial value for the constant reference
+* @returns A constant reference object with subscribe capability but no write access
+*/
+function constantRef(init) {
+	return variableRef(init, true);
+}
+/**
+* @deprecated Use 'isValueRef()' instead.
+* Checks if a given value is a writable reference.
+* This function uses the REF_REGISTRY to determine if the provided value
+* is a registered writable reference.
+*
+* @template T The type of the value that the reference holds
+* @param ref - The value to check
+* @returns True if the value is a writable reference, false otherwise
+*/
+function isRef(ref) {
+	return REF_REGISTRY.has(ref);
+}
+
+//#endregion
+export { REF_REGISTRY, constantRef, isRef, variableRef };

package/dist/storage/index.d.ts

@@ -1,61 +1,8 @@
-import { Storable, KVState, Rec, Row, RowState, FilterFn, RowListState, ReactiveTable, InferRec } from '@anchorlib/storage/db';
-import { C as ConstantRef } from '../types-CsfltB4A.js';
-import { ObjLike, LinkableSchema, StateOptions } from '@anchorlib/core';
-
-/**
- * Creates a reactive reference to a key-value store state.
- *
- * This function initializes a key-value store with the given name and initial value,
- * and automatically cleans up the store subscription when the component is destroyed.
- *
- * @template T - The type of the stored value, must extend Storable
- * @param name - The unique identifier for the key-value store
- * @param init - The initial value for the store
- * @returns A reactive reference to the key-value store state
- */
-declare function kvRef<T extends Storable>(name: string, init: T): ConstantRef<KVState<T>>;
-
-/**
- * Creates a persistent reactive reference using the provided name, initial value, and options.
- * The persistentRef is tied to the browser's local storage, meaning its value will persist
- * across page reloads and browser sessions until explicitly cleared.
- *
- * @template T - The type of the initial value, must extend object-like structure.
- * @template S - The schema type for linkable validation, defaults to LinkableSchema.
- * @param name - A unique string identifier for the local storage key.
- * @param init - The initial value to be stored in local storage.
- * @param options - Optional configuration for state behavior and validation schema.
- * @returns A WritableRef<T> that provides reactive access and modification capabilities.
- */
-declare function persistentRef<T extends ObjLike, S extends LinkableSchema = LinkableSchema>(name: string, init: T, options?: StateOptions<S>): ConstantRef<T>;
-
-/**
- * Creates a session-scoped reactive reference using the provided name, initial value, and options.
- * The sessionRef is tied to the browser's session storage, meaning its value will persist
- * across page reloads but not after the session ends (e.g., tab/window closed).
- *
- * @template T - The type of the initial value, must extend object-like structure.
- * @template S - The schema type for linkable validation, defaults to LinkableSchema.
- * @param name - A unique string identifier for the session storage key.
- * @param init - The initial value to be stored in session storage.
- * @param options - Optional configuration for state behavior and validation schema.
- * @returns A WritableRef<T> that provides reactive access and modification capabilities.
- */
-declare function sessionRef<T extends ObjLike, S extends LinkableSchema = LinkableSchema>(name: string, init: T, options?: StateOptions<S>): ConstantRef<T>;
-
-interface TableRef<T extends Rec, R extends Row<T> = Row<T>> {
-    get(id: string): ConstantRef<RowState<R>>;
-    add(payload: T): ConstantRef<RowState<R>>;
-    remove(id: string): ConstantRef<RowState<R>>;
-    list(filter?: IDBKeyRange | FilterFn<R>, limit?: number, direction?: IDBCursorDirection): ConstantRef<RowListState<R>>;
-    listByIndex(name: keyof R, filter?: IDBKeyRange | FilterFn<R>, limit?: number, direction?: IDBCursorDirection): ConstantRef<RowListState<R>>;
-    seed<T extends R[]>(seeds: T): this;
-    table(): ReactiveTable<T>;
-}
-type InferRef<T> = T extends TableRef<Rec, infer R> ? ConstantRef<R> : never;
-type InferListRef<T> = T extends TableRef<Rec, infer R> ? ConstantRef<R[]> : never;
-
-declare function createTableRef<T extends ReactiveTable<Rec>>(table: T): TableRef<InferRec<T>>;
-declare function createTableRef<T extends Rec, R extends Row<T> = Row<T>>(name: string, version?: number, indexes?: (keyof R)[], remIndexes?: (keyof R)[], dbName?: string): TableRef<T, R>;
-
-export { type InferListRef, type InferRef, type TableRef, createTableRef, kvRef, persistentRef, sessionRef };
+import { kvRef } from "./kv.js";
+import { persistentRef } from "./persistent.js";
+import { sessionRef } from "./session.js";
+import { InferListRef, InferRef, TableRef } from "./types.js";
+import { createTableRef } from "./table.js";
+export * from "@anchorlib/storage";
+export * from "@anchorlib/storage/db";
+export { InferListRef, InferRef, TableRef, createTableRef, kvRef, persistentRef, sessionRef };

package/dist/storage/index.js

@@ -1,66 +1,11 @@
-import { kv, createTable } from '@anchorlib/storage/db';
-import { constantRef } from '../index.js';
-import { onDestroy } from 'svelte';
-import { persistent, session } from '@anchorlib/storage';
+import "../reactive.js";
+import { kvRef } from "./kv.js";
+import { persistentRef } from "./persistent.js";
+import { sessionRef } from "./session.js";
+import { createTableRef } from "./table.js";
 
-// src/storage/kv.ts
-function kvRef(name, init) {
-  const state = kv(name, init);
-  onDestroy(() => {
-    kv.leave(state);
-  });
-  return constantRef(state);
-}
-function persistentRef(name, init, options) {
-  const state = persistent(name, init, options);
-  return constantRef(state);
-}
-function sessionRef(name, init, options) {
-  const state = session(name, init, options);
-  return constantRef(state);
-}
-function createTableRef(tableName, version = 1, indexes, remIndexes, dbName = tableName) {
-  if (typeof tableName === "string") {
-    tableName = createTable(tableName, version, indexes, remIndexes, dbName);
-  }
-  const tableRef = tableName;
-  return {
-    get(id) {
-      const state = tableRef.get(id);
-      onDestroy(() => {
-        tableRef.leave(id);
-      });
-      return constantRef(state);
-    },
-    add(payload) {
-      const state = tableRef.add(payload);
-      onDestroy(() => {
-        tableRef.leave(state.data.id);
-      });
-      return constantRef(state);
-    },
-    list(filter, limit, direction) {
-      const state = tableRef.list(filter, limit, direction);
-      return constantRef(state);
-    },
-    listByIndex(name, filter, limit, direction) {
-      const state = tableRef.listByIndex(name, filter, limit, direction);
-      return constantRef(state);
-    },
-    remove(id) {
-      const state = tableRef.remove(id);
-      return constantRef(state);
-    },
-    seed(seeds) {
-      tableRef.seed(seeds);
-      return this;
-    },
-    table() {
-      return tableRef;
-    }
-  };
-}
+export * from "@anchorlib/storage"
 
-export { createTableRef, kvRef, persistentRef, sessionRef };
-//# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map
+export * from "@anchorlib/storage/db"
+
+export { createTableRef, kvRef, persistentRef, sessionRef };

package/dist/storage/kv.d.ts

@@ -0,0 +1,19 @@
+import { KVState, Storable } from "@anchorlib/storage/db";
+
+//#region src/storage/kv.d.ts
+
+/**
+ * @deprecated Use `kv()` instead.
+ * Creates a reactive key-value store state.
+ *
+ * This function initializes a key-value store with the given name and initial value,
+ * and automatically cleans up the store subscription when the component is destroyed.
+ *
+ * @template T - The type of the stored value, must extend Storable
+ * @param name - The unique identifier for the key-value store
+ * @param init - The initial value for the store
+ * @returns A reactive key-value store state.
+ */
+declare function kvRef<T extends Storable>(name: string, init: T): KVState<T>;
+//#endregion
+export { kvRef };

package/dist/storage/kv.js

@@ -0,0 +1,26 @@
+import { onDestroy } from "svelte";
+import { kv } from "@anchorlib/storage/db";
+
+//#region src/storage/kv.ts
+/**
+* @deprecated Use `kv()` instead.
+* Creates a reactive key-value store state.
+*
+* This function initializes a key-value store with the given name and initial value,
+* and automatically cleans up the store subscription when the component is destroyed.
+*
+* @template T - The type of the stored value, must extend Storable
+* @param name - The unique identifier for the key-value store
+* @param init - The initial value for the store
+* @returns A reactive key-value store state.
+*/
+function kvRef(name, init) {
+	const state = kv(name, init);
+	onDestroy(() => {
+		kv.leave(state);
+	});
+	return state;
+}
+
+//#endregion
+export { kvRef };

package/dist/storage/persistent.d.ts

@@ -0,0 +1,20 @@
+import { LinkableSchema, ObjLike, StateOptions } from "@anchorlib/core";
+
+//#region src/storage/persistent.d.ts
+
+/**
+ * @deprecated Use `persistent()` instead.
+ * Creates a persistent reactive state using the provided name, initial value, and options.
+ * The persistentRef is tied to the browser's local storage, meaning its value will persist
+ * across page reloads and browser sessions until explicitly cleared.
+ *
+ * @template T - The type of the initial value, must extend object-like structure.
+ * @template S - The schema type for linkable validation, defaults to LinkableSchema.
+ * @param name - A unique string identifier for the local storage key.
+ * @param init - The initial value to be stored in local storage.
+ * @param options - Optional configuration for state behavior and validation schema.
+ * @returns A reactive state that provides reactive access and modification capabilities.
+ */
+declare function persistentRef<T extends ObjLike, S extends LinkableSchema = LinkableSchema>(name: string, init: T, options?: StateOptions<S>): T;
+//#endregion
+export { persistentRef };

package/dist/storage/persistent.js

@@ -0,0 +1,27 @@
+import { onDestroy } from "svelte";
+import { persistent } from "@anchorlib/storage";
+
+//#region src/storage/persistent.ts
+/**
+* @deprecated Use `persistent()` instead.
+* Creates a persistent reactive state using the provided name, initial value, and options.
+* The persistentRef is tied to the browser's local storage, meaning its value will persist
+* across page reloads and browser sessions until explicitly cleared.
+*
+* @template T - The type of the initial value, must extend object-like structure.
+* @template S - The schema type for linkable validation, defaults to LinkableSchema.
+* @param name - A unique string identifier for the local storage key.
+* @param init - The initial value to be stored in local storage.
+* @param options - Optional configuration for state behavior and validation schema.
+* @returns A reactive state that provides reactive access and modification capabilities.
+*/
+function persistentRef(name, init, options) {
+	const state = persistent(name, init, options);
+	onDestroy(() => {
+		persistent.leave(state);
+	});
+	return state;
+}
+
+//#endregion
+export { persistentRef };

package/dist/storage/session.d.ts

@@ -0,0 +1,20 @@
+import { LinkableSchema, ObjLike, StateOptions } from "@anchorlib/core";
+
+//#region src/storage/session.d.ts
+
+/**
+ * @deprecated Use `session()` instead.
+ * Creates a session-scoped reactive state using the provided name, initial value, and options.
+ * The sessionRef is tied to the browser's session storage, meaning its value will persist
+ * across page reloads but not after the session ends (e.g., tab/window closed).
+ *
+ * @template T - The type of the initial value, must extend object-like structure.
+ * @template S - The schema type for linkable validation, defaults to LinkableSchema.
+ * @param name - A unique string identifier for the session storage key.
+ * @param init - The initial value to be stored in session storage.
+ * @param options - Optional configuration for state behavior and validation schema.
+ * @returns A reactive state that provides reactive access and modification capabilities.
+ */
+declare function sessionRef<T extends ObjLike, S extends LinkableSchema = LinkableSchema>(name: string, init: T, options?: StateOptions<S>): T;
+//#endregion
+export { sessionRef };

package/dist/storage/session.js

@@ -0,0 +1,27 @@
+import { onDestroy } from "svelte";
+import { session } from "@anchorlib/storage";
+
+//#region src/storage/session.ts
+/**
+* @deprecated Use `session()` instead.
+* Creates a session-scoped reactive state using the provided name, initial value, and options.
+* The sessionRef is tied to the browser's session storage, meaning its value will persist
+* across page reloads but not after the session ends (e.g., tab/window closed).
+*
+* @template T - The type of the initial value, must extend object-like structure.
+* @template S - The schema type for linkable validation, defaults to LinkableSchema.
+* @param name - A unique string identifier for the session storage key.
+* @param init - The initial value to be stored in session storage.
+* @param options - Optional configuration for state behavior and validation schema.
+* @returns A reactive state that provides reactive access and modification capabilities.
+*/
+function sessionRef(name, init, options) {
+	const state = session(name, init, options);
+	onDestroy(() => {
+		session.leave(state);
+	});
+	return state;
+}
+
+//#endregion
+export { sessionRef };

package/dist/storage/table.d.ts

@@ -0,0 +1,15 @@
+import { TableRef } from "./types.js";
+import { InferRec, ReactiveTable, Rec, Row } from "@anchorlib/storage/db";
+
+//#region src/storage/table.d.ts
+
+/**
+ * @deprecated Use `createTable()` instead.
+ */
+declare function createTableRef<T extends ReactiveTable<Rec>>(table: T): TableRef<InferRec<T>>;
+/**
+ * @deprecated Use `createTable()` instead.
+ */
+declare function createTableRef<T extends Rec, R extends Row<T> = Row<T>>(name: string, version?: number, indexes?: (keyof R)[], remIndexes?: (keyof R)[], dbName?: string): TableRef<T, R>;
+//#endregion
+export { createTableRef };

package/dist/storage/table.js

@@ -0,0 +1,46 @@
+import { onDestroy } from "svelte";
+import { createTable } from "@anchorlib/storage/db";
+
+//#region src/storage/table.ts
+/**
+* @deprecated Use `createTable()` instead.
+*/
+function createTableRef(tableName, version = 1, indexes, remIndexes, dbName = tableName) {
+	if (typeof tableName === "string") tableName = createTable(tableName, version, indexes, remIndexes, dbName);
+	const tableRef = tableName;
+	return {
+		get(id) {
+			const state = tableRef.get(id);
+			onDestroy(() => {
+				tableRef.leave(id);
+			});
+			return state;
+		},
+		add(payload) {
+			const state = tableRef.add(payload);
+			onDestroy(() => {
+				tableRef.leave(state.data.id);
+			});
+			return state;
+		},
+		list(filter, limit, direction) {
+			return tableRef.list(filter, limit, direction);
+		},
+		listByIndex(name, filter, limit, direction) {
+			return tableRef.listByIndex(name, filter, limit, direction);
+		},
+		remove(id) {
+			return tableRef.remove(id);
+		},
+		seed(seeds) {
+			tableRef.seed(seeds);
+			return this;
+		},
+		table() {
+			return tableRef;
+		}
+	};
+}
+
+//#endregion
+export { createTableRef };

package/dist/storage/types.d.ts

@@ -0,0 +1,16 @@
+import { FilterFn, ReactiveTable, Rec, Row, RowListState, RowState } from "@anchorlib/storage/db";
+
+//#region src/storage/types.d.ts
+interface TableRef<T extends Rec, R$1 extends Row<T> = Row<T>> {
+  get(id: string): RowState<R$1>;
+  add(payload: T): RowState<R$1>;
+  remove(id: string): RowState<R$1>;
+  list(filter?: IDBKeyRange | FilterFn<R$1>, limit?: number, direction?: IDBCursorDirection): RowListState<R$1>;
+  listByIndex(name: keyof R$1, filter?: IDBKeyRange | FilterFn<R$1>, limit?: number, direction?: IDBCursorDirection): RowListState<R$1>;
+  seed<T extends R$1[]>(seeds: T): this;
+  table(): ReactiveTable<T>;
+}
+type InferRef<T> = T extends TableRef<Rec, infer R> ? R : never;
+type InferListRef<T> = T extends TableRef<Rec, infer R> ? R[] : never;
+//#endregion
+export { InferListRef, InferRef, TableRef };

package/dist/types.d.ts

@@ -0,0 +1,12 @@
+//#region src/types.d.ts
+type StateRef<T> = {
+  value: T;
+};
+type ConstantRef<T> = {
+  get value(): T;
+};
+type VariableRef<T> = ConstantRef<T> & {
+  set value(value: T);
+};
+//#endregion
+export { ConstantRef, StateRef, VariableRef };