@anchorlib/svelte 1.0.0-beta.11 → 1.0.0-beta.15

package/dist/anchor.d.ts

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

package/dist/core/index.d.ts

@@ -0,0 +1 @@
+export * from '@anchorlib/core';

package/dist/core/index.js

@@ -0,0 +1,3 @@
+export * from '@anchorlib/core';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/core/index.js.map

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

package/dist/derive.d.ts

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

package/dist/fetch.d.ts

@@ -0,0 +1,60 @@
+import { FetchOptions, FetchState, StreamOptions } from '@anchorlib/core';
+
+/**
+ * @deprecated Use 'fetchState()' or 'asyncState()' instead.
+ * 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>;
+/**
+ * @deprecated Use 'fetchState()' or 'asyncState()' instead.
+ * 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>;
+/**
+ * @deprecated Use 'streamState()' instead.
+ * 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>;
+/**
+ * @deprecated Use 'streamState()' instead.
+ * 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":";;AA8BO,SAAS,QAAA,CAAY,MAAS,OAAA,EAAsC;AACzE,EAAA,OAAO,UAAA,CAAW,MAAM,OAAO,CAAA;AACjC;AA8BO,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 * @deprecated Use 'fetchState()' or 'asyncState()' instead.\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 * @deprecated Use 'fetchState()' or 'asyncState()' instead.\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 * @deprecated Use 'streamState()' instead.\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 * @deprecated Use 'streamState()' instead.\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}"]}

package/dist/history.d.ts

@@ -0,0 +1,12 @@
+import { State, HistoryOptions, HistoryState } from '@anchorlib/core';
+
+/**
+ * @deprecated Use 'history()' instead.
+ * 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":";;AAUO,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 * @deprecated Use 'history()' instead.\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}"]}

package/dist/immutable.d.ts

@@ -0,0 +1,47 @@
+import { State, LinkableSchema, StateOptions, Immutable, ModelInput, StateBaseOptions, ImmutableOutput, Mutable, MutationKey, MutablePart } from '@anchorlib/core';
+
+/**
+ * @deprecated Use 'immutable()' instead.
+ * 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>;
+/**
+ * @deprecated Use 'immutable()' instead.
+ * 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>;
+/**
+ * @deprecated Use 'writable()' instead.
+ * 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>;
+/**
+ * @deprecated Use 'writable()' instead.
+ * 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":";;AA+CO,SAAS,YAAA,CACd,IAAA,EACA,aAAA,EACA,OAAA,EACc;AACd,EAAA,OAAO,MAAA,CAAO,SAAA,CAAU,IAAA,EAAe,aAAA,EAAwB,OAAO,CAAA;AACxE;AAyBO,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 * @deprecated Use 'immutable()' instead.\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 * @deprecated Use 'immutable()' instead.\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 * @deprecated Use 'writable()' instead.\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 * @deprecated Use 'writable()' instead.\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}"]}