@anchorlib/svelte 1.0.0-beta.10

package/dist/index.d.ts

@@ -0,0 +1,305 @@
+import { Linkable, LinkableSchema, StateOptions, ModelInput, ModelOutput, Immutable, ModelArray, FetchOptions, FetchState, StreamOptions, State, HistoryOptions, HistoryState, StateBaseOptions, ImmutableOutput, Mutable, MutationKey, MutablePart, ObjLike, StateExceptionMap, KeyLike } from '@anchorlib/core';
+
+/**
+ * Creates a reactive state that can be used to manage state with Anchor.
+ * This overload is used when no schema is provided, or when using a LinkableSchema with StateOptions.
+ *
+ * @template T - The type of the initial value
+ * @template S - The schema type, extending LinkableSchema
+ * @param init - The initial value for the state
+ * @param options - Optional state options for the state
+ * @returns A reactive state containing the initial value
+ */
+declare function anchorRef<T extends Linkable, S extends LinkableSchema = LinkableSchema>(init: T, options?: StateOptions<S>): T;
+/**
+ * Creates a reactive state with a defined schema for validation and type inference.
+ *
+ * @template S - The schema type, extending LinkableSchema
+ * @template T - The type of the initial value, must extend ModelInput of the schema
+ * @param init - The initial value for the state
+ * @param schema - The schema to validate and type the state
+ * @param options - Optional state options for the state
+ * @returns A reactive state containing the output model based on the schema
+ */
+declare function anchorRef<S extends LinkableSchema, T extends ModelInput<S>>(init: T, schema?: S, options?: StateOptions): ModelOutput<S>;
+/**
+ * Creates an immutable reactive state with a defined schema.
+ *
+ * @template S - The schema type, extending LinkableSchema
+ * @template T - The type of the initial value, must extend ModelInput of the schema
+ * @param init - The initial value for the state
+ * @param schema - The schema to validate and type the state
+ * @param options - State options with immutable flag set to true
+ * @returns A reactive state containing an immutable output model based on the schema
+ */
+declare function anchorRef<S extends LinkableSchema, T extends ModelInput<S>>(init: T, schema?: S, options?: StateOptions & {
+    immutable: true;
+}): Immutable<ModelOutput<S>>;
+/**
+ * Reactive state alias for anchorRef.
+ * @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>>}}
+ */
+declare const reactiveRef: typeof anchorRef;
+/**
+ * Creates a reactive state that maintains a sorted array state based on a comparison function.
+ *
+ * @template T - The type of elements in the array
+ * @template S - The schema type for array elements, extending ModelArray
+ * @param init - The initial array value for the state
+ * @param compare - A function that defines the sort order of elements
+ * @param options - Optional state options for the state
+ * @returns A reactive state containing the sorted array
+ */
+declare function orderedRef<T extends unknown[], S extends ModelArray = ModelArray>(init: T, compare: (a: T[number], b: T[number]) => number, options?: StateOptions<S>): T;
+/**
+ * Creates a reactive state that maintains a flat array state.
+ *
+ * @template T - The type of elements in the array
+ * @template S - The schema type for array elements, extending ModelArray
+ * @param init - The initial array value for the state
+ * @param options - Optional state options for the state
+ * @returns A reactive state containing the flat array
+ */
+declare function flatRef<T extends unknown[], S extends ModelArray = ModelArray>(init: T, options?: StateOptions<S>): T;
+/**
+ * Creates a reactive state that mutates the underlying object.
+ *
+ * Unless you set the global options to `cloned: true`, you don't want to use this.
+ *
+ * @template T - The type of the initial value
+ * @template S - The schema type, extending LinkableSchema
+ * @param init - The initial value for the state
+ * @param options - Optional state options for the state
+ * @returns A reactive state containing the raw value
+ */
+declare function rawRef<T extends Linkable, S extends LinkableSchema = LinkableSchema>(init: T, options?: StateOptions<S>): T;
+
+type StateRef<T> = {
+    value: T;
+};
+type ConstantRef<T> = {
+    get value(): T;
+};
+type VariableRef<T> = ConstantRef<T> & {
+    set value(value: T);
+};
+
+/**
+ * Creates a derived state from a source state with an optional transformation.
+ *
+ * @template T - The type of the input state
+ * @template R - The type of the transformed output
+ * @param state - The source state
+ * @param derive - A function that transforms the current state value
+ * @returns A read-only reference containing the derived state value
+ */
+declare function derivedRef<T, R>(state: T, derive: (current: T) => R): ConstantRef<R>;
+
+/**
+ * Creates a reactive state that manages the state of a fetch request.
+ * This overload is for GET or DELETE requests, which typically do not have a request body.
+ *
+ * @template R The type of the data expected in the response.
+ * @param init The initial value for the fetch state.
+ * @param options The options for the fetch request, including the URL and method.
+ * @returns A `FetchState` object representing the state of the request.
+ */
+declare function fetchRef<R>(init: R, options: FetchOptions & {
+    method: 'GET' | 'DELETE';
+}): FetchState<R>;
+/**
+ * Creates a readable Svelte store that manages the state of a fetch request.
+ * This overload is for POST, PUT, or PATCH requests, which typically include a request body.
+ *
+ * @template R The type of the data expected in the response.
+ * @template P The type of the request body.
+ * @param init The initial value for the fetch state.
+ * @param options The options for the fetch request, including the URL, method, and body.
+ * @returns A `FetchState` object representing the state of the request.
+ */
+declare function fetchRef<R, P>(init: R, options: FetchOptions & {
+    method: 'POST' | 'PUT' | 'PATCH';
+    body: P;
+}): FetchState<R>;
+/**
+ * Creates a reactive state that manages the state of a streaming request.
+ * This overload is for GET or DELETE requests, which typically do not have a request body.
+ *
+ * @template R The type of the data expected in the response.
+ * @param init The initial value for the fetch state.
+ * @param options The options for the stream request, including the URL and method.
+ * @returns A `FetchState` object representing the state of the request.
+ */
+declare function streamRef<R>(init: R, options: StreamOptions<R> & {
+    method: 'GET' | 'DELETE';
+}): FetchState<R>;
+/**
+ * Creates a reactive state that manages the state of a streaming request.
+ * This overload is for POST, PUT, or PATCH requests, which typically include a request body.
+ *
+ * @template R The type of the data expected in the response.
+ * @template P The type of the request body.
+ * @param init The initial value for the fetch state.
+ * @param options The options for the stream request, including the URL, method, and body.
+ * @returns A `FetchState` object representing the state of the request.
+ */
+declare function streamRef<R, P>(init: R, options: StreamOptions<R> & {
+    method: 'POST' | 'PUT' | 'PATCH';
+    body: P;
+}): FetchState<R>;
+
+/**
+ * Creates a reactive state that reflects the history state of a given Anchor state.
+ * @param state The initial Anchor state.
+ * @param options Optional history options.
+ * @returns A `HistoryState` object representing the state of the history.
+ */
+declare function historyRef<T extends State>(state: T, options?: HistoryOptions): HistoryState;
+
+/**
+ * Creates an immutable state from a state object.
+ *
+ * @template T The type of the state object.
+ * @template S The type of the linkable schema.
+ * @param init The initial state object.
+ * @param options Optional state options.
+ * @returns An immutable state.
+ */
+declare function immutableRef<T extends State, S extends LinkableSchema = LinkableSchema>(init: T, options?: StateOptions<S>): Immutable<T>;
+/**
+ * Creates an immutable state from a model input and a schema.
+ *
+ * @template S The type of the linkable schema.
+ * @template T The type of the model input.
+ * @param init The initial model input.
+ * @param schema The linkable schema.
+ * @param options Optional base state options.
+ * @returns An immutable state.
+ */
+declare function immutableRef<S extends LinkableSchema, T extends ModelInput<S>>(init: T, schema: S, options?: StateBaseOptions): ImmutableOutput<S>;
+/**
+ * Creates a writable state from a state object.
+ *
+ * @template T The type of the state object.
+ * @param state The initial state object.
+ * @returns A mutable state.
+ */
+declare function writableRef<T extends State>(state: T): Mutable<T>;
+/**
+ * Creates a writable state from a state object and a list of contracts.
+ *
+ * @template T The type of the state object.
+ * @template K The type of the mutation keys.
+ * @param state The initial state object.
+ * @param contracts A list of mutation keys.
+ * @returns A mutable part of the state.
+ */
+declare function writableRef<T extends State, K extends MutationKey<T>[]>(state: T, contracts: K): MutablePart<T, K>;
+
+/**
+ * Creates a model with mutable state.
+ *
+ * @template S - The linkable schema type
+ * @template T - The model input type that extends the schema
+ * @param schema - The schema to use for the model
+ * @param init - The initial value for the model
+ * @param options - Optional state configuration
+ * @returns A model output.
+ */
+declare function modelRef<S extends LinkableSchema, T extends ModelInput<S>>(schema: S, init: T, options?: StateBaseOptions): ModelOutput<S>;
+/**
+ * Creates a model with immutable state.
+ *
+ * @template S - The linkable schema type
+ * @template T - The model input type that extends the schema
+ * @param schema - The schema to use for the model
+ * @param init - The initial value for the model
+ * @param options - State configuration with immutable flag set to true
+ * @returns An immutable model output.
+ */
+declare function modelRef<S extends LinkableSchema, T extends ModelInput<S>>(schema: S, init: T, options: StateBaseOptions & {
+    immutable: true;
+}): ImmutableOutput<S>;
+/**
+ * Creates a state that maps exceptions for a given state object or array.
+ *
+ * @template T - The type of the input state, must be an object-like or array type
+ * @param state - The input state object or array to create exception mappings for
+ * @returns A StateExceptionMap for the provided state.
+ */
+declare function exceptionRef<T extends ObjLike | Array<unknown>>(state: T): StateExceptionMap<T>;
+
+type Props = {
+    [key: string]: KeyLike | State;
+};
+type PropsRef<T extends Props> = {
+    [K in keyof T]: T[K] extends State ? ConstantRef<T[K]> : T[K];
+};
+/**
+ * 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
+ */
+declare function propsRef<T extends Props>(props: T): T;
+
+/**
+ * Creates a read-only reference that observes a reactive function and updates its value
+ * when the observed value changes. The function automatically handles observer lifecycle
+ * and cleanup using Svelte's onDestroy hook.
+ *
+ * @template R - The type of the observed value
+ * @param observe - A function that returns the value to be observed
+ * @returns A read-only reference containing the observed value
+ */
+declare function observedRef<R>(observe: () => R): ConstantRef<R>;
+
+declare const REF_REGISTRY: WeakMap<ConstantRef<unknown>, StateRef<unknown>>;
+/**
+ * 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>;
+/**
+ * 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>;
+/**
+ * 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>;
+/**
+ * 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>;
+
+export { type ConstantRef, type Props, type PropsRef, REF_REGISTRY, type StateRef, type VariableRef, anchorRef, constantRef, derivedRef, exceptionRef, fetchRef, flatRef, historyRef, immutableRef, isRef, modelRef, observedRef, orderedRef, propsRef, rawRef, reactiveRef, streamRef, variableRef, writableRef };

package/dist/index.js

@@ -0,0 +1,140 @@
+import { setTracker, createObserver, anchor, subscribe, fetchState, streamState, history } from '@anchorlib/core';
+import { createSubscriber } from 'svelte/reactivity';
+import { onDestroy } from 'svelte';
+
+// src/reactive.ts
+var TRACKER_REGISTRY = /* @__PURE__ */ new WeakMap();
+var bindingInitialized = false;
+if (!bindingInitialized && typeof window !== "undefined") {
+  bindingInitialized = true;
+  setTracker((init, observers, key) => {
+    if (!TRACKER_REGISTRY.has(init)) {
+      let track = void 0;
+      const subscribe2 = createSubscriber((update) => {
+        const observer = createObserver(() => {
+          update();
+        });
+        track = observer.assign(init, observers);
+        return () => {
+          observer.destroy();
+          TRACKER_REGISTRY.delete(init);
+        };
+      });
+      const assign = (prop) => {
+        subscribe2();
+        track?.(prop);
+      };
+      TRACKER_REGISTRY.set(init, assign);
+    }
+    TRACKER_REGISTRY.get(init)?.(key);
+  });
+}
+function anchorRef(init, schemaOptions, options) {
+  return anchor(init, schemaOptions, options);
+}
+var reactiveRef = anchorRef;
+function orderedRef(init, compare, options) {
+  return anchor.ordered(init, compare, options);
+}
+function flatRef(init, options) {
+  return anchor.flat(init, options);
+}
+function rawRef(init, options) {
+  return anchor.raw(init, options);
+}
+var REF_REGISTRY = /* @__PURE__ */ new WeakMap();
+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;
+}
+function constantRef(init) {
+  return variableRef(init, true);
+}
+function isRef(ref) {
+  return REF_REGISTRY.has(ref);
+}
+
+// src/derive.ts
+function derivedRef(state, derive) {
+  const valueRef = anchor({}, { recursive: false });
+  const stateRef = {
+    get value() {
+      return valueRef.value;
+    }
+  };
+  REF_REGISTRY.set(stateRef, valueRef);
+  const unsubscribe = subscribe(state, (current) => {
+    valueRef.value = derive(current);
+  });
+  onDestroy(() => {
+    anchor.destroy(valueRef);
+    unsubscribe();
+    REF_REGISTRY.delete(stateRef);
+  });
+  return stateRef;
+}
+function fetchRef(init, options) {
+  return fetchState(init, options);
+}
+function streamRef(init, options) {
+  return streamState(init, options);
+}
+function historyRef(state, options) {
+  return history(state, options);
+}
+function immutableRef(init, schemaOptions, options) {
+  return anchor.immutable(init, schemaOptions, options);
+}
+function writableRef(state, contracts) {
+  return anchor.writable(state, contracts);
+}
+function modelRef(schema, init, options) {
+  return anchor(init, schema, options);
+}
+function exceptionRef(state) {
+  return anchor.catch(state);
+}
+function propsRef(props) {
+  return props;
+}
+function observedRef(observe) {
+  const observer = createObserver(() => {
+    update();
+  });
+  const valueRef = anchor({ value: observer.run(observe) }, { recursive: false });
+  const stateRef = {
+    get value() {
+      return valueRef.value;
+    }
+  };
+  REF_REGISTRY.set(stateRef, valueRef);
+  const update = () => {
+    valueRef.value = observer.run(observe);
+  };
+  onDestroy(() => {
+    observer.destroy();
+    REF_REGISTRY.delete(stateRef);
+  });
+  return stateRef;
+}
+
+export { REF_REGISTRY, anchorRef, constantRef, derivedRef, exceptionRef, fetchRef, flatRef, historyRef, immutableRef, isRef, modelRef, observedRef, orderedRef, propsRef, rawRef, reactiveRef, streamRef, variableRef, writableRef };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/reactive.ts","../src/anchor.ts","../src/ref.ts","../src/derive.ts","../src/fetch.ts","../src/history.ts","../src/immutable.ts","../src/model.ts","../src/prop.ts","../src/observable.ts"],"names":["subscribe","anchor","onDestroy","createObserver"],"mappings":"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","file":"index.js","sourcesContent":["import { createObserver, type KeyLike, type Linkable, setTracker } from '@anchorlib/core';\nimport { createSubscriber } from 'svelte/reactivity';\n\nexport const TRACKER_REGISTRY = new WeakMap<Linkable, (prop: KeyLike) => void>();\n\nlet bindingInitialized = false;\n\nif (!bindingInitialized && typeof window !== 'undefined') {\n  bindingInitialized = true;\n\n  /**\n   * Sets up a tracker function that integrates Anchor's reactivity system with Svelte's reactivity.\n   * This tracker is responsible for creating observers that watch for changes in reactive objects\n   * and properly subscribing/unsubscribing to Svelte's reactivity system.\n   *\n   * @param init - The initial linkable object to track\n   * @param observers - The observers collection to use for tracking\n   * @param key - The specific key/property to track on the object\n   */\n  setTracker((init, observers, key) => {\n    // Only initialize the tracking setup once per object\n    if (!TRACKER_REGISTRY.has(init)) {\n      let track: ((prop: KeyLike) => void) | undefined = undefined;\n\n      // Create a Svelte subscriber that manages the lifecycle of our observer\n      const subscribe = createSubscriber((update) => {\n        // Create an Anchor observer that will trigger the Svelte update when changes occur\n        const observer = createObserver(() => {\n          update();\n        });\n\n        // Assign the observer to track changes on the init object and its observers\n        track = observer.assign(init, observers);\n\n        // Return cleanup function to destroy observer and remove from registry\n        return () => {\n          observer.destroy();\n          TRACKER_REGISTRY.delete(init);\n        };\n      });\n\n      // Function to assign tracking to a specific key/property\n      const assign = (prop: KeyLike) => {\n        // Activate the subscription\n        subscribe();\n        // Track the specific property\n        track?.(prop);\n      };\n\n      // Store the assign function in the registry for this object\n      TRACKER_REGISTRY.set(init, assign);\n    }\n\n    // Execute the tracking function for the specific key\n    TRACKER_REGISTRY.get(init)?.(key);\n  });\n}\n","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 * 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 * 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 * 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 * 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 * 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 * 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 * 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 * 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}\n","import type { ConstantRef, StateRef, VariableRef } from './types.js';\nimport { anchor } from '@anchorlib/core';\nimport { onDestroy } from 'svelte';\n\nexport const REF_REGISTRY = new WeakMap<ConstantRef<unknown>, StateRef<unknown>>();\n\n/**\n * Creates a readable reference that can be subscribed to for reactive updates.\n * This function initializes a reactive reference with a given initial value and provides\n * mechanisms for subscribing to changes and publishing updates to subscribers.\n *\n * @template T The type of the value being referenced\n * @param init - The initial value for the reference\n * @returns A readable reference object with subscribe and publish capabilities\n */\nexport function variableRef<T>(init: T): VariableRef<T>;\n\n/**\n * Creates a constant (read-only) reference that can be subscribed to for reactive updates.\n * This function initializes a reactive reference with a given initial value that cannot be modified\n * after creation.\n *\n * @template T The type of the value being referenced\n * @param init - The initial value for the reference\n * @param constant - If true, the reference will be read-only and cannot be updated.\n * @returns A constant reference object with subscribe capability but no write access\n */\nexport function variableRef<T>(init: T, constant: true): ConstantRef<T>;\n\n/**\n * Creates a readable reference that can be subscribed to for reactive updates.\n * This function initializes a reactive reference with a given initial value and provides\n * mechanisms for subscribing to changes and publishing updates to subscribers.\n *\n * @template T The type of the value being referenced\n * @param init - The initial value for the reference\n * @param constant - If true, the reference will be read-only and cannot be updated.\n * @returns A readable reference object with subscribe and publish capabilities\n */\nexport function variableRef<T>(init: T, constant?: boolean) {\n  const valueRef = anchor({ value: init }, { recursive: true });\n\n  const set = (value: T) => {\n    // Ignore if the value is the same.\n    if (constant === true || value === valueRef.value) return;\n\n    valueRef.value = value;\n  };\n\n  onDestroy(() => {\n    // Remove the ref from the registry.\n    REF_REGISTRY.delete(stateRef as ConstantRef<unknown>);\n\n    // Destroy the ref state.\n    anchor.destroy(valueRef);\n  });\n\n  const stateRef = {\n    get value() {\n      return valueRef.value;\n    },\n    set value(value: T) {\n      set(value);\n    },\n  } as never;\n\n  REF_REGISTRY.set(stateRef as ConstantRef<unknown>, valueRef);\n\n  return stateRef as ConstantRef<T>;\n}\n\n/**\n * Creates a constant (read-only) reference that can be subscribed to for reactive updates.\n * This function initializes a reactive reference with a given initial value that cannot be modified\n * after creation. It's useful for values that should remain constant throughout the component lifecycle\n * but still need to be reactively tracked.\n *\n * @template T The type of the value being referenced\n * @param init - The initial value for the constant reference\n * @returns A constant reference object with subscribe capability but no write access\n */\nexport function constantRef<T>(init: T): ConstantRef<T> {\n  return variableRef(init, true);\n}\n\n/**\n * Checks if a given value is a writable reference.\n * This function uses the REF_REGISTRY to determine if the provided value\n * is a registered writable reference.\n *\n * @template T The type of the value that the reference holds\n * @param ref - The value to check\n * @returns True if the value is a writable reference, false otherwise\n */\nexport function isRef<T>(ref: unknown): ref is VariableRef<T> {\n  return REF_REGISTRY.has(ref as VariableRef<unknown>);\n}\n","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 * 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}\n","import { type FetchOptions, fetchState, type FetchState, type StreamOptions, streamState } from '@anchorlib/core';\n\n/**\n * Creates a reactive state that manages the state of a fetch request.\n * This overload is for GET or DELETE requests, which typically do not have a request body.\n *\n * @template R The type of the data expected in the response.\n * @param init The initial value for the fetch state.\n * @param options The options for the fetch request, including the URL and method.\n * @returns A `FetchState` object representing the state of the request.\n */\nexport function fetchRef<R>(init: R, options: FetchOptions & { method: 'GET' | 'DELETE' }): FetchState<R>;\n\n/**\n * Creates a readable Svelte store that manages the state of a fetch request.\n * This overload is for POST, PUT, or PATCH requests, which typically include a request body.\n *\n * @template R The type of the data expected in the response.\n * @template P The type of the request body.\n * @param init The initial value for the fetch state.\n * @param options The options for the fetch request, including the URL, method, and body.\n * @returns A `FetchState` object representing the state of the request.\n */\nexport function fetchRef<R, P>(\n  init: R,\n  options: FetchOptions & { method: 'POST' | 'PUT' | 'PATCH'; body: P }\n): FetchState<R>;\n\nexport function fetchRef<R>(init: R, options: FetchOptions): FetchState<R> {\n  return fetchState(init, options);\n}\n\n/**\n * Creates a reactive state that manages the state of a streaming request.\n * This overload is for GET or DELETE requests, which typically do not have a request body.\n *\n * @template R The type of the data expected in the response.\n * @param init The initial value for the fetch state.\n * @param options The options for the stream request, including the URL and method.\n * @returns A `FetchState` object representing the state of the request.\n */\nexport function streamRef<R>(init: R, options: StreamOptions<R> & { method: 'GET' | 'DELETE' }): FetchState<R>;\n\n/**\n * Creates a reactive state that manages the state of a streaming request.\n * This overload is for POST, PUT, or PATCH requests, which typically include a request body.\n *\n * @template R The type of the data expected in the response.\n * @template P The type of the request body.\n * @param init The initial value for the fetch state.\n * @param options The options for the stream request, including the URL, method, and body.\n * @returns A `FetchState` object representing the state of the request.\n */\nexport function streamRef<R, P>(\n  init: R,\n  options: StreamOptions<R> & { method: 'POST' | 'PUT' | 'PATCH'; body: P }\n): FetchState<R>;\n\nexport function streamRef<R>(init: R, options: StreamOptions<R>): FetchState<R> {\n  return streamState(init, options);\n}\n","import type { HistoryOptions, HistoryState, State } from '@anchorlib/core';\nimport { history } from '@anchorlib/core';\n\n/**\n * Creates a reactive state that reflects the history state of a given Anchor state.\n * @param state The initial Anchor state.\n * @param options Optional history options.\n * @returns A `HistoryState` object representing the state of the history.\n */\nexport function historyRef<T extends State>(state: T, options?: HistoryOptions): HistoryState {\n  return history(state, options);\n}\n","import {\n  anchor,\n  type Immutable,\n  type ImmutableOutput,\n  type LinkableSchema,\n  type ModelInput,\n  type Mutable,\n  type MutablePart,\n  type MutationKey,\n  type State,\n  type StateBaseOptions,\n  type StateOptions,\n} from '@anchorlib/core';\n\n/**\n * Creates an immutable state from a state object.\n *\n * @template T The type of the state object.\n * @template S The type of the linkable schema.\n * @param init The initial state object.\n * @param options Optional state options.\n * @returns An immutable state.\n */\nexport function immutableRef<T extends State, S extends LinkableSchema = LinkableSchema>(\n  init: T,\n  options?: StateOptions<S>\n): Immutable<T>;\n\n/**\n * Creates an immutable state from a model input and a schema.\n *\n * @template S The type of the linkable schema.\n * @template T The type of the model input.\n * @param init The initial model input.\n * @param schema The linkable schema.\n * @param options Optional base state options.\n * @returns An immutable state.\n */\nexport function immutableRef<S extends LinkableSchema, T extends ModelInput<S>>(\n  init: T,\n  schema: S,\n  options?: StateBaseOptions\n): ImmutableOutput<S>;\n\n/** Implementation of `immutableRef` overloads. */\nexport function immutableRef<T extends State, S extends LinkableSchema = LinkableSchema>(\n  init: T,\n  schemaOptions?: S | StateOptions,\n  options?: StateOptions<S>\n): Immutable<T> {\n  return anchor.immutable(init as never, schemaOptions as never, options);\n}\n\n/**\n * Creates a writable state from a state object.\n *\n * @template T The type of the state object.\n * @param state The initial state object.\n * @returns A mutable state.\n */\nexport function writableRef<T extends State>(state: T): Mutable<T>;\n\n/**\n * Creates a writable state from a state object and a list of contracts.\n *\n * @template T The type of the state object.\n * @template K The type of the mutation keys.\n * @param state The initial state object.\n * @param contracts A list of mutation keys.\n * @returns A mutable part of the state.\n */\nexport function writableRef<T extends State, K extends MutationKey<T>[]>(state: T, contracts: K): MutablePart<T, K>;\n\n/** Implementation of `writableRef` overloads. */\nexport function writableRef<T extends State, K extends MutationKey<T>[]>(state: T, contracts?: K): T {\n  return anchor.writable(state, contracts) as T;\n}\n","import {\n  anchor,\n  type ImmutableOutput,\n  type LinkableSchema,\n  type ModelInput,\n  type ModelOutput,\n  type ObjLike,\n  type StateBaseOptions,\n  type StateExceptionMap,\n} from '@anchorlib/core';\n\n/**\n * Creates a model with mutable state.\n *\n * @template S - The linkable schema type\n * @template T - The model input type that extends the schema\n * @param schema - The schema to use for the model\n * @param init - The initial value for the model\n * @param options - Optional state configuration\n * @returns A model output.\n */\nexport function modelRef<S extends LinkableSchema, T extends ModelInput<S>>(\n  schema: S,\n  init: T,\n  options?: StateBaseOptions\n): ModelOutput<S>;\n\n/**\n * Creates a model with immutable state.\n *\n * @template S - The linkable schema type\n * @template T - The model input type that extends the schema\n * @param schema - The schema to use for the model\n * @param init - The initial value for the model\n * @param options - State configuration with immutable flag set to true\n * @returns An immutable model output.\n */\nexport function modelRef<S extends LinkableSchema, T extends ModelInput<S>>(\n  schema: S,\n  init: T,\n  options: StateBaseOptions & { immutable: true }\n): ImmutableOutput<S>;\n\nexport function modelRef<S extends LinkableSchema, T extends ModelInput<S>>(\n  schema: S,\n  init: T,\n  options?: StateBaseOptions\n) {\n  return anchor(init, schema, options);\n}\n\n/**\n * Creates a state that maps exceptions for a given state object or array.\n *\n * @template T - The type of the input state, must be an object-like or array type\n * @param state - The input state object or array to create exception mappings for\n * @returns A StateExceptionMap for the provided state.\n */\nexport function exceptionRef<T extends ObjLike | Array<unknown>>(state: T): StateExceptionMap<T> {\n  return anchor.catch(state);\n}\n","import { type KeyLike, type State } from '@anchorlib/core';\nimport type { ConstantRef } from './types.js';\n\nexport type Props = {\n  [key: string]: KeyLike | State;\n};\n\nexport type PropsRef<T extends Props> = {\n  [K in keyof T]: T[K] extends State ? ConstantRef<T[K]> : T[K];\n};\n\n/**\n * Creates a reactive state object from the provided props.\n * For each property in the input props:\n * - If the value is a State object, it will be converted to a derived state\n * - Otherwise, the value will be kept as is\n * @deprecated\n * @template T - The type of props extending Props\n * @param {T} props - The input props object containing KeyLike or State values\n * @returns {PropsRef<T>} A new object with State values converted to reactive states\n */\nexport function propsRef<T extends Props>(props: T): T {\n  return props as never;\n}\n","import { anchor, createObserver } from '@anchorlib/core';\nimport type { ConstantRef, StateRef } from './types.js';\nimport { onDestroy } from 'svelte';\nimport { REF_REGISTRY } from './ref.js';\n\n/**\n * Creates a read-only reference that observes a reactive function and updates its value\n * when the observed value changes. The function automatically handles observer lifecycle\n * and cleanup using Svelte's onDestroy hook.\n *\n * @template R - The type of the observed value\n * @param observe - A function that returns the value to be observed\n * @returns A read-only reference containing the observed value\n */\nexport function observedRef<R>(observe: () => R): ConstantRef<R> {\n  const observer = createObserver(() => {\n    update();\n  });\n\n  const valueRef = anchor({ value: observer.run(observe) }, { recursive: false }) as StateRef<R>;\n  const stateRef = {\n    get value() {\n      return valueRef.value;\n    },\n  } as ConstantRef<R>;\n\n  REF_REGISTRY.set(stateRef, valueRef);\n\n  const update = () => {\n    valueRef.value = observer.run(observe);\n  };\n\n  onDestroy(() => {\n    observer.destroy();\n    REF_REGISTRY.delete(stateRef);\n  });\n\n  return stateRef;\n}\n"]}

package/dist/reactive.d.ts

@@ -0,0 +1,5 @@
+import { Linkable, KeyLike } from '@anchorlib/core';
+
+declare const TRACKER_REGISTRY: WeakMap<Linkable, (prop: KeyLike) => void>;
+
+export { TRACKER_REGISTRY };

package/dist/reactive.js

@@ -0,0 +1,34 @@
+import { setTracker, createObserver } from '@anchorlib/core';
+import { createSubscriber } from 'svelte/reactivity';
+
+// src/reactive.ts
+var TRACKER_REGISTRY = /* @__PURE__ */ new WeakMap();
+var bindingInitialized = false;
+if (!bindingInitialized && typeof window !== "undefined") {
+  bindingInitialized = true;
+  setTracker((init, observers, key) => {
+    if (!TRACKER_REGISTRY.has(init)) {
+      let track = void 0;
+      const subscribe = createSubscriber((update) => {
+        const observer = createObserver(() => {
+          update();
+        });
+        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);
+  });
+}
+
+export { TRACKER_REGISTRY };
+//# sourceMappingURL=reactive.js.map
+//# sourceMappingURL=reactive.js.map

package/dist/reactive.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/reactive.ts"],"names":[],"mappings":";;;;AAGO,IAAM,gBAAA,uBAAuB,OAAA;AAEpC,IAAI,kBAAA,GAAqB,KAAA;AAEzB,IAAI,CAAC,kBAAA,IAAsB,OAAO,MAAA,KAAW,WAAA,EAAa;AACxD,EAAA,kBAAA,GAAqB,IAAA;AAWrB,EAAA,UAAA,CAAW,CAAC,IAAA,EAAM,SAAA,EAAW,GAAA,KAAQ;AAEnC,IAAA,IAAI,CAAC,gBAAA,CAAiB,GAAA,CAAI,IAAI,CAAA,EAAG;AAC/B,MAAA,IAAI,KAAA,GAA+C,MAAA;AAGnD,MAAA,MAAM,SAAA,GAAY,gBAAA,CAAiB,CAAC,MAAA,KAAW;AAE7C,QAAA,MAAM,QAAA,GAAW,eAAe,MAAM;AACpC,UAAA,MAAA,EAAO;AAAA,QACT,CAAC,CAAA;AAGD,QAAA,KAAA,GAAQ,QAAA,CAAS,MAAA,CAAO,IAAA,EAAM,SAAS,CAAA;AAGvC,QAAA,OAAO,MAAM;AACX,UAAA,QAAA,CAAS,OAAA,EAAQ;AACjB,UAAA,gBAAA,CAAiB,OAAO,IAAI,CAAA;AAAA,QAC9B,CAAA;AAAA,MACF,CAAC,CAAA;AAGD,MAAA,MAAM,MAAA,GAAS,CAAC,IAAA,KAAkB;AAEhC,QAAA,SAAA,EAAU;AAEV,QAAA,KAAA,GAAQ,IAAI,CAAA;AAAA,MACd,CAAA;AAGA,MAAA,gBAAA,CAAiB,GAAA,CAAI,MAAM,MAAM,CAAA;AAAA,IACnC;AAGA,IAAA,gBAAA,CAAiB,GAAA,CAAI,IAAI,CAAA,GAAI,GAAG,CAAA;AAAA,EAClC,CAAC,CAAA;AACH","file":"reactive.js","sourcesContent":["import { createObserver, type KeyLike, type Linkable, setTracker } from '@anchorlib/core';\nimport { createSubscriber } from 'svelte/reactivity';\n\nexport const TRACKER_REGISTRY = new WeakMap<Linkable, (prop: KeyLike) => void>();\n\nlet bindingInitialized = false;\n\nif (!bindingInitialized && typeof window !== 'undefined') {\n  bindingInitialized = true;\n\n  /**\n   * Sets up a tracker function that integrates Anchor's reactivity system with Svelte's reactivity.\n   * This tracker is responsible for creating observers that watch for changes in reactive objects\n   * and properly subscribing/unsubscribing to Svelte's reactivity system.\n   *\n   * @param init - The initial linkable object to track\n   * @param observers - The observers collection to use for tracking\n   * @param key - The specific key/property to track on the object\n   */\n  setTracker((init, observers, key) => {\n    // Only initialize the tracking setup once per object\n    if (!TRACKER_REGISTRY.has(init)) {\n      let track: ((prop: KeyLike) => void) | undefined = undefined;\n\n      // Create a Svelte subscriber that manages the lifecycle of our observer\n      const subscribe = createSubscriber((update) => {\n        // Create an Anchor observer that will trigger the Svelte update when changes occur\n        const observer = createObserver(() => {\n          update();\n        });\n\n        // Assign the observer to track changes on the init object and its observers\n        track = observer.assign(init, observers);\n\n        // Return cleanup function to destroy observer and remove from registry\n        return () => {\n          observer.destroy();\n          TRACKER_REGISTRY.delete(init);\n        };\n      });\n\n      // Function to assign tracking to a specific key/property\n      const assign = (prop: KeyLike) => {\n        // Activate the subscription\n        subscribe();\n        // Track the specific property\n        track?.(prop);\n      };\n\n      // Store the assign function in the registry for this object\n      TRACKER_REGISTRY.set(init, assign);\n    }\n\n    // Execute the tracking function for the specific key\n    TRACKER_REGISTRY.get(init)?.(key);\n  });\n}\n"]}

package/dist/storage/index.d.ts

@@ -0,0 +1,60 @@
+import { Storable, KVState, Rec, Row, RowState, FilterFn, RowListState, ReactiveTable, InferRec } from '@anchorlib/storage/db';
+import { ObjLike, LinkableSchema, StateOptions } from '@anchorlib/core';
+
+/**
+ * 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>;
+
+/**
+ * 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;
+
+/**
+ * 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;
+
+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>;
+}
+type InferRef<T> = T extends TableRef<Rec, infer R> ? R : never;
+type InferListRef<T> = T extends TableRef<Rec, infer R> ? 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 };

package/dist/storage/index.js

@@ -0,0 +1,68 @@
+import { kv, createTable } from '@anchorlib/storage/db';
+import { onDestroy } from 'svelte';
+import { persistent, session } from '@anchorlib/storage';
+
+// src/storage/kv.ts
+function kvRef(name, init) {
+  const state = kv(name, init);
+  onDestroy(() => {
+    kv.leave(state);
+  });
+  return state;
+}
+function persistentRef(name, init, options) {
+  const state = persistent(name, init, options);
+  onDestroy(() => {
+    persistent.leave(state);
+  });
+  return state;
+}
+function sessionRef(name, init, options) {
+  const state = session(name, init, options);
+  onDestroy(() => {
+    session.leave(state);
+  });
+  return 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 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, kvRef, persistentRef, sessionRef };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/storage/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/storage/kv.ts","../../src/storage/persistent.ts","../../src/storage/session.ts","../../src/storage/table.ts"],"names":["onDestroy"],"mappings":";;;;;AAcO,SAAS,KAAA,CAA0B,MAAc,IAAA,EAAqB;AAC3E,EAAA,MAAM,KAAA,GAAQ,EAAA,CAAG,IAAA,EAAM,IAAI,CAAA;AAE3B,EAAA,SAAA,CAAU,MAAM;AACd,IAAA,EAAA,CAAG,MAAM,KAAK,CAAA;AAAA,EAChB,CAAC,CAAA;AAED,EAAA,OAAO,KAAA;AACT;ACNO,SAAS,aAAA,CACd,IAAA,EACA,IAAA,EACA,OAAA,EACG;AACH,EAAA,MAAM,KAAA,GAAQ,UAAA,CAAW,IAAA,EAAM,IAAA,EAAM,OAAO,CAAA;AAE5C,EAAAA,UAAU,MAAM;AACd,IAAA,UAAA,CAAW,MAAM,KAAK,CAAA;AAAA,EACxB,CAAC,CAAA;AAED,EAAA,OAAO,KAAA;AACT;ACZO,SAAS,UAAA,CACd,IAAA,EACA,IAAA,EACA,OAAA,EACG;AACH,EAAA,MAAM,KAAA,GAAQ,OAAA,CAAQ,IAAA,EAAM,IAAA,EAAM,OAAO,CAAA;AAEzC,EAAAA,UAAU,MAAM;AACd,IAAA,OAAA,CAAQ,MAAM,KAAK,CAAA;AAAA,EACrB,CAAC,CAAA;AAED,EAAA,OAAO,KAAA;AACT;ACTO,SAAS,eACd,SAAA,EACA,OAAA,GAAU,GACV,OAAA,EACA,UAAA,EACA,SAAS,SAAA,EACO;AAChB,EAAA,IAAI,OAAO,cAAc,QAAA,EAAU;AACjC,IAAA,SAAA,GAAY,WAAA,CAAkB,SAAA,EAAW,OAAA,EAAS,OAAA,EAAS,YAAY,MAAM,CAAA;AAAA,EAC/E;AAEA,EAAA,MAAM,QAAA,GAAW,SAAA;AAEjB,EAAA,OAAO;AAAA,IACL,IAAI,EAAA,EAAY;AACd,MAAA,MAAM,KAAA,GAAQ,QAAA,CAAS,GAAA,CAAI,EAAE,CAAA;AAE7B,MAAAA,UAAU,MAAM;AACd,QAAA,QAAA,CAAS,MAAM,EAAE,CAAA;AAAA,MACnB,CAAC,CAAA;AAED,MAAA,OAAO,KAAA;AAAA,IACT,CAAA;AAAA,IACA,IAAI,OAAA,EAAY;AACd,MAAA,MAAM,KAAA,GAAQ,QAAA,CAAS,GAAA,CAAI,OAAO,CAAA;AAElC,MAAAA,UAAU,MAAM;AACd,QAAA,QAAA,CAAS,KAAA,CAAM,KAAA,CAAM,IAAA,CAAK,EAAE,CAAA;AAAA,MAC9B,CAAC,CAAA;AAED,MAAA,OAAO,KAAA;AAAA,IACT,CAAA;AAAA,IACA,IAAA,CAAK,MAAA,EAAoC,KAAA,EAAgB,SAAA,EAAgC;AACvF,MAAA,OAAO,QAAA,CAAS,IAAA,CAAK,MAAA,EAAQ,KAAA,EAAO,SAAS,CAAA;AAAA,IAC/C,CAAA;AAAA,IACA,WAAA,CAAY,IAAA,EAAe,MAAA,EAAoC,KAAA,EAAgB,SAAA,EAAgC;AAC7G,MAAA,OAAO,QAAA,CAAS,WAAA,CAAY,IAAA,EAAM,MAAA,EAAQ,OAAO,SAAS,CAAA;AAAA,IAC5D,CAAA;AAAA,IACA,OAAO,EAAA,EAAY;AACjB,MAAA,OAAO,QAAA,CAAS,OAAO,EAAE,CAAA;AAAA,IAC3B,CAAA;AAAA,IACA,KAAK,KAAA,EAAY;AACf,MAAA,QAAA,CAAS,KAAK,KAAK,CAAA;AACnB,MAAA,OAAO,IAAA;AAAA,IACT,CAAA;AAAA,IACA,KAAA,GAAQ;AACN,MAAA,OAAO,QAAA;AAAA,IACT;AAAA,GACF;AACF","file":"index.js","sourcesContent":["import { kv, type KVState, type Storable } from '@anchorlib/storage/db';\nimport { onDestroy } from 'svelte';\n\n/**\n * Creates a reactive key-value store state.\n *\n * This function initializes a key-value store with the given name and initial value,\n * and automatically cleans up the store subscription when the component is destroyed.\n *\n * @template T - The type of the stored value, must extend Storable\n * @param name - The unique identifier for the key-value store\n * @param init - The initial value for the store\n * @returns A reactive key-value store state.\n */\nexport function kvRef<T extends Storable>(name: string, init: T): KVState<T> {\n  const state = kv(name, init);\n\n  onDestroy(() => {\n    kv.leave(state);\n  });\n\n  return state;\n}\n","import type { LinkableSchema, ObjLike, StateOptions } from '@anchorlib/core';\nimport { persistent } from '@anchorlib/storage';\nimport { onDestroy } from 'svelte';\n\n/**\n * Creates a persistent reactive state using the provided name, initial value, and options.\n * The persistentRef is tied to the browser's local storage, meaning its value will persist\n * across page reloads and browser sessions until explicitly cleared.\n *\n * @template T - The type of the initial value, must extend object-like structure.\n * @template S - The schema type for linkable validation, defaults to LinkableSchema.\n * @param name - A unique string identifier for the local storage key.\n * @param init - The initial value to be stored in local storage.\n * @param options - Optional configuration for state behavior and validation schema.\n * @returns A reactive state that provides reactive access and modification capabilities.\n */\nexport function persistentRef<T extends ObjLike, S extends LinkableSchema = LinkableSchema>(\n  name: string,\n  init: T,\n  options?: StateOptions<S>\n): T {\n  const state = persistent(name, init, options);\n\n  onDestroy(() => {\n    persistent.leave(state);\n  });\n\n  return state;\n}\n","import type { LinkableSchema, ObjLike, StateOptions } from '@anchorlib/core';\nimport { session } from '@anchorlib/storage';\nimport { onDestroy } from 'svelte';\n\n/**\n * Creates a session-scoped reactive state using the provided name, initial value, and options.\n * The sessionRef is tied to the browser's session storage, meaning its value will persist\n * across page reloads but not after the session ends (e.g., tab/window closed).\n *\n * @template T - The type of the initial value, must extend object-like structure.\n * @template S - The schema type for linkable validation, defaults to LinkableSchema.\n * @param name - A unique string identifier for the session storage key.\n * @param init - The initial value to be stored in session storage.\n * @param options - Optional configuration for state behavior and validation schema.\n * @returns A reactive state that provides reactive access and modification capabilities.\n */\nexport function sessionRef<T extends ObjLike, S extends LinkableSchema = LinkableSchema>(\n  name: string,\n  init: T,\n  options?: StateOptions<S>\n): T {\n  const state = session(name, init, options);\n\n  onDestroy(() => {\n    session.leave(state);\n  });\n\n  return state;\n}\n","import {\n  createTable,\n  type FilterFn,\n  type InferRec,\n  type ReactiveTable,\n  type Rec,\n  type Row,\n} from '@anchorlib/storage/db';\nimport { onDestroy } from 'svelte';\nimport type { TableRef } from './types.js';\n\nexport function createTableRef<T extends ReactiveTable<Rec>>(table: T): TableRef<InferRec<T>>;\nexport function createTableRef<T extends Rec, R extends Row<T> = Row<T>>(\n  name: string,\n  version?: number,\n  indexes?: (keyof R)[],\n  remIndexes?: (keyof R)[],\n  dbName?: string\n): TableRef<T, R>;\nexport function createTableRef<T extends Rec, R extends Row<T> = Row<T>>(\n  tableName: string | ReactiveTable<T>,\n  version = 1,\n  indexes?: (keyof R)[],\n  remIndexes?: (keyof R)[],\n  dbName = tableName as string\n): TableRef<T, R> {\n  if (typeof tableName === 'string') {\n    tableName = createTable<T, R>(tableName, version, indexes, remIndexes, dbName);\n  }\n\n  const tableRef = tableName as ReactiveTable<T, R>;\n\n  return {\n    get(id: string) {\n      const state = tableRef.get(id);\n\n      onDestroy(() => {\n        tableRef.leave(id);\n      });\n\n      return state;\n    },\n    add(payload: T) {\n      const state = tableRef.add(payload);\n\n      onDestroy(() => {\n        tableRef.leave(state.data.id);\n      });\n\n      return state;\n    },\n    list(filter?: IDBKeyRange | FilterFn<R>, limit?: number, direction?: IDBCursorDirection) {\n      return tableRef.list(filter, limit, direction);\n    },\n    listByIndex(name: keyof R, filter?: IDBKeyRange | FilterFn<R>, limit?: number, direction?: IDBCursorDirection) {\n      return tableRef.listByIndex(name, filter, limit, direction);\n    },\n    remove(id: string) {\n      return tableRef.remove(id);\n    },\n    seed(seeds: R[]) {\n      tableRef.seed(seeds);\n      return this;\n    },\n    table() {\n      return tableRef;\n    },\n  };\n}\n"]}

package/package.json

@@ -0,0 +1,91 @@
+{
+  "name": "@anchorlib/svelte",
+  "version": "1.0.0-beta.10",
+  "description": "Svelte bindings for Anchor reactive state management",
+  "keywords": [
+    "state",
+    "management",
+    "reactive",
+    "observable",
+    "svelte"
+  ],
+  "author": "Nanang Mahdaen El Agung <mahdaen@gmail.com>",
+  "homepage": "https://github.com/beerush-id/anchor",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/beerush-id/anchor.git"
+  },
+  "bugs": {
+    "url": "https://github.com/beerush-id/anchor/issues"
+  },
+  "type": "module",
+  "module": "./dist/index.js",
+  "svelte": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "svelte": "./dist/index.js",
+      "import": "./dist/index.js"
+    },
+    "./reactive": {
+      "types": "./dist/reactive.d.ts",
+      "svelte": "./dist/reactive.js",
+      "import": "./dist/reactive.js"
+    },
+    "./storage": {
+      "types": "./dist/storage/index.d.ts",
+      "svelte": "./dist/storage/index.js",
+      "import": "./dist/storage/index.js"
+    }
+  },
+  "directories": {
+    "dist": "./dist"
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@anchorlib/core": "^1.0.0-beta.10",
+    "@anchorlib/storage": "^1.0.0-beta.10"
+  },
+  "devDependencies": {
+    "@eslint/css": "^0.5.0",
+    "@eslint/js": "^9.23.0",
+    "@eslint/markdown": "^6.3.0",
+    "@sveltejs/vite-plugin-svelte": "^6.2.1",
+    "@testing-library/svelte": "^5.2.8",
+    "@testing-library/user-event": "^14.6.1",
+    "@types/react": "^19.1.8",
+    "@vitest/ui": "^3.2.4",
+    "eslint": "^9.23.0",
+    "eslint-plugin-prettier": "^5.2.3",
+    "jsdom": "^27.0.0",
+    "prettier": "^3.5.3",
+    "publint": "^0.3.9",
+    "rimraf": "^6.0.1",
+    "tsup": "^8.4.0",
+    "typescript-eslint": "^8.27.0",
+    "vitest": "^3.2.4"
+  },
+  "peerDependencies": {
+    "svelte": "^5.36.16",
+    "typescript": "^5.8.2"
+  },
+  "scripts": {
+    "dev": "rimraf dist && tsup --watch",
+    "clean": "rimraf dist",
+    "build": "rimraf dist && tsup && publint",
+    "prepublish": "rimraf dist && tsup && publint",
+    "format": "prettier --write .",
+    "test": "rimraf coverage && vitest --run",
+    "test:preview": "rimraf coverage && vitest --run && vite preview --outDir coverage"
+  },
+  "optionalDependencies": {
+    "zod": "^4.1.5"
+  }
+}

package/readme.md

@@ -0,0 +1,41 @@
+# Anchor Svelte Library
+
+This is the official Anchor library for Svelte. It provides a set of tools to manage state in your Svelte applications, based on the principles of the Anchor framework.
+
+## Installation
+
+```bash
+npm install @anchorlib/svelte
+```
+
+## Documentation
+
+For full documentation, visit [Anchor for Svelte](https://anchorlib.dev/docs/svelte/introduction.html)
+
+## Quick Start
+
+```svelte
+<script>
+  import { anchorRef } from '@anchorlib/svelte';
+
+  // Create a reactive state object
+  const state = anchorRef({
+    count: 0,
+    user: {
+      name: 'John Doe',
+      email: 'john@example.com'
+    }
+  });
+</script>
+
+<div>
+  <h1>Hello {state.user.name}</h1>
+  <p>Count: {state.count}</p>
+  <button onclick={() => state.count++}>Increment</button>
+  <button onclick={() => state.user.name = 'Jane Doe'}>Change Name</button>
+</div>
+```
+
+## License
+
+MIT