@azure-net/kit 5.2.0 → 5.4.0

package/dist/infra/response/BaseResponse.d.ts

@@ -20,7 +20,7 @@ export declare class ResponseBuilder<TData = unknown, TMeta = object, TWrapper =
         toPlainObject(): TResource;
     }): Omit<this, keyof ResponseBuilder<unknown, unknown, unknown>> & ResponseBuilder<TResource[], TMeta, TWrapper>;
     extract<TPath extends DeepKeys<TData>>(path: TPath): Omit<this, keyof ResponseBuilder<unknown, unknown, unknown>> & ResponseBuilder<DeepValue<TData, TPath>, TMeta, TWrapper>;
-    addMeta<TNewMeta extends Record<string, unknown>>(metaData: TNewMeta | ((current: TMeta) => TNewMeta)): Omit<this, keyof ResponseBuilder<unknown, unknown, unknown>> & ResponseBuilder<TData, TMeta & TNewMeta, TWrapper>;
+    addMeta<TNewMeta extends Record<string, unknown>>(metaData: TNewMeta | ((current: TMeta & TNewMeta) => TMeta & TNewMeta)): Omit<this, keyof ResponseBuilder<unknown, unknown, unknown>> & ResponseBuilder<TData, TMeta & TNewMeta, TWrapper>;
     getData(): TData;
     get(): {
         data: TData;

package/dist/shared/cookie/UniversalCookie.d.ts

@@ -9,12 +9,40 @@ export type CookieOptions = {
     priority?: 'low' | 'medium' | 'high' | undefined;
     partitioned?: boolean | undefined;
 };
+/** Cookie operations with shared defaults and request-local resolution at call time. */
+export declare class UniversalCookieInstance {
+    private readonly defaults;
+    constructor(options?: CookieOptions);
+    set<T>(name: string, value: T, options?: CookieOptions): void;
+    get<T = string>(name: string): T | undefined;
+    getAll<T = Record<string, unknown>>(): T | undefined;
+    has(name: string): boolean;
+    delete(name: string, options?: CookieOptions): void;
+    clear(options?: CookieOptions): void;
+    toCredentials(): string;
+    createNamedInstance<T = string>(name: string): UniversalNamedCookieInstance<T>;
+}
+/** Type-safe operations for one cookie name. */
+export declare class UniversalNamedCookieInstance<T = string> {
+    readonly name: string;
+    private readonly cookies;
+    constructor(name: string, cookies: UniversalCookieInstance);
+    set(value: T, options?: CookieOptions): void;
+    get(): T | undefined;
+    has(): boolean;
+    delete(options?: CookieOptions): void;
+    clear(options?: CookieOptions): void;
+}
 /**
  * Utility class for managing cookies in svelte ssr (browser and server).
  * Supports setting, getting, deleting, checking, and clearing cookies.
  * All methods are static and operate without creating instances.
  */
 export declare class UniversalCookie {
+    /** Creates reusable cookie operations with shared defaults. */
+    static createInstance(options?: CookieOptions): UniversalCookieInstance;
+    /** Creates reusable operations bound to one cookie name. */
+    static createNamedInstance<T = string>(name: string, options?: CookieOptions): UniversalNamedCookieInstance<T>;
     private static serialize;
     private static deserialize;
     /**

package/dist/shared/cookie/UniversalCookie.js

@@ -1,11 +1,81 @@
 import { BROWSER, Cookies } from '../../external/tools/index.js';
 import { RequestContext } from '../../external/edges/ServerContext.js';
+const cloneCookieOptions = (options) => ({
+    ...options,
+    expires: options.expires instanceof Date ? new Date(options.expires) : options.expires
+});
+const mergeCookieOptions = (defaults, overrides) => overrides ? { ...defaults, ...overrides } : defaults;
+/** Cookie operations with shared defaults and request-local resolution at call time. */
+export class UniversalCookieInstance {
+    defaults;
+    constructor(options = {}) {
+        this.defaults = cloneCookieOptions(options);
+    }
+    set(name, value, options) {
+        UniversalCookie.set(name, value, mergeCookieOptions(this.defaults, options));
+    }
+    get(name) {
+        return UniversalCookie.get(name);
+    }
+    getAll() {
+        return UniversalCookie.getAll();
+    }
+    has(name) {
+        return UniversalCookie.has(name);
+    }
+    delete(name, options) {
+        UniversalCookie.delete(name, mergeCookieOptions(this.defaults, options));
+    }
+    clear(options) {
+        UniversalCookie.clear(mergeCookieOptions(this.defaults, options));
+    }
+    toCredentials() {
+        return UniversalCookie.toCredentials();
+    }
+    createNamedInstance(name) {
+        return new UniversalNamedCookieInstance(name, this);
+    }
+}
+/** Type-safe operations for one cookie name. */
+export class UniversalNamedCookieInstance {
+    name;
+    cookies;
+    constructor(name, cookies) {
+        if (!name)
+            throw new TypeError('Cookie name must not be empty.');
+        this.name = name;
+        this.cookies = cookies;
+    }
+    set(value, options) {
+        this.cookies.set(this.name, value, options);
+    }
+    get() {
+        return this.cookies.get(this.name);
+    }
+    has() {
+        return this.cookies.has(this.name);
+    }
+    delete(options) {
+        this.cookies.delete(this.name, options);
+    }
+    clear(options) {
+        this.delete(options);
+    }
+}
 /**
  * Utility class for managing cookies in svelte ssr (browser and server).
  * Supports setting, getting, deleting, checking, and clearing cookies.
  * All methods are static and operate without creating instances.
  */
 export class UniversalCookie {
+    /** Creates reusable cookie operations with shared defaults. */
+    static createInstance(options = {}) {
+        return new UniversalCookieInstance(options);
+    }
+    /** Creates reusable operations bound to one cookie name. */
+    static createNamedInstance(name, options = {}) {
+        return this.createInstance(options).createNamedInstance(name);
+    }
     static serialize(value) {
         if (typeof value === 'string')
             return value;

package/dist/shared/event-bus/EventBus.d.ts

@@ -1,2 +1,12 @@
 import { EventBus } from '../../external/tools/index.js';
-export declare const AppEvents: () => EventBus<any>;
+declare global {
+    namespace App {
+        interface CustomEvents {
+            readonly __azureNetEvents__?: never;
+        }
+    }
+}
+export type AppEventsList = App.CustomEvents extends {
+    list: infer TEvents extends object;
+} ? TEvents : Record<never, never>;
+export declare const AppEvents: () => EventBus<AppEventsList>;

package/dist/shared/event-bus/EventBus.js

@@ -1,6 +1,3 @@
 import { EventBus } from '../../external/tools/index.js';
 import { createPresenter } from '../../external/edges/Edges.js';
-export const AppEvents = createPresenter(() => {
-    const appEventBus = new EventBus({});
-    return appEventBus;
-});
+export const AppEvents = createPresenter(() => new EventBus({}));

package/dist/shared/index.d.ts

@@ -1,4 +1,4 @@
-export { UniversalCookie, type CookieOptions } from './cookie/index.js';
+export { UniversalCookie, UniversalCookieInstance, UniversalNamedCookieInstance, type CookieOptions } from './cookie/index.js';
 export { BackgroundTask } from './background-task/index.js';
 export { AppEvents } from './event-bus/index.js';
 export { ClassMirror } from './class-mirror/index.js';

package/dist/shared/index.js

@@ -1,4 +1,4 @@
-export { UniversalCookie } from './cookie/index.js';
+export { UniversalCookie, UniversalCookieInstance, UniversalNamedCookieInstance } from './cookie/index.js';
 export { BackgroundTask } from './background-task/index.js';
 export { AppEvents } from './event-bus/index.js';
 export { ClassMirror } from './class-mirror/index.js';

package/dist/svelte/active-form/ActiveForm.svelte.d.ts

@@ -1,6 +1,7 @@
 import type { RequestErrors } from '../../delivery/schema/index.js';
 import type { AsyncActionResponse } from '../../delivery/injectable-dependencies/AsyncHelpers.js';
-type InitialData<FormData, Initial extends Partial<FormData>> = () => Initial | Promise<Initial>;
+import type { AsyncSignalSvelte } from '../async-signal/AsyncSignal.svelte.js';
+type MaybePromise<T> = T | Promise<T>;
 type PathRequiredShape<T, P extends string> = P extends `${infer Head}.${infer Tail}` ? Head extends keyof T ? {
     [K in Head]-?: PathRequiredShape<NonNullable<T[K]>, Tail>;
 } : unknown : P extends keyof T ? {
@@ -8,32 +9,59 @@ type PathRequiredShape<T, P extends string> = P extends `${infer Head}.${infer T
 } : unknown;
 type UnionToIntersection<U> = (U extends unknown ? (arg: U) => void : never) extends (arg: infer I) => void ? I : never;
 type RequiredByPaths<T, P extends string> = [P] extends [never] ? object : UnionToIntersection<PathRequiredShape<T, P>>;
-type ResetBehaviors = 'clear' | 'initial' | 'reloadInitial' | 'default';
-export interface FormConfig<FormData, Response, Initial extends Partial<FormData> = Partial<FormData>, RequiredPath extends string = never> {
-    initialData?: InitialData<FormData, Initial>;
-    required?: readonly RequiredPath[];
-    onSuccess?: (response: Response) => Promise<void> | void;
-    onError?: () => Promise<void> | void;
-    beforeSubmit?: (actions: {
-        form: ActiveFormController<FormData, RequiredPath>;
-        abort: () => void;
-    }) => Promise<void> | void;
-    successBehavior?: ResetBehaviors;
+export type ResetBehaviors = 'clear' | 'initial' | 'reloadInitial' | 'default';
+export type ActiveFormStatus = 'idle' | 'waitingForInitialValues' | 'pending' | 'success' | 'error';
+export type ActiveFormResponse<Response, FormData, Custom = Record<never, never>> = AsyncActionResponse<Response, FormData, Custom>;
+export interface LinkSignalOptions<TValue = unknown, MappedValues = unknown> {
+    watch?: boolean;
+    mapValues?: (data: TValue | undefined) => MappedValues;
+}
+export interface LinkPromise<FormData> {
+    <TValue extends Partial<FormData>>(source: () => Promise<TValue>): Promise<Partial<FormData>>;
+    <TValue>(source: () => Promise<TValue>, map: (value: TValue) => MaybePromise<Partial<FormData>>): Promise<Partial<FormData>>;
+}
+export interface LinkSignal<FormData> {
+    <TValue, MappedValues extends Partial<FormData>>(signal: AsyncSignalSvelte<TValue, unknown>, options: LinkSignalOptions<TValue, MappedValues> & {
+        mapValues: (data: TValue | undefined) => MappedValues;
+    }): Promise<MappedValues>;
+    <TValue extends Partial<FormData>>(signal: AsyncSignalSvelte<TValue, unknown>, options?: {
+        watch?: boolean;
+        mapValues?: never;
+    }): Promise<TValue | undefined>;
+}
+export interface InitialValuesHelpers<FormData> {
+    linkPromise: LinkPromise<FormData>;
+    linkSignal: LinkSignal<FormData>;
 }
+type InitialValues<FormData> = (helpers: InitialValuesHelpers<FormData>) => MaybePromise<Partial<FormData> | undefined>;
 export interface ActiveForm<FormData, Response, Custom, RequiredPath extends string = never> {
     data: Partial<FormData> & RequiredByPaths<FormData, RequiredPath>;
     errors: RequestErrors<FormData>;
-    submit: () => Promise<AsyncActionResponse<Response, FormData, Custom>>;
+    submit: () => Promise<ActiveFormResponse<Response, FormData, Custom>>;
     reset: (behavior?: ResetBehaviors) => Promise<void>;
     pending: boolean;
+    status: ActiveFormStatus;
     dirty: boolean;
-    ready: Promise<Partial<FormData>>;
 }
 export interface ActiveFormController<FormData, RequiredPath extends string = never> {
     data: Partial<FormData> & RequiredByPaths<FormData, RequiredPath>;
     errors: RequestErrors<FormData>;
     reset: (behavior?: ResetBehaviors) => Promise<void>;
 }
+export interface ActiveFormCallbackContext<FormData, Response, Custom, RequiredPath extends string = never> {
+    form: ActiveForm<FormData, Response, Custom, RequiredPath>;
+    response: ActiveFormResponse<Response, FormData, Custom>;
+}
+export interface FormConfig<FormData, Response, Custom = Record<never, never>, RequiredPath extends string = never> {
+    initialValues?: InitialValues<FormData>;
+    required?: readonly RequiredPath[];
+    onSuccess?: (context: ActiveFormCallbackContext<FormData, Response, Custom, RequiredPath>) => Promise<void> | void;
+    onError?: (context: ActiveFormCallbackContext<FormData, Response, Custom, RequiredPath>) => Promise<void> | void;
+    beforeSubmit?: (actions: {
+        form: ActiveFormController<FormData, RequiredPath>;
+        abort: () => void;
+    }) => Promise<void> | void;
+}
 type ExtractResponse<T> = T extends AsyncActionResponse<infer R, unknown, unknown> ? R : never;
 type ExtractFormData<T> = T extends AsyncActionResponse<unknown, infer D, unknown> ? D : never;
 type ExtractCustom<T> = T extends AsyncActionResponse<unknown, unknown, infer C> ? C : never;
@@ -43,5 +71,5 @@ type ExtractFromSubmit<T> = {
     formData: ExtractFormData<UnwrapPromise<T>>;
     custom: ExtractCustom<UnwrapPromise<T>>;
 };
-export declare const createActiveForm: <SubmitReturn extends Promise<AsyncActionResponse<unknown, unknown, unknown>>, RequiredPath extends string = never>(onSubmit: (formData: Partial<ExtractFromSubmit<SubmitReturn>["formData"]>) => SubmitReturn, config?: FormConfig<ExtractFromSubmit<SubmitReturn>["formData"], ExtractFromSubmit<SubmitReturn>["response"], Partial<ExtractFromSubmit<SubmitReturn>["formData"]>, RequiredPath>) => ActiveForm<ExtractFromSubmit<SubmitReturn>["formData"], ExtractFromSubmit<SubmitReturn>["response"], ExtractFromSubmit<SubmitReturn>["custom"], RequiredPath>;
+export declare const createActiveForm: <SubmitReturn extends Promise<AsyncActionResponse<unknown, unknown, unknown>>, RequiredPath extends string = never>(onSubmit: (formData: Partial<ExtractFromSubmit<SubmitReturn>["formData"]>) => SubmitReturn, config?: FormConfig<ExtractFromSubmit<SubmitReturn>["formData"], ExtractFromSubmit<SubmitReturn>["response"], ExtractFromSubmit<SubmitReturn>["custom"], RequiredPath>) => ActiveForm<ExtractFromSubmit<SubmitReturn>["formData"], ExtractFromSubmit<SubmitReturn>["response"], ExtractFromSubmit<SubmitReturn>["custom"], RequiredPath>;
 export {};

package/dist/svelte/active-form/ActiveForm.svelte.js

@@ -1,35 +1,133 @@
 import { ObjectUtil } from '../../external/tools/index.js';
 import { cloneStateValue } from '../shared/cloneStateValue.js';
+const NO_INITIAL_VALUES_ERROR = Symbol('no-initial-values-error');
+const isPromiseLike = (value) => {
+    return typeof value?.then === 'function';
+};
 export const createActiveForm = (onSubmit, config) => {
-    const isPromise = (value) => {
-        return typeof value?.then === 'function';
-    };
     let initial = {};
     let formData = $state(cloneStateValue(initial));
     let formErrors = $state({});
-    let pending = $state(false);
+    let status = $state('idle');
+    let signalBindings = $state.raw([]);
     let submitRunId = 0;
     let initialLoadRunId = 0;
+    let initialValuesTask = Promise.resolve();
+    let initialValuesError = NO_INITIAL_VALUES_ERROR;
+    let bindingsBySignal;
     const dirty = $derived(!ObjectUtil.equals(formData, initial));
-    const loadInitialData = async () => {
-        const runId = ++initialLoadRunId;
-        const source = config?.initialData;
-        if (!source) {
-            initial = {};
-            formData = cloneStateValue(initial);
-            formErrors = {};
-            return cloneStateValue(initial);
+    const pending = $derived(status === 'waitingForInitialValues' || status === 'pending');
+    const setValues = (values, invalidateSubmission = false) => {
+        if (invalidateSubmission) {
+            submitRunId += 1;
+            status = 'idle';
         }
-        const value = source();
-        const nextInitial = isPromise(value) ? await value : value;
-        if (runId !== initialLoadRunId)
-            return cloneStateValue(initial);
-        initial = cloneStateValue((nextInitial ?? {}));
+        initial = cloneStateValue(values);
         formData = cloneStateValue(initial);
         formErrors = {};
-        return cloneStateValue(initial);
     };
-    const ready = loadInitialData();
+    $effect(() => {
+        for (const binding of signalBindings) {
+            const status = binding.signal.status;
+            const data = binding.signal.data;
+            const shouldUpdate = binding.active && status === 'success' && (binding.lastStatus !== 'success' || !Object.is(binding.lastData, data));
+            binding.lastStatus = status;
+            binding.lastData = data;
+            if (shouldUpdate)
+                setValues(binding.map(data), true);
+        }
+    });
+    const loadInitialValues = async () => {
+        const runId = ++initialLoadRunId;
+        const source = config?.initialValues;
+        initialValuesError = NO_INITIAL_VALUES_ERROR;
+        if (!source) {
+            bindingsBySignal?.clear();
+            bindingsBySignal = undefined;
+            signalBindings = [];
+            setValues({});
+            status = 'idle';
+            return;
+        }
+        try {
+            const linkPromise = (async (promiseSource, map) => {
+                const value = await promiseSource();
+                return map ? await map(value) : value;
+            });
+            const linkSignal = (async (signal, options = {}) => {
+                const map = options.mapValues ?? ((value) => value);
+                let binding;
+                if (options.watch && runId === initialLoadRunId) {
+                    const untypedSignal = signal;
+                    const bindings = (bindingsBySignal ??= new Map());
+                    binding = bindings.get(untypedSignal);
+                    if (!binding) {
+                        binding = {
+                            signal: untypedSignal,
+                            map: map,
+                            active: false,
+                            loadRunId: runId,
+                            lastData: signal.data,
+                            lastStatus: signal.status
+                        };
+                        bindings.set(untypedSignal, binding);
+                    }
+                    else {
+                        binding.map = map;
+                        binding.active = false;
+                        binding.loadRunId = runId;
+                    }
+                    signalBindings = [...bindings.values()];
+                }
+                if (signal.status === 'idle' || signal.status === 'pending')
+                    await signal.ready;
+                const value = signal.data;
+                if (binding && runId === initialLoadRunId && binding.loadRunId === runId) {
+                    binding.active = true;
+                    binding.lastData = value;
+                    binding.lastStatus = signal.status;
+                    signalBindings = bindingsBySignal ? [...bindingsBySignal.values()] : [];
+                }
+                return map(value);
+            });
+            const sourceResult = source({ linkPromise, linkSignal });
+            let nextInitial;
+            if (isPromiseLike(sourceResult)) {
+                status = 'waitingForInitialValues';
+                nextInitial = await sourceResult;
+            }
+            else {
+                nextInitial = sourceResult;
+            }
+            if (runId !== initialLoadRunId)
+                return;
+            if (bindingsBySignal) {
+                for (const [signal, binding] of bindingsBySignal) {
+                    if (binding.loadRunId !== runId)
+                        bindingsBySignal.delete(signal);
+                }
+                if (bindingsBySignal.size === 0)
+                    bindingsBySignal = undefined;
+            }
+            signalBindings = bindingsBySignal ? [...bindingsBySignal.values()] : [];
+            setValues(nextInitial ?? {});
+            status = 'idle';
+        }
+        catch (error) {
+            if (runId === initialLoadRunId) {
+                initialValuesError = error;
+                status = 'error';
+            }
+            throw error;
+        }
+    };
+    const startInitialValues = () => {
+        const task = loadInitialValues();
+        initialValuesTask = task.then(() => undefined, () => undefined);
+        return task;
+    };
+    if (config?.initialValues)
+        void startInitialValues();
     const abortedResponse = () => ({
         success: false,
         response: undefined
@@ -37,10 +135,13 @@ export const createActiveForm = (onSubmit, config) => {
     const resetForm = async (behavior = 'clear', invalidateSubmission = true) => {
         if (invalidateSubmission) {
             submitRunId += 1;
-            pending = false;
+            status = 'idle';
         }
-        if (behavior !== 'reloadInitial')
+        if (behavior !== 'reloadInitial') {
             initialLoadRunId += 1;
+            initialValuesTask = Promise.resolve();
+            initialValuesError = NO_INITIAL_VALUES_ERROR;
+        }
         switch (behavior) {
             case 'clear':
                 formData = {};
@@ -49,7 +150,7 @@ export const createActiveForm = (onSubmit, config) => {
                 formData = cloneStateValue(initial);
                 break;
             case 'reloadInitial':
-                await loadInitialData();
+                await startInitialValues();
                 break;
         }
         formErrors = {};
@@ -57,43 +158,53 @@ export const createActiveForm = (onSubmit, config) => {
     const reset = async (behavior = 'clear') => resetForm(behavior, true);
     const submit = async () => {
         const runId = ++submitRunId;
-        pending = true;
         try {
-            await ready;
+            await initialValuesTask;
             if (runId !== submitRunId)
                 return abortedResponse();
+            if (initialValuesError !== NO_INITIAL_VALUES_ERROR)
+                throw initialValuesError;
+            status = 'pending';
             if (config?.beforeSubmit) {
                 let aborted = false;
-                const abort = () => {
-                    aborted = true;
-                };
-                await config.beforeSubmit({ form: formApi, abort: () => abort() });
-                if (aborted || runId !== submitRunId)
+                await config.beforeSubmit({
+                    form: formController,
+                    abort: () => {
+                        aborted = true;
+                    }
+                });
+                if (aborted) {
+                    if (runId === submitRunId)
+                        status = 'idle';
+                    return abortedResponse();
+                }
+                if (runId !== submitRunId)
                     return abortedResponse();
             }
-            const result = await onSubmit(cloneStateValue(formData));
+            const result = (await onSubmit(cloneStateValue(formData)));
             if (runId !== submitRunId)
                 return result;
             if (result.success) {
-                await config?.onSuccess?.(result.response);
-                if (runId !== submitRunId)
-                    return result;
-                await resetForm(config?.successBehavior ?? 'default', false);
+                await config?.onSuccess?.({ form: activeForm, response: result });
+                if (runId === submitRunId)
+                    status = 'success';
             }
             else {
-                if (result.error?.validation) {
+                if (result.error?.validation)
                     formErrors = result.error.validation;
-                }
-                await config?.onError?.();
+                await config?.onError?.({ form: activeForm, response: result });
+                if (runId === submitRunId)
+                    status = 'error';
             }
             return result;
         }
-        finally {
+        catch (error) {
             if (runId === submitRunId)
-                pending = false;
+                status = 'error';
+            throw error;
         }
     };
-    const formApi = {
+    const formController = {
         get data() {
             return formData;
         },
@@ -108,7 +219,7 @@ export const createActiveForm = (onSubmit, config) => {
         },
         reset
     };
-    return {
+    const activeForm = {
         get data() {
             return formData;
         },
@@ -127,8 +238,11 @@ export const createActiveForm = (onSubmit, config) => {
         get pending() {
             return pending;
         },
+        get status() {
+            return status;
+        },
         submit,
-        ready,
         reset
     };
+    return activeForm;
 };

package/dist/svelte/async-signal/AsyncSignal.svelte.js

@@ -124,6 +124,9 @@ export const createAsyncSignal = (handler, options = {}) => {
         }
         await start('manual');
     };
+    const refresh = async () => {
+        await start('manual');
+    };
     if (BROWSER) {
         const signalKey = key ?? asyncSignalManager.generateKey();
         const callback = (source) => start(source);
@@ -163,7 +166,7 @@ export const createAsyncSignal = (handler, options = {}) => {
             return start('auto');
         },
         execute,
-        refresh: execute,
+        refresh,
         reset: () => {
             currentRunId += 1;
             abortController?.abort();

package/dist/svelte/index.d.ts

@@ -1,3 +1,3 @@
 export { createAsyncSignal, refreshAsyncSignal, refreshAllAsyncSignals, type AsyncSignalOptions, type AsyncSignalSvelte, type AsyncStatus, type AsyncSignalSource } from './async-signal/AsyncSignal.svelte.js';
-export { createActiveForm } from './active-form/ActiveForm.svelte.js';
+export { createActiveForm, type ActiveForm, type ActiveFormCallbackContext, type ActiveFormController, type ActiveFormResponse, type ActiveFormStatus, type FormConfig, type InitialValuesHelpers, type LinkPromise, type LinkSignal, type LinkSignalOptions, type ResetBehaviors } from './active-form/ActiveForm.svelte.js';
 export { createQuery, type QueryController, type CreateQueryOptions } from './query/Query.svelte.js';

package/dist/svelte/query/Query.svelte.js

@@ -1,24 +1,55 @@
 import { untrack } from 'svelte';
+import { ObjectUtil } from '../../external/tools/index.js';
 import { cloneStateValue } from '../shared/cloneStateValue.js';
+const trackDeep = (value, seen = new WeakSet()) => {
+    if (value === null || typeof value !== 'object' || seen.has(value))
+        return;
+    seen.add(value);
+    if (Array.isArray(value)) {
+        for (const item of value)
+            trackDeep(item, seen);
+        return;
+    }
+    if (value instanceof Map) {
+        for (const [key, item] of value) {
+            trackDeep(key, seen);
+            trackDeep(item, seen);
+        }
+        return;
+    }
+    if (value instanceof Set) {
+        for (const item of value)
+            trackDeep(item, seen);
+        return;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null)
+        return;
+    for (const key of Reflect.ownKeys(value)) {
+        trackDeep(Reflect.get(value, key), seen);
+    }
+};
 export const createQuery = (initialValue, options) => {
     const baseInitial = cloneStateValue(initialValue);
     let data = $state(cloneStateValue(baseInitial));
-    const includeKeys = options?.onChange?.include ?? [];
+    const includeKeys = [...new Set(options?.onChange?.include ?? [])];
     const hasWatch = Boolean(options?.onChange?.handler) && includeKeys.length > 0;
-    const lastValues = new Map();
+    const lastSnapshots = new Map();
     let onChangeController = null;
     let onChangeRunId = 0;
     if (hasWatch) {
         includeKeys.forEach((key) => {
-            lastValues.set(key, data[key]);
+            lastSnapshots.set(key, cloneStateValue(data[key]));
         });
         $effect(() => {
             const changedKeys = [];
             includeKeys.forEach((key) => {
                 const nextValue = data[key];
-                if (!Object.is(lastValues.get(key), nextValue)) {
+                trackDeep(nextValue);
+                const nextSnapshot = cloneStateValue(nextValue);
+                if (!ObjectUtil.equals(lastSnapshots.get(key), nextSnapshot)) {
                     changedKeys.push(key);
-                    lastValues.set(key, nextValue);
+                    lastSnapshots.set(key, nextSnapshot);
                 }
             });
             if (!changedKeys.length)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@azure-net/kit",
-  "version": "5.2.0",
+  "version": "5.4.0",
   "license": "MIT",
   "author": "Pixel1917",
   "description": "Universal toolkit and library collection, developed as part of the Azure-net ecosystem",
@@ -126,8 +126,9 @@
     "format": "prettier --write .",
     "lint": "prettier --check . && eslint .",
     "test:unit": "vitest --config vitest.config.ts",
+    "test:client": "vitest --config vitest.client.config.ts",
     "test:integration": "vitest --config vitest.integration.config.ts --run",
-    "test": "pnpm test:unit -- --run && pnpm test:integration && pnpm test:e2e",
+    "test": "pnpm test:unit -- --run && pnpm test:client -- --run && pnpm test:integration && pnpm test:e2e",
     "test:e2e": "playwright test",
     "commit": "pnpm format && git add ."
   }