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

package/dist/anchor.d.ts

@@ -0,0 +1,86 @@
+import { Immutable, Linkable, LinkableSchema, ModelArray, ModelInput, ModelOutput, StateOptions } from "@anchorlib/core";
+
+//#region src/anchor.d.ts
+
+/**
+ * @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;
+//#endregion
+export { anchorRef, flatRef, orderedRef, rawRef, reactiveRef };

package/dist/anchor.js

@@ -0,0 +1,68 @@
+import { anchor } from "@anchorlib/core";
+
+//#region src/anchor.ts
+/**
+* @deprecated Use 'mutable()' instead.
+* Creates a reactive state for state management with optional schema validation.
+*
+* @template T - The type of the initial value
+* @template S - The schema type or options
+* @param init - The initial value for the state
+* @param schemaOptions - Either a schema or state options
+* @param options - Additional state options when schema is provided
+* @returns A reactive state containing the managed state
+*/
+function anchorRef(init, schemaOptions, options) {
+	return anchor(init, schemaOptions, options);
+}
+/**
+* @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>>}}
+*/
+const reactiveRef = 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
+*/
+function orderedRef(init, compare, options) {
+	return anchor.ordered(init, compare, options);
+}
+/**
+* @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
+*/
+function flatRef(init, options) {
+	return anchor.flat(init, options);
+}
+/**
+* @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
+*/
+function rawRef(init, options) {
+	return anchor.raw(init, options);
+}
+
+//#endregion
+export { anchorRef, flatRef, orderedRef, rawRef, reactiveRef };

package/dist/core/index.d.ts

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

package/dist/core/index.js

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

package/dist/derive.d.ts

@@ -0,0 +1,17 @@
+import { ConstantRef } from "./types.js";
+
+//#region src/derive.d.ts
+
+/**
+ * @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>;
+//#endregion
+export { derivedRef };

package/dist/derive.js

@@ -0,0 +1,34 @@
+import { REF_REGISTRY } from "./ref.js";
+import { anchor, subscribe } from "@anchorlib/core";
+import { onDestroy } from "svelte";
+
+//#region src/derive.ts
+/**
+* @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
+*/
+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;
+}
+
+//#endregion
+export { derivedRef };

package/dist/fetch.d.ts

@@ -0,0 +1,62 @@
+import { FetchOptions, FetchState, StreamOptions } from "@anchorlib/core";
+
+//#region src/fetch.d.ts
+
+/**
+ * @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>;
+//#endregion
+export { fetchRef, streamRef };

package/dist/fetch.js

@@ -0,0 +1,12 @@
+import { fetchState, streamState } from "@anchorlib/core";
+
+//#region src/fetch.ts
+function fetchRef(init, options) {
+	return fetchState(init, options);
+}
+function streamRef(init, options) {
+	return streamState(init, options);
+}
+
+//#endregion
+export { fetchRef, streamRef };

package/dist/history.d.ts

@@ -0,0 +1,14 @@
+import { HistoryOptions, HistoryState, State } from "@anchorlib/core";
+
+//#region src/history.d.ts
+
+/**
+ * @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;
+//#endregion
+export { historyRef };

package/dist/history.js

@@ -0,0 +1,16 @@
+import { history } from "@anchorlib/core";
+
+//#region src/history.ts
+/**
+* @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.
+*/
+function historyRef(state, options) {
+	return history(state, options);
+}
+
+//#endregion
+export { historyRef };

package/dist/immutable.d.ts

@@ -0,0 +1,49 @@
+import { Immutable, ImmutableOutput, LinkableSchema, ModelInput, Mutable, MutablePart, MutationKey, State, StateBaseOptions, StateOptions } from "@anchorlib/core";
+
+//#region src/immutable.d.ts
+
+/**
+ * @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>;
+//#endregion
+export { immutableRef, writableRef };

package/dist/immutable.js

@@ -0,0 +1,14 @@
+import { anchor } from "@anchorlib/core";
+
+//#region src/immutable.ts
+/** Implementation of `immutableRef` overloads. */
+function immutableRef(init, schemaOptions, options) {
+	return anchor.immutable(init, schemaOptions, options);
+}
+/** Implementation of `writableRef` overloads. */
+function writableRef(state, contracts) {
+	return anchor.writable(state, contracts);
+}
+
+//#endregion
+export { immutableRef, writableRef };