@anchorlib/svelte 1.0.0-beta.10 → 1.0.0-beta.14

package/dist/anchor.d.ts

@@ -0,0 +1,77 @@
+import { Linkable, LinkableSchema, StateOptions, ModelInput, ModelOutput, Immutable, ModelArray } 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;
+
+export { anchorRef, flatRef, orderedRef, rawRef, reactiveRef };

package/dist/anchor.js

@@ -0,0 +1,19 @@
+import { anchor } from '@anchorlib/core';
+
+function anchorRef(init, schemaOptions, options) {
+  return anchor(init, schemaOptions, options);
+}
+const 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);
+}
+
+export { anchorRef, flatRef, orderedRef, rawRef, reactiveRef };
+//# sourceMappingURL=anchor.js.map
+//# sourceMappingURL=anchor.js.map

package/dist/anchor.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/anchor.ts"],"names":[],"mappings":";;AAoEO,SAAS,SAAA,CACd,IAAA,EACA,aAAA,EACA,OAAA,EACgD;AAChD,EAAA,OAAO,MAAA,CAAyB,IAAA,EAAuB,aAAA,EAAoB,OAAO,CAAA;AACpF;AAMO,MAAM,WAAA,GAAc;AAYpB,SAAS,UAAA,CACd,IAAA,EACA,OAAA,EACA,OAAA,EACG;AACH,EAAA,OAAO,MAAA,CAAO,OAAA,CAAQ,IAAA,EAAM,OAAA,EAAS,OAAO,CAAA;AAC9C;AAWO,SAAS,OAAA,CAAgE,MAAS,OAAA,EAA8B;AACrH,EAAA,OAAO,MAAA,CAAO,IAAA,CAAK,IAAA,EAAM,OAAO,CAAA;AAClC;AAaO,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 * 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"]}

package/dist/derive.d.ts

@@ -0,0 +1,14 @@
+import { ConstantRef } from './types.js';
+
+/**
+ * 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>;
+
+export { derivedRef };

package/dist/derive.js

@@ -0,0 +1,26 @@
+import { anchor, subscribe } from '@anchorlib/core';
+import { onDestroy } from 'svelte';
+import { REF_REGISTRY } from './ref.js';
+
+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;
+}
+
+export { derivedRef };
+//# sourceMappingURL=derive.js.map
+//# sourceMappingURL=derive.js.map

package/dist/derive.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/derive.ts"],"names":[],"mappings":";;;;AAcO,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 * 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"]}

package/dist/fetch.d.ts

@@ -0,0 +1,56 @@
+import { FetchOptions, FetchState, StreamOptions } from '@anchorlib/core';
+
+/**
+ * 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>;
+
+export { fetchRef, streamRef };

package/dist/fetch.js

@@ -0,0 +1,12 @@
+import { fetchState, streamState } from '@anchorlib/core';
+
+function fetchRef(init, options) {
+  return fetchState(init, options);
+}
+function streamRef(init, options) {
+  return streamState(init, options);
+}
+
+export { fetchRef, streamRef };
+//# sourceMappingURL=fetch.js.map
+//# sourceMappingURL=fetch.js.map

package/dist/fetch.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/fetch.ts"],"names":[],"mappings":";;AA4BO,SAAS,QAAA,CAAY,MAAS,OAAA,EAAsC;AACzE,EAAA,OAAO,UAAA,CAAW,MAAM,OAAO,CAAA;AACjC;AA4BO,SAAS,SAAA,CAAa,MAAS,OAAA,EAA0C;AAC9E,EAAA,OAAO,WAAA,CAAY,MAAM,OAAO,CAAA;AAClC","file":"fetch.js","sourcesContent":["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"]}

package/dist/history.d.ts

@@ -0,0 +1,11 @@
+import { State, HistoryOptions, HistoryState } from '@anchorlib/core';
+
+/**
+ * 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;
+
+export { historyRef };

package/dist/history.js

@@ -0,0 +1,9 @@
+import { history } from '@anchorlib/core';
+
+function historyRef(state, options) {
+  return history(state, options);
+}
+
+export { historyRef };
+//# sourceMappingURL=history.js.map
+//# sourceMappingURL=history.js.map

package/dist/history.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/history.ts"],"names":[],"mappings":";;AASO,SAAS,UAAA,CAA4B,OAAU,OAAA,EAAwC;AAC5F,EAAA,OAAO,OAAA,CAAQ,OAAO,OAAO,CAAA;AAC/B","file":"history.js","sourcesContent":["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"]}

package/dist/immutable.d.ts

@@ -0,0 +1,43 @@
+import { State, LinkableSchema, StateOptions, Immutable, ModelInput, StateBaseOptions, ImmutableOutput, Mutable, MutationKey, MutablePart } from '@anchorlib/core';
+
+/**
+ * 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>;
+
+export { immutableRef, writableRef };

package/dist/immutable.js

@@ -0,0 +1,12 @@
+import { anchor } from '@anchorlib/core';
+
+function immutableRef(init, schemaOptions, options) {
+  return anchor.immutable(init, schemaOptions, options);
+}
+function writableRef(state, contracts) {
+  return anchor.writable(state, contracts);
+}
+
+export { immutableRef, writableRef };
+//# sourceMappingURL=immutable.js.map
+//# sourceMappingURL=immutable.js.map

package/dist/immutable.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/immutable.ts"],"names":[],"mappings":";;AA6CO,SAAS,YAAA,CACd,IAAA,EACA,aAAA,EACA,OAAA,EACc;AACd,EAAA,OAAO,MAAA,CAAO,SAAA,CAAU,IAAA,EAAe,aAAA,EAAwB,OAAO,CAAA;AACxE;AAuBO,SAAS,WAAA,CAAyD,OAAU,SAAA,EAAkB;AACnG,EAAA,OAAO,MAAA,CAAO,QAAA,CAAS,KAAA,EAAO,SAAS,CAAA;AACzC","file":"immutable.js","sourcesContent":["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"]}

package/dist/index.d.ts

@@ -1,305 +1,11 @@
-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 };
+export { anchorRef, flatRef, orderedRef, rawRef, reactiveRef } from './anchor.js';
+export { derivedRef } from './derive.js';
+export { fetchRef, streamRef } from './fetch.js';
+export { historyRef } from './history.js';
+export { immutableRef, writableRef } from './immutable.js';
+export { exceptionRef, modelRef } from './model.js';
+export { Props, PropsRef, propsRef } from './prop.js';
+export { observedRef } from './observable.js';
+export { REF_REGISTRY, constantRef, isRef, variableRef } from './ref.js';
+export { ConstantRef, StateRef, VariableRef } from './types.js';
+import '@anchorlib/core';