@azure-net/kit 5.4.0 → 6.0.0-next

package/dist/shared/app-error/index.js

@@ -1 +1,2 @@
 export * from './AppError.js';
+export * from './ErrorRuntime.js';

package/dist/shared/boundary-provider/Provider.js

@@ -105,12 +105,18 @@ export const createBoundaryProvider = (name, settings) => {
             return factories;
         };
         const providerProxy = new Proxy({}, {
-            get(_, key) {
+            get(target, key, receiver) {
+                if (typeof key === 'symbol')
+                    return Reflect.get(target, key, receiver);
                 if (cache.has(key)) {
                     return cache.get(key);
                 }
                 const factories = getFactories();
-                if (!(key in factories)) {
+                if (!Object.hasOwn(factories, key)) {
+                    if (key === 'then' || key === 'toJSON')
+                        return undefined;
+                    if (Reflect.has(target, key))
+                        return Reflect.get(target, key, receiver);
                     throw new AzureNetKitInternalError(`[BoundaryProvider] Service '${key}' not found in provider '${name}'`);
                 }
                 const factory = factories[key];
@@ -124,17 +130,31 @@ export const createBoundaryProvider = (name, settings) => {
                 cache.set(key, instance);
                 return instance;
             },
-            has(_, key) {
+            has(target, key) {
+                if (typeof key === 'symbol')
+                    return Reflect.has(target, key);
                 if (cache.has(key))
                     return true;
                 const factories = getFactories();
-                return key in factories;
+                return Object.hasOwn(factories, key) || Reflect.has(target, key);
             },
             ownKeys() {
                 const factories = getFactories();
                 const cachedKeys = Array.from(cache.keys());
                 const factoryKeys = Object.keys(factories);
                 return [...new Set([...cachedKeys, ...factoryKeys])];
+            },
+            getOwnPropertyDescriptor(_, key) {
+                if (typeof key === 'symbol')
+                    return undefined;
+                const factories = getFactories();
+                if (!cache.has(key) && !Object.hasOwn(factories, key))
+                    return undefined;
+                return {
+                    configurable: true,
+                    enumerable: true,
+                    get: () => providerProxy[key]
+                };
             }
         });
         if (BROWSER) {

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

@@ -1,6 +1,6 @@
 import type { RequestErrors } from '../../delivery/schema/index.js';
 import type { AsyncActionResponse } from '../../delivery/injectable-dependencies/AsyncHelpers.js';
-import type { AsyncSignalSvelte } from '../async-signal/AsyncSignal.svelte.js';
+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>;

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

@@ -1,4 +1,5 @@
-import { ObjectUtil } from '../../external/tools/index.js';
+import { BROWSER, ObjectUtil } from '../../external/tools/index.js';
+import { isAsyncSignalScheduledForClient } from '../async-signal/AsyncSignal.svelte.js';
 import { cloneStateValue } from '../shared/cloneStateValue.js';
 const NO_INITIAL_VALUES_ERROR = Symbol('no-initial-values-error');
 const isPromiseLike = (value) => {
@@ -29,7 +30,7 @@ export const createActiveForm = (onSubmit, config) => {
     $effect(() => {
         for (const binding of signalBindings) {
             const status = binding.signal.status;
-            const data = binding.signal.data;
+            const data = binding.signal.response;
             const shouldUpdate = binding.active && status === 'success' && (binding.lastStatus !== 'success' || !Object.is(binding.lastData, data));
             binding.lastStatus = status;
             binding.lastData = data;
@@ -40,6 +41,7 @@ export const createActiveForm = (onSubmit, config) => {
     const loadInitialValues = async () => {
         const runId = ++initialLoadRunId;
         const source = config?.initialValues;
+        let waitingForClientSignal = false;
         initialValuesError = NO_INITIAL_VALUES_ERROR;
         if (!source) {
             bindingsBySignal?.clear();
@@ -67,7 +69,7 @@ export const createActiveForm = (onSubmit, config) => {
                             map: map,
                             active: false,
                             loadRunId: runId,
-                            lastData: signal.data,
+                            lastData: signal.response,
                             lastStatus: signal.status
                         };
                         bindings.set(untypedSignal, binding);
@@ -79,9 +81,13 @@ export const createActiveForm = (onSubmit, config) => {
                     }
                     signalBindings = [...bindings.values()];
                 }
+                if (!BROWSER && isAsyncSignalScheduledForClient(signal)) {
+                    waitingForClientSignal = true;
+                    return undefined;
+                }
                 if (signal.status === 'idle' || signal.status === 'pending')
                     await signal.ready;
-                const value = signal.data;
+                const value = signal.response;
                 if (binding && runId === initialLoadRunId && binding.loadRunId === runId) {
                     binding.active = true;
                     binding.lastData = value;
@@ -101,6 +107,10 @@ export const createActiveForm = (onSubmit, config) => {
             }
             if (runId !== initialLoadRunId)
                 return;
+            if (waitingForClientSignal) {
+                status = 'waitingForInitialValues';
+                return;
+            }
             if (bindingsBySignal) {
                 for (const [signal, binding] of bindingsBySignal) {
                     if (binding.loadRunId !== runId)

package/dist/svelte/async-signal/AsyncSignal.svelte.d.ts

@@ -13,7 +13,7 @@ export interface AsyncSignalOptions<TData, TError = Error> {
     key?: string;
 }
 export interface AsyncSignalSvelte<TData, TError = Error> {
-    data?: TData;
+    response?: TData;
     error?: TError;
     status: AsyncStatus;
     pending: boolean;
@@ -23,6 +23,17 @@ export interface AsyncSignalSvelte<TData, TError = Error> {
     reset: () => void;
     abort: () => void;
 }
+export interface AsyncSignalBatchOptions {
+    parallel?: boolean;
+}
+export interface AsyncSignalBatchFactory {
+    <TData, TError = Error>(handler: (signal?: AbortSignal) => Promise<TData>, options?: Omit<AsyncSignalOptions<TData, TError>, 'immediate'>): AsyncSignalSvelte<TData, TError>;
+}
+export interface AsyncSignalBatch<TSignals extends readonly AsyncSignalSvelte<unknown, unknown>[]> {
+    execute: () => TSignals;
+}
+export declare const isAsyncSignalScheduledForClient: (signal: AsyncSignalSvelte<unknown, unknown>) => boolean;
 export declare const createAsyncSignal: <TData, TError = Error>(handler: (signal?: AbortSignal) => Promise<TData>, options?: AsyncSignalOptions<TData, TError>) => AsyncSignalSvelte<TData, TError>;
+export declare const createAsyncSignalBatch: <const TSignals extends readonly AsyncSignalSvelte<unknown, unknown>[]>(factory: (createSignal: AsyncSignalBatchFactory) => TSignals, options?: AsyncSignalBatchOptions) => AsyncSignalBatch<TSignals>;
 export declare const refreshAsyncSignal: (key: string) => Promise<void>;
 export declare const refreshAllAsyncSignals: () => Promise<void>;

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

@@ -1,5 +1,20 @@
 import { untrack } from 'svelte';
 import { BROWSER } from '../../external/tools/index.js';
+const ASYNC_SIGNAL_BATCH_INTERNAL = Symbol('async-signal-batch-internal');
+const ASYNC_SIGNAL_SCHEDULED_FOR_CLIENT = Symbol('async-signal-scheduled-for-client');
+export const isAsyncSignalScheduledForClient = (signal) => {
+    return signal[ASYNC_SIGNAL_SCHEDULED_FOR_CLIENT]?.() ?? false;
+};
+const createDeferred = () => {
+    let resolve;
+    const promise = new Promise((promiseResolve) => {
+        resolve = promiseResolve;
+    });
+    return { promise, resolve };
+};
+const createResolvedPromise = (value) => {
+    return new Promise((resolve) => resolve(value));
+};
 const createAsyncSignalManager = () => {
     const instances = BROWSER ? new Map() : undefined;
     const generateUid = () => {
@@ -48,14 +63,36 @@ const asyncSignalManager = createAsyncSignalManager();
 export const createAsyncSignal = (handler, options = {}) => {
     const { server = false, immediate = true, initialData = undefined, key } = options;
     const resolvedInitialData = typeof initialData === 'function' ? initialData() : initialData;
+    let scheduledForClient = immediate && !BROWSER && !server;
     let data = $state(resolvedInitialData);
     let error = $state();
-    let status = $state('idle');
+    let status = $state(scheduledForClient ? 'pending' : 'idle');
     const pending = $derived(status === 'pending');
     let abortController = null;
     let currentPromise = null;
+    let readyPromise = createResolvedPromise(resolvedInitialData);
+    let resolveReady = null;
     let currentRunId = 0;
     let started = false;
+    let batchLocked = false;
+    let batchGate = null;
+    let batchSkipRequested = false;
+    const startReadyCycle = () => {
+        if (resolveReady)
+            return;
+        const deferred = createDeferred();
+        readyPromise = deferred.promise;
+        resolveReady = deferred.resolve;
+    };
+    const settleReadyCycle = () => {
+        const resolve = resolveReady;
+        if (!resolve) {
+            readyPromise = createResolvedPromise(data);
+            return;
+        }
+        resolveReady = null;
+        resolve(data);
+    };
     const run = async (runId, source) => {
         const initial = !started;
         started = true;
@@ -108,16 +145,28 @@ export const createAsyncSignal = (handler, options = {}) => {
                 currentPromise = null;
                 if (abortController === localController)
                     abortController = null;
+                settleReadyCycle();
             }
         }
     };
     const start = (source) => {
+        scheduledForClient = false;
+        startReadyCycle();
         const runId = ++currentRunId;
         const localPromise = run(runId, source);
         currentPromise = localPromise;
         return localPromise;
     };
+    const startWhenUnlocked = (source) => {
+        if (batchLocked)
+            return batchGate ?? readyPromise;
+        return start(source);
+    };
     const execute = async () => {
+        if (batchLocked) {
+            await batchGate;
+            return;
+        }
         if (currentPromise) {
             await currentPromise;
             return;
@@ -125,11 +174,15 @@ export const createAsyncSignal = (handler, options = {}) => {
         await start('manual');
     };
     const refresh = async () => {
+        if (batchLocked) {
+            await batchGate;
+            return;
+        }
         await start('manual');
     };
     if (BROWSER) {
         const signalKey = key ?? asyncSignalManager.generateKey();
-        const callback = (source) => start(source);
+        const callback = (source) => startWhenUnlocked(source);
         asyncSignalManager.register(signalKey, callback);
         $effect(() => {
             return () => {
@@ -147,8 +200,8 @@ export const createAsyncSignal = (handler, options = {}) => {
             void start('auto');
         }
     }
-    return {
-        get data() {
+    const asyncSignal = {
+        get response() {
             return data;
         },
         get error() {
@@ -161,13 +214,16 @@ export const createAsyncSignal = (handler, options = {}) => {
             return pending;
         },
         get ready() {
-            if (currentPromise)
-                return currentPromise;
-            return start('auto');
+            if (batchLocked)
+                return (batchGate ?? readyPromise);
+            return readyPromise;
         },
         execute,
         refresh,
         reset: () => {
+            scheduledForClient = false;
+            if (batchLocked)
+                batchSkipRequested = true;
             currentRunId += 1;
             abortController?.abort();
             abortController = null;
@@ -175,16 +231,111 @@ export const createAsyncSignal = (handler, options = {}) => {
             data = undefined;
             error = undefined;
             status = 'idle';
+            settleReadyCycle();
         },
         abort: () => {
+            scheduledForClient = false;
+            if (batchLocked)
+                batchSkipRequested = true;
             currentRunId += 1;
             abortController?.abort();
             abortController = null;
             currentPromise = null;
             error = undefined;
             status = 'idle';
+            settleReadyCycle();
         }
     };
+    Object.defineProperty(asyncSignal, ASYNC_SIGNAL_SCHEDULED_FOR_CLIENT, {
+        value: () => scheduledForClient
+    });
+    Object.defineProperty(asyncSignal, ASYNC_SIGNAL_BATCH_INTERNAL, {
+        value: {
+            lock: (gate) => {
+                batchLocked = true;
+                batchGate = gate ?? null;
+                batchSkipRequested = false;
+            },
+            unlock: () => {
+                batchLocked = false;
+                batchGate = null;
+            },
+            start: (source) => {
+                if (batchSkipRequested)
+                    return Promise.resolve(undefined);
+                return start(source);
+            }
+        }
+    });
+    return asyncSignal;
+};
+export const createAsyncSignalBatch = (factory, options = {}) => {
+    const internals = new Map();
+    const createSignal = (handler, signalOptions = {}) => {
+        const signal = createAsyncSignal(handler, { ...signalOptions, immediate: false });
+        const internal = signal[ASYNC_SIGNAL_BATCH_INTERNAL];
+        internal.lock();
+        internals.set(signal, internal);
+        return signal;
+    };
+    const signals = factory(createSignal);
+    const uniqueSignals = new Set(signals);
+    if (uniqueSignals.size !== signals.length || signals.some((signal) => !internals.has(signal))) {
+        throw new Error('[AsyncSignalBatch] Factory must return each signal created by createSignal exactly once.');
+    }
+    if (internals.size !== signals.length) {
+        throw new Error('[AsyncSignalBatch] Factory must return every signal created by createSignal.');
+    }
+    let running = false;
+    const execute = () => {
+        if (running || signals.length === 0)
+            return signals;
+        running = true;
+        const gates = signals.map(() => createDeferred());
+        signals.forEach((signal, index) => {
+            internals.get(signal)?.lock(gates[index].promise);
+        });
+        queueMicrotask(() => {
+            if (options.parallel !== false) {
+                let remaining = signals.length;
+                signals.forEach((signal, index) => {
+                    const internal = internals.get(signal);
+                    void internal
+                        .start('manual')
+                        .catch(() => undefined)
+                        .then((result) => {
+                        gates[index].resolve(result);
+                        internal.unlock();
+                        remaining -= 1;
+                        if (remaining === 0)
+                            running = false;
+                    });
+                });
+                return;
+            }
+            void (async () => {
+                for (let index = 0; index < signals.length; index += 1) {
+                    const signal = signals[index];
+                    const internal = internals.get(signal);
+                    const result = await internal.start('manual').catch(() => undefined);
+                    gates[index].resolve(result);
+                    internal.unlock();
+                    if (signal.status !== 'success') {
+                        for (let skippedIndex = index + 1; skippedIndex < signals.length; skippedIndex += 1) {
+                            const skippedSignal = signals[skippedIndex];
+                            gates[skippedIndex].resolve(undefined);
+                            internals.get(skippedSignal)?.unlock();
+                        }
+                        break;
+                    }
+                }
+            })().finally(() => {
+                running = false;
+            });
+        });
+        return signals;
+    };
+    return { execute };
 };
 export const refreshAsyncSignal = async (key) => {
     return await asyncSignalManager.refreshByKey(key);

package/dist/svelte/effect/Effect.svelte.d.ts

@@ -0,0 +1,4 @@
+export type EffectCleanup = () => void;
+export type EffectCallback = () => EffectCleanup | Promise<unknown> | void;
+export type EffectDependency<T = unknown> = () => T;
+export declare const createEffect: (callback: EffectCallback, dependencies: readonly EffectDependency[]) => void;

package/dist/svelte/effect/Effect.svelte.js

@@ -0,0 +1,27 @@
+import { untrack } from 'svelte';
+export const createEffect = (callback, dependencies) => {
+    let cleanup;
+    let initialized = false;
+    let previousValues = [];
+    $effect(() => {
+        const values = dependencies.map((dependency) => dependency());
+        const changed = !initialized || values.some((value, index) => !Object.is(value, previousValues[index]));
+        if (!changed)
+            return;
+        initialized = true;
+        previousValues = values;
+        untrack(() => {
+            cleanup?.();
+            cleanup = undefined;
+            const result = callback();
+            if (typeof result === 'function')
+                cleanup = result;
+        });
+    });
+    $effect(() => {
+        return () => {
+            untrack(() => cleanup?.());
+            cleanup = undefined;
+        };
+    });
+};

package/dist/svelte/effect/index.d.ts

@@ -0,0 +1 @@
+export * from './Effect.svelte.js';

package/dist/svelte/effect/index.js

@@ -0,0 +1 @@
+export * from './Effect.svelte.js';

package/dist/svelte/index.d.ts

@@ -1,3 +1,4 @@
-export { createAsyncSignal, refreshAsyncSignal, refreshAllAsyncSignals, type AsyncSignalOptions, type AsyncSignalSvelte, type AsyncStatus, type AsyncSignalSource } from './async-signal/AsyncSignal.svelte.js';
+export { createAsyncSignal, createAsyncSignalBatch, refreshAsyncSignal, refreshAllAsyncSignals, type AsyncSignalBatch, type AsyncSignalBatchFactory, type AsyncSignalBatchOptions, type AsyncSignalOptions, type AsyncSignalSvelte, type AsyncStatus, type AsyncSignalSource } from './async-signal/AsyncSignal.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';
+export { createEffect, type EffectCallback, type EffectCleanup, type EffectDependency } from './effect/Effect.svelte.js';
+export { createQuery, type CreateQueryOptions, type QueryController, type QueryPath, type QuerySearchParamsSync } from './query/Query.svelte.js';

package/dist/svelte/index.js

@@ -1,3 +1,4 @@
-export { createAsyncSignal, refreshAsyncSignal, refreshAllAsyncSignals } from './async-signal/AsyncSignal.svelte.js';
+export { createAsyncSignal, createAsyncSignalBatch, refreshAsyncSignal, refreshAllAsyncSignals } from './async-signal/AsyncSignal.svelte.js';
 export { createActiveForm } from './active-form/ActiveForm.svelte.js';
+export { createEffect } from './effect/Effect.svelte.js';
 export { createQuery } from './query/Query.svelte.js';

package/dist/svelte/query/Query.svelte.d.ts

@@ -1,20 +1,23 @@
-export interface QueryOnChangeContext<T extends Record<string, unknown>> {
-    snapshot: T;
-    changedKeys: (keyof T)[];
-    signal: AbortSignal;
-}
-export interface QueryOnChangeOptions<T extends Record<string, unknown>> {
-    include: (keyof T)[];
-    handler: (ctx: QueryOnChangeContext<T>) => Promise<void> | void;
+import { type EffectCallback } from '../effect/Effect.svelte.js';
+type QueryPathDepth = readonly [unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown];
+type QueryLeaf = bigint | boolean | Date | File | Blob | ((...args: never[]) => unknown) | Map<unknown, unknown> | null | number | readonly unknown[] | RegExp | Set<unknown> | string | symbol | undefined | URL | URLSearchParams;
+export type QueryPath<T, Depth extends readonly unknown[] = QueryPathDepth> = Depth extends readonly [unknown, ...infer Rest] ? T extends QueryLeaf ? never : T extends object ? {
+    [K in Extract<keyof T, string>]: NonNullable<T[K]> extends QueryLeaf ? K : K | `${K}.${QueryPath<NonNullable<T[K]>, Rest>}`;
+}[Extract<keyof T, string>] : never : never;
+export interface QuerySearchParamsSync<T extends Record<string, unknown>> {
+    fromSearchParams?: (params: URLSearchParams, initial: Readonly<T>) => Partial<T>;
+    toSearchParams?: (data: Readonly<T>, initial: Readonly<T>) => URLSearchParams;
 }
 export interface CreateQueryOptions<T extends Record<string, unknown>> {
-    onChange?: QueryOnChangeOptions<T>;
+    syncWithSearchParams?: boolean | QuerySearchParamsSync<T>;
 }
 export interface QueryController<T extends Record<string, unknown>> {
     data: T;
     patch: (value: Partial<T>) => void;
     reset: () => void;
-    snapshot: () => T;
-    initial: () => T;
+    createSnapshot: () => T;
+    getInitial: () => T;
+    createEffect: (callback: EffectCallback, dependencies?: readonly QueryPath<T>[]) => void;
 }
 export declare const createQuery: <T extends Record<string, unknown>>(initialValue: T, options?: CreateQueryOptions<T>) => QueryController<T>;
+export {};