@anchorlib/svelte 1.0.0-beta.17 → 1.0.0-beta.19

package/dist/reactive.js

@@ -1,46 +1,51 @@
-import { setTracker, createObserver, setCleanUpHandler, onGlobalCleanup } from '@anchorlib/core';
-import { onDestroy } from 'svelte';
-import { createSubscriber } from 'svelte/reactivity';
+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;
-  setTracker((init, observers, key) => {
-    if (!TRACKER_REGISTRY.has(init)) {
-      let track;
-      const subscribe = 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();
-        track?.(prop);
-      };
-      TRACKER_REGISTRY.set(init, assign);
-    }
-    TRACKER_REGISTRY.get(init)?.(key);
-  });
-  setCleanUpHandler((handler) => {
-    try {
-      return onDestroy(handler);
-    } catch (_error) {
-      return onGlobalCleanup(handler);
-    }
-  });
+	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);
+		}
+	});
 }
 
-export { TRACKER_REGISTRY };
-//# sourceMappingURL=reactive.js.map
-//# sourceMappingURL=reactive.js.map
+//#endregion
+export { TRACKER_REGISTRY };

package/dist/ref.d.ts

@@ -1,5 +1,6 @@
-import { ConstantRef, StateRef, VariableRef } from './types.js';
+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.
@@ -47,5 +48,5 @@ declare function constantRef<T>(init: T): ConstantRef<T>;
  * @returns True if the value is a writable reference, false otherwise
  */
 declare function isRef<T>(ref: unknown): ref is VariableRef<T>;
-
-export { REF_REGISTRY, constantRef, isRef, variableRef };
+//#endregion
+export { REF_REGISTRY, constantRef, isRef, variableRef };

package/dist/ref.js

@@ -1,35 +1,67 @@
-import { anchor } from '@anchorlib/core';
-import { onDestroy } from 'svelte';
+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;
+	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);
+	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);
+	return REF_REGISTRY.has(ref);
 }
 
-export { REF_REGISTRY, constantRef, isRef, variableRef };
-//# sourceMappingURL=ref.js.map
-//# sourceMappingURL=ref.js.map
+//#endregion
+export { REF_REGISTRY, constantRef, isRef, variableRef };

package/dist/storage/index.d.ts

@@ -1,8 +1,7 @@
-export * from '@anchorlib/storage';
-export { kvRef } from './kv.js';
-export { persistentRef } from './persistent.js';
-export { sessionRef } from './session.js';
-export { createTableRef } from './table.js';
-export { InferListRef, InferRef, TableRef } from './types.js';
-import '@anchorlib/storage/db';
-import '@anchorlib/core';
+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 { InferListRef, InferRef, TableRef, createTableRef, kvRef, persistentRef, sessionRef };

package/dist/storage/index.js

@@ -1,9 +1,9 @@
-import '../reactive.js';
-export * from '@anchorlib/storage';
-export * from './kv.js';
-export * from './persistent.js';
-export * from './session.js';
-export * from './table.js';
-export * from './types.js';
-//# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map
+import "../reactive.js";
+import { kvRef } from "./kv.js";
+import { persistentRef } from "./persistent.js";
+import { sessionRef } from "./session.js";
+import { createTableRef } from "./table.js";
+
+export * from "@anchorlib/storage"
+
+export { createTableRef, kvRef, persistentRef, sessionRef };

package/dist/storage/kv.d.ts

@@ -1,4 +1,6 @@
-import { Storable, KVState } from '@anchorlib/storage/db';
+import { KVState, Storable } from "@anchorlib/storage/db";
+
+//#region src/storage/kv.d.ts
 
 /**
  * @deprecated Use `kv()` instead.
@@ -13,5 +15,5 @@ import { Storable, KVState } from '@anchorlib/storage/db';
  * @returns A reactive key-value store state.
  */
 declare function kvRef<T extends Storable>(name: string, init: T): KVState<T>;
-
-export { kvRef };
+//#endregion
+export { kvRef };

package/dist/storage/kv.js

@@ -1,14 +1,26 @@
-import { kv } from '@anchorlib/storage/db';
-import { onDestroy } from 'svelte';
+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;
+	const state = kv(name, init);
+	onDestroy(() => {
+		kv.leave(state);
+	});
+	return state;
 }
 
-export { kvRef };
-//# sourceMappingURL=kv.js.map
-//# sourceMappingURL=kv.js.map
+//#endregion
+export { kvRef };

package/dist/storage/persistent.d.ts

@@ -1,4 +1,6 @@
-import { ObjLike, LinkableSchema, StateOptions } from '@anchorlib/core';
+import { LinkableSchema, ObjLike, StateOptions } from "@anchorlib/core";
+
+//#region src/storage/persistent.d.ts
 
 /**
  * @deprecated Use `persistent()` instead.
@@ -14,5 +16,5 @@ import { ObjLike, LinkableSchema, StateOptions } from '@anchorlib/core';
  * @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;
-
-export { persistentRef };
+//#endregion
+export { persistentRef };

package/dist/storage/persistent.js

@@ -1,14 +1,27 @@
-import { persistent } from '@anchorlib/storage';
-import { onDestroy } from 'svelte';
+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;
+	const state = persistent(name, init, options);
+	onDestroy(() => {
+		persistent.leave(state);
+	});
+	return state;
 }
 
-export { persistentRef };
-//# sourceMappingURL=persistent.js.map
-//# sourceMappingURL=persistent.js.map
+//#endregion
+export { persistentRef };

package/dist/storage/session.d.ts

@@ -1,4 +1,6 @@
-import { ObjLike, LinkableSchema, StateOptions } from '@anchorlib/core';
+import { LinkableSchema, ObjLike, StateOptions } from "@anchorlib/core";
+
+//#region src/storage/session.d.ts
 
 /**
  * @deprecated Use `session()` instead.
@@ -14,5 +16,5 @@ import { ObjLike, LinkableSchema, StateOptions } from '@anchorlib/core';
  * @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;
-
-export { sessionRef };
+//#endregion
+export { sessionRef };

package/dist/storage/session.js

@@ -1,14 +1,27 @@
-import { session } from '@anchorlib/storage';
-import { onDestroy } from 'svelte';
+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;
+	const state = session(name, init, options);
+	onDestroy(() => {
+		session.leave(state);
+	});
+	return state;
 }
 
-export { sessionRef };
-//# sourceMappingURL=session.js.map
-//# sourceMappingURL=session.js.map
+//#endregion
+export { sessionRef };

package/dist/storage/table.d.ts

@@ -1,5 +1,7 @@
-import { ReactiveTable, Rec, InferRec, Row } from '@anchorlib/storage/db';
-import { TableRef } from './types.js';
+import { TableRef } from "./types.js";
+import { InferRec, ReactiveTable, Rec, Row } from "@anchorlib/storage/db";
+
+//#region src/storage/table.d.ts
 
 /**
  * @deprecated Use `createTable()` instead.
@@ -9,5 +11,5 @@ declare function createTableRef<T extends ReactiveTable<Rec>>(table: T): TableRe
  * @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>;
-
-export { createTableRef };
+//#endregion
+export { createTableRef };

package/dist/storage/table.js

@@ -1,45 +1,46 @@
-import { createTable } from '@anchorlib/storage/db';
-import { onDestroy } from 'svelte';
+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;
-    }
-  };
+	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;
+		}
+	};
 }
 
-export { createTableRef };
-//# sourceMappingURL=table.js.map
-//# sourceMappingURL=table.js.map
+//#endregion
+export { createTableRef };

package/dist/storage/types.d.ts

@@ -1,15 +1,16 @@
-import { Rec, Row, RowState, FilterFn, RowListState, ReactiveTable } from '@anchorlib/storage/db';
+import { FilterFn, ReactiveTable, Rec, Row, RowListState, RowState } from "@anchorlib/storage/db";
 
-interface TableRef<T extends Rec, R extends Row<T> = Row<T>> {
-    get(id: string): RowState<R>;
-    add(payload: T): RowState<R>;
-    remove(id: string): RowState<R>;
-    list(filter?: IDBKeyRange | FilterFn<R>, limit?: number, direction?: IDBCursorDirection): RowListState<R>;
-    listByIndex(name: keyof R, filter?: IDBKeyRange | FilterFn<R>, limit?: number, direction?: IDBCursorDirection): RowListState<R>;
-    seed<T extends R[]>(seeds: T): this;
-    table(): ReactiveTable<T>;
+//#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;
-
-export type { InferListRef, InferRef, TableRef };
+//#endregion
+export { InferListRef, InferRef, TableRef };

package/dist/storage/types.js

@@ -1,3 +0,0 @@
-
-//# sourceMappingURL=types.js.map
-//# sourceMappingURL=types.js.map

package/dist/types.d.ts

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

package/dist/types.js

@@ -1,3 +0,0 @@
-
-//# sourceMappingURL=types.js.map
-//# sourceMappingURL=types.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anchorlib/svelte",
-  "version": "1.0.0-beta.17",
+  "version": "1.0.0-beta.19",
   "description": "Svelte bindings for Anchor reactive state management",
   "keywords": [
     "state",
@@ -55,8 +55,8 @@
     "access": "public"
   },
   "dependencies": {
-    "@anchorlib/core": "^1.0.0-beta.17",
-    "@anchorlib/storage": "^1.0.0-beta.17"
+    "@anchorlib/core": "^1.0.0-beta.19",
+    "@anchorlib/storage": "^1.0.0-beta.19"
   },
   "devDependencies": {
     "@biomejs/biome": "2.3.3",
@@ -69,7 +69,7 @@
     "jsdom": "27.0.1",
     "publint": "0.3.15",
     "rimraf": "6.0.1",
-    "tsup": "8.5.0",
+    "tsdown": "0.15.9",
     "vite": "7.1.12",
     "vitest": "^3.2.4"
   },
@@ -78,10 +78,10 @@
     "typescript": "^5.9.3"
   },
   "scripts": {
-    "dev": "rimraf dist && tsup --watch",
+    "dev": "rimraf dist && tsdown --watch",
     "clean": "rimraf dist",
-    "build": "rimraf dist && tsup && publint",
-    "prepublish": "rimraf dist && tsup && publint",
+    "build": "rimraf dist && tsdown && publint",
+    "prepublish": "rimraf dist && tsdown && publint",
     "format": "biome format --write",
     "test": "rimraf coverage && vitest --run",
     "test:preview": "rimraf coverage && vitest --run && vite preview --outDir coverage"

package/dist/anchor.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/anchor.ts"],"names":[],"mappings":";;AAwEO,SAAS,SAAA,CACd,IAAA,EACA,aAAA,EACA,OAAA,EACgD;AAChD,EAAA,OAAO,MAAA,CAAyB,IAAA,EAAuB,aAAA,EAAoB,OAAO,CAAA;AACpF;AAOO,MAAM,WAAA,GAAc;AAapB,SAAS,UAAA,CACd,IAAA,EACA,OAAA,EACA,OAAA,EACG;AACH,EAAA,OAAO,MAAA,CAAO,OAAA,CAAQ,IAAA,EAAM,OAAA,EAAS,OAAO,CAAA;AAC9C;AAYO,SAAS,OAAA,CAAgE,MAAS,OAAA,EAA8B;AACrH,EAAA,OAAO,MAAA,CAAO,IAAA,CAAK,IAAA,EAAM,OAAO,CAAA;AAClC;AAcO,SAAS,MAAA,CACd,MACA,OAAA,EACG;AACH,EAAA,OAAO,MAAA,CAAO,GAAA,CAAI,IAAA,EAAM,OAAO,CAAA;AACjC","file":"anchor.js","sourcesContent":["import {\n  anchor,\n  type Immutable,\n  type Linkable,\n  type LinkableSchema,\n  type ModelArray,\n  type ModelInput,\n  type ModelOutput,\n  type StateOptions,\n} from '@anchorlib/core';\n\n/**\n * @deprecated Use 'mutable()' instead.\n * Creates a reactive state that can be used to manage state with Anchor.\n * This overload is used when no schema is provided, or when using a LinkableSchema with StateOptions.\n *\n * @template T - The type of the initial value\n * @template S - The schema type, extending LinkableSchema\n * @param init - The initial value for the state\n * @param options - Optional state options for the state\n * @returns A reactive state containing the initial value\n */\nexport function anchorRef<T extends Linkable, S extends LinkableSchema = LinkableSchema>(\n  init: T,\n  options?: StateOptions<S>\n): T;\n\n/**\n * @deprecated Use 'mutable()' instead.\n * Creates a reactive state with a defined schema for validation and type inference.\n *\n * @template S - The schema type, extending LinkableSchema\n * @template T - The type of the initial value, must extend ModelInput of the schema\n * @param init - The initial value for the state\n * @param schema - The schema to validate and type the state\n * @param options - Optional state options for the state\n * @returns A reactive state containing the output model based on the schema\n */\nexport function anchorRef<S extends LinkableSchema, T extends ModelInput<S>>(\n  init: T,\n  schema?: S,\n  options?: StateOptions\n): ModelOutput<S>;\n\n/**\n * @deprecated Use 'mutable()' instead.\n * Creates an immutable reactive state with a defined schema.\n *\n * @template S - The schema type, extending LinkableSchema\n * @template T - The type of the initial value, must extend ModelInput of the schema\n * @param init - The initial value for the state\n * @param schema - The schema to validate and type the state\n * @param options - State options with immutable flag set to true\n * @returns A reactive state containing an immutable output model based on the schema\n */\nexport function anchorRef<S extends LinkableSchema, T extends ModelInput<S>>(\n  init: T,\n  schema?: S,\n  options?: StateOptions & { immutable: true }\n): Immutable<ModelOutput<S>>;\n\n/**\n * @deprecated Use 'mutable()' instead.\n * Creates a reactive state for state management with optional schema validation.\n *\n * @template T - The type of the initial value\n * @template S - The schema type or options\n * @param init - The initial value for the state\n * @param schemaOptions - Either a schema or state options\n * @param options - Additional state options when schema is provided\n * @returns A reactive state containing the managed state\n */\nexport function anchorRef<T extends Linkable, S extends LinkableSchema = LinkableSchema>(\n  init: T,\n  schemaOptions?: S | StateOptions,\n  options?: StateOptions\n): T | ModelOutput<S> | Immutable<ModelOutput<S>> {\n  return anchor<S, ModelInput<S>>(init as ModelInput<S>, schemaOptions as S, options);\n}\n\n/**\n * @deprecated Use 'mutable()' instead.\n * Reactive state alias for anchorRef.\n * @type {{<T, S=LinkableSchema extends LinkableSchema>(init: T, options?: StateOptions<S>): T, <S extends LinkableSchema, T extends ModelInput<S>>(init: T, schema?: S, options?: StateOptions): ModelOutput<S>, <S extends LinkableSchema, T extends ModelInput<S>>(init: T, schema?: S, options?: (StateOptions & {immutable: true})): Immutable<ModelOutput<S>>}}\n */\nexport const reactiveRef = anchorRef;\n\n/**\n * @deprecated Use 'ordered()' instead.\n * Creates a reactive state that maintains a sorted array state based on a comparison function.\n *\n * @template T - The type of elements in the array\n * @template S - The schema type for array elements, extending ModelArray\n * @param init - The initial array value for the state\n * @param compare - A function that defines the sort order of elements\n * @param options - Optional state options for the state\n * @returns A reactive state containing the sorted array\n */\nexport function orderedRef<T extends unknown[], S extends ModelArray = ModelArray>(\n  init: T,\n  compare: (a: T[number], b: T[number]) => number,\n  options?: StateOptions<S>\n): T {\n  return anchor.ordered(init, compare, options);\n}\n\n/**\n * @deprecated Use 'flat()' instead.\n * Creates a reactive state that maintains a flat array state.\n *\n * @template T - The type of elements in the array\n * @template S - The schema type for array elements, extending ModelArray\n * @param init - The initial array value for the state\n * @param options - Optional state options for the state\n * @returns A reactive state containing the flat array\n */\nexport function flatRef<T extends unknown[], S extends ModelArray = ModelArray>(init: T, options?: StateOptions<S>): T {\n  return anchor.flat(init, options);\n}\n\n/**\n * @deprecated Use 'raw()' instead.\n * Creates a reactive state that mutates the underlying object.\n *\n * Unless you set the global options to `cloned: true`, you don't want to use this.\n *\n * @template T - The type of the initial value\n * @template S - The schema type, extending LinkableSchema\n * @param init - The initial value for the state\n * @param options - Optional state options for the state\n * @returns A reactive state containing the raw value\n */\nexport function rawRef<T extends Linkable, S extends LinkableSchema = LinkableSchema>(\n  init: T,\n  options?: StateOptions<S>\n): T {\n  return anchor.raw(init, options);\n}"]}

package/dist/core/index.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js","sourcesContent":[]}

package/dist/derive.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/derive.ts"],"names":[],"mappings":";;;;AAeO,SAAS,UAAA,CAAiB,OAAU,MAAA,EAA2C;AACpF,EAAA,MAAM,WAAW,MAAA,CAAO,IAAI,EAAE,SAAA,EAAW,OAAO,CAAA;AAChD,EAAA,MAAM,QAAA,GAAW;AAAA,IACf,IAAI,KAAA,GAAQ;AACV,MAAA,OAAO,QAAA,CAAS,KAAA;AAAA,IAClB;AAAA,GACF;AACA,EAAA,YAAA,CAAa,GAAA,CAAI,UAAU,QAAQ,CAAA;AAEnC,EAAA,MAAM,WAAA,GAAc,SAAA,CAAU,KAAA,EAAO,CAAC,OAAA,KAAY;AAChD,IAAA,QAAA,CAAS,KAAA,GAAQ,OAAO,OAAO,CAAA;AAAA,EACjC,CAAC,CAAA;AAED,EAAA,SAAA,CAAU,MAAM;AACd,IAAA,MAAA,CAAO,QAAQ,QAAQ,CAAA;AACvB,IAAA,WAAA,EAAY;AACZ,IAAA,YAAA,CAAa,OAAO,QAAQ,CAAA;AAAA,EAC9B,CAAC,CAAA;AAED,EAAA,OAAO,QAAA;AACT","file":"derive.js","sourcesContent":["import { anchor, subscribe } from '@anchorlib/core';\nimport type { ConstantRef, StateRef } from './types.js';\nimport { onDestroy } from 'svelte';\nimport { REF_REGISTRY } from './ref.js';\n\n/**\n * @deprecated Use `derived()` instead.\n * Creates a derived state from a source state with an optional transformation.\n *\n * @template T - The type of the input state\n * @template R - The type of the transformed output\n * @param state - The source state\n * @param derive - A function that transforms the current state value\n * @returns A read-only reference containing the derived state value\n */\nexport function derivedRef<T, R>(state: T, derive: (current: T) => R): ConstantRef<R> {\n  const valueRef = anchor({}, { recursive: false }) as StateRef<R>;\n  const stateRef = {\n    get value() {\n      return valueRef.value;\n    },\n  };\n  REF_REGISTRY.set(stateRef, valueRef);\n\n  const unsubscribe = subscribe(state, (current) => {\n    valueRef.value = derive(current);\n  });\n\n  onDestroy(() => {\n    anchor.destroy(valueRef);\n    unsubscribe();\n    REF_REGISTRY.delete(stateRef);\n  });\n\n  return stateRef as ConstantRef<R>;\n}"]}