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

package/dist/anchor.d.ts

@@ -1,4 +1,6 @@
-import { Linkable, LinkableSchema, StateOptions, ModelInput, ModelOutput, Immutable, ModelArray } from '@anchorlib/core';
+import { Immutable, Linkable, LinkableSchema, ModelArray, ModelInput, ModelOutput, StateOptions } from "@anchorlib/core";
+
+//#region src/anchor.d.ts
 
 /**
  * @deprecated Use 'mutable()' instead.
@@ -36,7 +38,7 @@ declare function anchorRef<S extends LinkableSchema, T extends ModelInput<S>>(in
  * @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: true;
 }): Immutable<ModelOutput<S>>;
 /**
  * @deprecated Use 'mutable()' instead.
@@ -80,5 +82,5 @@ declare function flatRef<T extends unknown[], S extends ModelArray = ModelArray>
  * @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 };
+//#endregion
+export { anchorRef, flatRef, orderedRef, rawRef, reactiveRef };

package/dist/anchor.js

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

package/dist/core/index.d.ts

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

package/dist/core/index.js

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

package/dist/derive.d.ts

@@ -1,4 +1,6 @@
-import { ConstantRef } from './types.js';
+import { ConstantRef } from "./types.js";
+
+//#region src/derive.d.ts
 
 /**
  * @deprecated Use `derived()` instead.
@@ -11,5 +13,5 @@ import { ConstantRef } from './types.js';
  * @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 };
+//#endregion
+export { derivedRef };

package/dist/derive.js

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

package/dist/fetch.d.ts

@@ -1,4 +1,6 @@
-import { FetchOptions, FetchState, StreamOptions } from '@anchorlib/core';
+import { FetchOptions, FetchState, StreamOptions } from "@anchorlib/core";
+
+//#region src/fetch.d.ts
 
 /**
  * @deprecated Use 'fetchState()' or 'asyncState()' instead.
@@ -11,7 +13,7 @@ import { FetchOptions, FetchState, StreamOptions } from '@anchorlib/core';
  * @returns A `FetchState` object representing the state of the request.
  */
 declare function fetchRef<R>(init: R, options: FetchOptions & {
-    method: 'GET' | 'DELETE';
+  method: 'GET' | 'DELETE';
 }): FetchState<R>;
 /**
  * @deprecated Use 'fetchState()' or 'asyncState()' instead.
@@ -25,8 +27,8 @@ declare function fetchRef<R>(init: R, options: FetchOptions & {
  * @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;
+  method: 'POST' | 'PUT' | 'PATCH';
+  body: P;
 }): FetchState<R>;
 /**
  * @deprecated Use 'streamState()' instead.
@@ -39,7 +41,7 @@ declare function fetchRef<R, P>(init: R, options: FetchOptions & {
  * @returns A `FetchState` object representing the state of the request.
  */
 declare function streamRef<R>(init: R, options: StreamOptions<R> & {
-    method: 'GET' | 'DELETE';
+  method: 'GET' | 'DELETE';
 }): FetchState<R>;
 /**
  * @deprecated Use 'streamState()' instead.
@@ -53,8 +55,8 @@ declare function streamRef<R>(init: R, options: StreamOptions<R> & {
  * @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;
+  method: 'POST' | 'PUT' | 'PATCH';
+  body: P;
 }): FetchState<R>;
-
-export { fetchRef, streamRef };
+//#endregion
+export { fetchRef, streamRef };

package/dist/fetch.js

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

package/dist/history.d.ts

@@ -1,4 +1,6 @@
-import { State, HistoryOptions, HistoryState } from '@anchorlib/core';
+import { HistoryOptions, HistoryState, State } from "@anchorlib/core";
+
+//#region src/history.d.ts
 
 /**
  * @deprecated Use 'history()' instead.
@@ -8,5 +10,5 @@ import { State, HistoryOptions, HistoryState } from '@anchorlib/core';
  * @returns A `HistoryState` object representing the state of the history.
  */
 declare function historyRef<T extends State>(state: T, options?: HistoryOptions): HistoryState;
-
-export { historyRef };
+//#endregion
+export { historyRef };

package/dist/history.js

@@ -1,9 +1,16 @@
-import { history } from '@anchorlib/core';
+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);
+	return history(state, options);
 }
 
-export { historyRef };
-//# sourceMappingURL=history.js.map
-//# sourceMappingURL=history.js.map
+//#endregion
+export { historyRef };

package/dist/immutable.d.ts

@@ -1,4 +1,6 @@
-import { State, LinkableSchema, StateOptions, Immutable, ModelInput, StateBaseOptions, ImmutableOutput, Mutable, MutationKey, MutablePart } from '@anchorlib/core';
+import { Immutable, ImmutableOutput, LinkableSchema, ModelInput, Mutable, MutablePart, MutationKey, State, StateBaseOptions, StateOptions } from "@anchorlib/core";
+
+//#region src/immutable.d.ts
 
 /**
  * @deprecated Use 'immutable()' instead.
@@ -43,5 +45,5 @@ declare function writableRef<T extends State>(state: T): Mutable<T>;
  * @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 };
+//#endregion
+export { immutableRef, writableRef };

package/dist/immutable.js

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

package/dist/index.d.ts

@@ -1,11 +1,12 @@
-export { AnchorSettings, BatchHandler, Context, ContextProvider, DerivedRef, EffectHandler, FetchOptions, FetchState, FetchStatus, HistoryOptions, HistoryState, Immutable, ImmutableOutput, ImmutableRef, MicroBatch, MicroLooper, MicroPusher, MicroTask, ModelError, ModelInput, ModelObject, Mutable, MutablePart, MutableRef, PushHandler, State, StateChange, StateException, StateExceptionHandler, StateObserver, StateOptions, StateSubscriber, StateUnsubscribe, TaskHandler, Writable, anchor, derived, effect, exception, fetchState, getContext, history, immutable, isImmutableRef, isMutableRef, isValueRef, microbatch, microloop, micropush, microtask, model, mutable, ordered, setContext, shortId, streamState, subscribe, undoable, writable } from '@anchorlib/core';
-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 { anchorRef, flatRef, orderedRef, rawRef, reactiveRef } from "./anchor.js";
+import { ConstantRef, StateRef, VariableRef } from "./types.js";
+import { derivedRef } from "./derive.js";
+import { fetchRef, streamRef } from "./fetch.js";
+import { historyRef } from "./history.js";
+import { immutableRef, writableRef } from "./immutable.js";
+import { exceptionRef, modelRef } from "./model.js";
+import { Props, PropsRef, propsRef } from "./prop.js";
+import { observedRef } from "./observable.js";
+import { REF_REGISTRY, constantRef, isRef, variableRef } from "./ref.js";
+import { AnchorSettings, BatchHandler, Context, ContextProvider, DerivedRef, EffectHandler, FetchOptions, FetchState, FetchStatus, HistoryOptions, HistoryState, Immutable, ImmutableOutput, ImmutableRef, MicroBatch, MicroLooper, MicroPusher, MicroTask, ModelError, ModelInput, ModelObject, Mutable, MutablePart, MutableRef, PushHandler, State, StateChange, StateException, StateExceptionHandler, StateObserver, StateOptions, StateSubscriber, StateUnsubscribe, TaskHandler, Writable, anchor, derived, effect, exception, fetchState, getContext, history, immutable, isImmutableRef, isMutableRef, isValueRef, microbatch, microloop, micropush, microtask, model, mutable, ordered, setContext, shortId, streamState, subscribe, undoable, writable } from "@anchorlib/core";
+export { type AnchorSettings, type BatchHandler, ConstantRef, type Context, type ContextProvider, DerivedRef, type EffectHandler, type FetchOptions, type FetchState, FetchStatus, type HistoryOptions, type HistoryState, type Immutable, type ImmutableOutput, ImmutableRef, type MicroBatch, type MicroLooper, type MicroPusher, type MicroTask, type ModelError, type ModelInput, type ModelObject, type Mutable, type MutablePart, MutableRef, Props, PropsRef, type PushHandler, REF_REGISTRY, type State, type StateChange, type StateException, type StateExceptionHandler, type StateObserver, type StateOptions, StateRef, type StateSubscriber, type StateUnsubscribe, type TaskHandler, VariableRef, type Writable, anchor, anchorRef, constantRef, derived, derivedRef, effect, exception, exceptionRef, fetchRef, fetchState, flatRef, getContext, history, historyRef, immutable, immutableRef, isImmutableRef, isMutableRef, isRef, isValueRef, microbatch, microloop, micropush, microtask, model, modelRef, mutable, observedRef, ordered, orderedRef, propsRef, rawRef, reactiveRef, setContext, shortId, streamRef, streamState, subscribe, undoable, variableRef, writable, writableRef };

package/dist/index.js

@@ -1,14 +1,13 @@
-import './reactive.js';
-export { DerivedRef, FetchStatus, ImmutableRef, MutableRef, anchor, derived, effect, exception, fetchState, getContext, history, immutable, isImmutableRef, isMutableRef, isValueRef, microbatch, microloop, micropush, microtask, model, mutable, ordered, setContext, shortId, streamState, subscribe, undoable, writable } from '@anchorlib/core';
-export * from './anchor.js';
-export * from './derive.js';
-export * from './fetch.js';
-export * from './history.js';
-export * from './immutable.js';
-export * from './model.js';
-export * from './prop.js';
-export * from './observable.js';
-export * from './ref.js';
-export * from './types.js';
-//# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map
+import { anchorRef, flatRef, orderedRef, rawRef, reactiveRef } from "./anchor.js";
+import { REF_REGISTRY, constantRef, isRef, variableRef } from "./ref.js";
+import { derivedRef } from "./derive.js";
+import { fetchRef, streamRef } from "./fetch.js";
+import { historyRef } from "./history.js";
+import { immutableRef, writableRef } from "./immutable.js";
+import "./reactive.js";
+import { exceptionRef, modelRef } from "./model.js";
+import { propsRef } from "./prop.js";
+import { observedRef } from "./observable.js";
+import { DerivedRef, FetchStatus, ImmutableRef, MutableRef, anchor, derived, effect, exception, fetchState, getContext, history, immutable, isImmutableRef, isMutableRef, isValueRef, microbatch, microloop, micropush, microtask, model, mutable, ordered, setContext, shortId, streamState, subscribe, undoable, writable } from "@anchorlib/core";
+
+export { DerivedRef, FetchStatus, ImmutableRef, MutableRef, REF_REGISTRY, anchor, anchorRef, constantRef, derived, derivedRef, effect, exception, exceptionRef, fetchRef, fetchState, flatRef, getContext, history, historyRef, immutable, immutableRef, isImmutableRef, isMutableRef, isRef, isValueRef, microbatch, microloop, micropush, microtask, model, modelRef, mutable, observedRef, ordered, orderedRef, propsRef, rawRef, reactiveRef, setContext, shortId, streamRef, streamState, subscribe, undoable, variableRef, writable, writableRef };

package/dist/model.d.ts

@@ -1,4 +1,6 @@
-import { LinkableSchema, ModelInput, StateBaseOptions, ModelOutput, ImmutableOutput, ObjLike, StateExceptionMap } from '@anchorlib/core';
+import { ImmutableOutput, LinkableSchema, ModelInput, ModelOutput, ObjLike, StateBaseOptions, StateExceptionMap } from "@anchorlib/core";
+
+//#region src/model.d.ts
 
 /**
  * @deprecated Use 'model()' instead.
@@ -24,7 +26,7 @@ declare function modelRef<S extends LinkableSchema, T extends ModelInput<S>>(sch
  * @returns An immutable model output.
  */
 declare function modelRef<S extends LinkableSchema, T extends ModelInput<S>>(schema: S, init: T, options: StateBaseOptions & {
-    immutable: true;
+  immutable: true;
 }): ImmutableOutput<S>;
 /**
  * @deprecated Use 'exception()' instead.
@@ -35,5 +37,5 @@ declare function modelRef<S extends LinkableSchema, T extends ModelInput<S>>(sch
  * @returns A StateExceptionMap for the provided state.
  */
 declare function exceptionRef<T extends ObjLike | Array<unknown>>(state: T): StateExceptionMap<T>;
-
-export { exceptionRef, modelRef };
+//#endregion
+export { exceptionRef, modelRef };

package/dist/model.js

@@ -1,12 +1,20 @@
-import { anchor } from '@anchorlib/core';
+import { anchor } from "@anchorlib/core";
 
+//#region src/model.ts
 function modelRef(schema, init, options) {
-  return anchor(init, schema, options);
+	return anchor(init, schema, options);
 }
+/**
+* @deprecated Use 'exception()' instead.
+* 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.
+*/
 function exceptionRef(state) {
-  return anchor.catch(state);
+	return anchor.catch(state);
 }
 
-export { exceptionRef, modelRef };
-//# sourceMappingURL=model.js.map
-//# sourceMappingURL=model.js.map
+//#endregion
+export { exceptionRef, modelRef };

package/dist/observable.d.ts

@@ -1,4 +1,6 @@
-import { ConstantRef } from './types.js';
+import { ConstantRef } from "./types.js";
+
+//#region src/observable.d.ts
 
 /**
  * @deprecated use `effect()` instead.
@@ -11,5 +13,5 @@ import { ConstantRef } from './types.js';
  * @returns A read-only reference containing the observed value
  */
 declare function observedRef<R>(observe: () => R): ConstantRef<R>;
-
-export { observedRef };
+//#endregion
+export { observedRef };

package/dist/observable.js

@@ -1,28 +1,36 @@
-import { createObserver, anchor } from '@anchorlib/core';
-import { onDestroy } from 'svelte';
-import { REF_REGISTRY } from './ref.js';
+import { REF_REGISTRY } from "./ref.js";
+import { anchor, createObserver } from "@anchorlib/core";
+import { onDestroy } from "svelte";
 
+//#region src/observable.ts
+/**
+* @deprecated use `effect()` instead.
+* 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
+*/
 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;
+	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 { observedRef };
-//# sourceMappingURL=observable.js.map
-//# sourceMappingURL=observable.js.map
+//#endregion
+export { observedRef };

package/dist/prop.d.ts

@@ -1,12 +1,11 @@
-import { KeyLike, State } from '@anchorlib/core';
-import { ConstantRef } from './types.js';
+import { ConstantRef } from "./types.js";
+import { KeyLike, State } from "@anchorlib/core";
 
+//#region src/prop.d.ts
 type Props = {
-    [key: string]: KeyLike | State;
-};
-type PropsRef<T extends Props> = {
-    [K in keyof T]: T[K] extends State ? ConstantRef<T[K]> : T[K];
+  [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:
@@ -18,5 +17,5 @@ type PropsRef<T extends Props> = {
  * @returns {PropsRef<T>} A new object with State values converted to reactive states
  */
 declare function propsRef<T extends Props>(props: T): T;
-
-export { type Props, type PropsRef, propsRef };
+//#endregion
+export { Props, PropsRef, propsRef };

package/dist/prop.js

@@ -1,9 +1,19 @@
-import '@anchorlib/core';
+import "@anchorlib/core";
 
+//#region src/prop.ts
+/**
+* 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
+*/
 function propsRef(props) {
-  return props;
+	return props;
 }
 
-export { propsRef };
-//# sourceMappingURL=prop.js.map
-//# sourceMappingURL=prop.js.map
+//#endregion
+export { propsRef };

package/dist/reactive.d.ts

@@ -1,5 +1,6 @@
-import { Linkable, KeyLike } from '@anchorlib/core';
+import { KeyLike, Linkable } from "@anchorlib/core";
 
+//#region src/reactive.d.ts
 declare const TRACKER_REGISTRY: WeakMap<Linkable, (prop: KeyLike) => void>;
-
-export { TRACKER_REGISTRY };
+//#endregion
+export { TRACKER_REGISTRY };