@azure-net/kit 5.4.0 → 6.0.0-next

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

@@ -1,97 +1,106 @@
-import { untrack } from 'svelte';
-import { ObjectUtil } from '../../external/tools/index.js';
+import { replaceState } from '$app/navigation';
+import { page } from '$app/state';
+import { createEffect } from '../effect/Effect.svelte.js';
 import { cloneStateValue } from '../shared/cloneStateValue.js';
-const trackDeep = (value, seen = new WeakSet()) => {
-    if (value === null || typeof value !== 'object' || seen.has(value))
+import { fromSearchParams, toSearchParams } from './SearchParamsSync.js';
+const trackDeep = (value, seen) => {
+    if (value === null || typeof value !== 'object')
         return;
-    seen.add(value);
+    const visited = seen ?? new WeakSet();
+    if (visited.has(value))
+        return;
+    visited.add(value);
     if (Array.isArray(value)) {
         for (const item of value)
-            trackDeep(item, seen);
+            trackDeep(item, visited);
         return;
     }
     if (value instanceof Map) {
         for (const [key, item] of value) {
-            trackDeep(key, seen);
-            trackDeep(item, seen);
+            trackDeep(key, visited);
+            trackDeep(item, visited);
         }
         return;
     }
     if (value instanceof Set) {
         for (const item of value)
-            trackDeep(item, seen);
+            trackDeep(item, visited);
         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);
+    for (const key of Reflect.ownKeys(value))
+        trackDeep(Reflect.get(value, key), visited);
+};
+const readPath = (source, path) => {
+    let value = source;
+    for (const key of path.split('.')) {
+        if (value === null || typeof value !== 'object')
+            return undefined;
+        value = Reflect.get(value, key);
     }
+    return value;
+};
+const createDeepDependency = (read) => {
+    let version = 0;
+    return () => {
+        const value = read();
+        if (value === null || typeof value !== 'object')
+            return value;
+        trackDeep(value);
+        return ++version;
+    };
 };
 export const createQuery = (initialValue, options) => {
     const baseInitial = cloneStateValue(initialValue);
-    let data = $state(cloneStateValue(baseInitial));
-    const includeKeys = [...new Set(options?.onChange?.include ?? [])];
-    const hasWatch = Boolean(options?.onChange?.handler) && includeKeys.length > 0;
-    const lastSnapshots = new Map();
-    let onChangeController = null;
-    let onChangeRunId = 0;
-    if (hasWatch) {
-        includeKeys.forEach((key) => {
-            lastSnapshots.set(key, cloneStateValue(data[key]));
-        });
-        $effect(() => {
-            const changedKeys = [];
-            includeKeys.forEach((key) => {
-                const nextValue = data[key];
-                trackDeep(nextValue);
-                const nextSnapshot = cloneStateValue(nextValue);
-                if (!ObjectUtil.equals(lastSnapshots.get(key), nextSnapshot)) {
-                    changedKeys.push(key);
-                    lastSnapshots.set(key, nextSnapshot);
-                }
-            });
-            if (!changedKeys.length)
-                return;
-            const previousController = onChangeController;
-            if (previousController)
-                previousController.abort();
-            const localController = new AbortController();
-            onChangeController = localController;
-            const localRunId = ++onChangeRunId;
-            const run = async () => {
-                await options.onChange.handler({
-                    changedKeys,
-                    signal: localController.signal,
-                    snapshot: cloneStateValue(data)
-                });
-            };
-            untrack(() => {
-                void run()
-                    .catch(() => undefined)
-                    .finally(() => {
-                    if (onChangeRunId === localRunId && onChangeController === localController) {
-                        onChangeController = null;
-                    }
-                });
-            });
-        });
-        $effect(() => {
-            return () => {
-                if (onChangeController)
-                    onChangeController.abort();
-            };
-        });
-    }
+    const searchParamsSync = options?.syncWithSearchParams;
+    const syncSettings = typeof searchParamsSync === 'object' ? searchParamsSync : undefined;
+    const syncEnabled = Boolean(searchParamsSync);
+    const parseSearchParams = syncSettings?.fromSearchParams ?? (fromSearchParams);
+    const serializeSearchParams = syncSettings?.toSearchParams ?? (toSearchParams);
+    const parsedInitial = syncEnabled ? parseSearchParams(new URLSearchParams(page.url.searchParams), cloneStateValue(baseInitial)) : undefined;
+    let data = $state(parsedInitial ? { ...cloneStateValue(baseInitial), ...cloneStateValue(parsedInitial) } : cloneStateValue(baseInitial));
     const reset = () => {
         data = cloneStateValue(baseInitial);
     };
     const patch = (value) => {
         data = { ...data, ...value };
     };
-    const snapshot = () => cloneStateValue(data);
-    const initial = () => cloneStateValue(baseInitial);
+    const createSnapshot = () => cloneStateValue(data);
+    const getInitial = () => cloneStateValue(baseInitial);
+    const createQueryEffect = (callback, dependencies) => {
+        const effectDependencies = dependencies === undefined
+            ? [createDeepDependency(() => data)]
+            : [...new Set(dependencies)].map((path) => createDeepDependency(() => readPath(data, path)));
+        createEffect(callback, effectDependencies);
+    };
+    if (syncEnabled) {
+        const managedKeys = new Set(Object.keys(baseInitial));
+        const captureInitialSyncedData = () => cloneStateValue(data);
+        const initialSyncedData = captureInitialSyncedData();
+        let initialized = false;
+        createEffect(() => {
+            const nextParams = serializeSearchParams(data, baseInitial);
+            for (const key of nextParams.keys())
+                managedKeys.add(key);
+            if (!initialized) {
+                initialized = true;
+                const initialParams = serializeSearchParams(initialSyncedData, baseInitial);
+                for (const key of initialParams.keys())
+                    managedKeys.add(key);
+                if (nextParams.toString() === initialParams.toString())
+                    return;
+            }
+            const url = new URL(page.url);
+            for (const key of managedKeys)
+                url.searchParams.delete(key);
+            for (const [key, value] of nextParams)
+                url.searchParams.append(key, value);
+            if (url.search !== page.url.search)
+                replaceState(url, page.state);
+        }, [createDeepDependency(() => data)]);
+    }
     return {
         get data() {
             return data;
@@ -101,7 +110,8 @@ export const createQuery = (initialValue, options) => {
         },
         patch,
         reset,
-        snapshot,
-        initial
+        createSnapshot,
+        getInitial,
+        createEffect: createQueryEffect
     };
 };

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

@@ -0,0 +1,2 @@
+export declare const fromSearchParams: <T extends Record<string, unknown>>(params: URLSearchParams, initial: Readonly<T>) => Partial<T>;
+export declare const toSearchParams: <T extends Record<string, unknown>>(data: Readonly<T>) => URLSearchParams;

package/dist/svelte/query/SearchParamsSync.js

@@ -0,0 +1,119 @@
+const INVALID_VALUE = Symbol('invalid-query-search-param');
+const isPlainObject = (value) => {
+    if (value === null || typeof value !== 'object')
+        return false;
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+};
+const parseScalar = (value, initial) => {
+    if (typeof initial === 'string')
+        return value;
+    if (typeof initial === 'number') {
+        if (!value.trim())
+            return INVALID_VALUE;
+        const parsed = Number(value);
+        return Number.isFinite(parsed) ? parsed : INVALID_VALUE;
+    }
+    if (typeof initial === 'boolean') {
+        const normalized = value.toLowerCase();
+        if (normalized === 'true' || normalized === '1')
+            return true;
+        if (normalized === 'false' || normalized === '0')
+            return false;
+        return INVALID_VALUE;
+    }
+    if (typeof initial === 'bigint') {
+        if (!value.trim())
+            return INVALID_VALUE;
+        try {
+            return BigInt(value);
+        }
+        catch {
+            return INVALID_VALUE;
+        }
+    }
+    if (initial instanceof Date) {
+        const parsed = new Date(value);
+        return Number.isNaN(parsed.getTime()) ? INVALID_VALUE : parsed;
+    }
+    if (initial instanceof URL) {
+        try {
+            return new URL(value, initial);
+        }
+        catch {
+            return INVALID_VALUE;
+        }
+    }
+    if (initial instanceof URLSearchParams)
+        return new URLSearchParams(value);
+    if (isPlainObject(initial)) {
+        try {
+            const parsed = JSON.parse(value);
+            return isPlainObject(parsed) ? parsed : INVALID_VALUE;
+        }
+        catch {
+            return INVALID_VALUE;
+        }
+    }
+    return INVALID_VALUE;
+};
+const parseValue = (params, key, initial) => {
+    if (Array.isArray(initial)) {
+        const values = params.getAll(key);
+        if (!values.length)
+            return INVALID_VALUE;
+        if (!initial.length)
+            return values;
+        const parsed = values.map((value) => parseScalar(value, initial[0]));
+        return parsed.some((value) => value === INVALID_VALUE) ? INVALID_VALUE : parsed;
+    }
+    const value = params.get(key);
+    return value === null ? INVALID_VALUE : parseScalar(value, initial);
+};
+const serializeScalar = (value) => {
+    if (typeof value === 'string' || typeof value === 'boolean' || typeof value === 'bigint')
+        return String(value);
+    if (typeof value === 'number')
+        return Number.isFinite(value) ? String(value) : undefined;
+    if (value instanceof Date)
+        return Number.isNaN(value.getTime()) ? undefined : value.toISOString();
+    if (value instanceof URL || value instanceof URLSearchParams)
+        return value.toString();
+    if (isPlainObject(value)) {
+        try {
+            return JSON.stringify(value);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    return undefined;
+};
+export const fromSearchParams = (params, initial) => {
+    const result = {};
+    for (const key of Object.keys(initial)) {
+        if (!params.has(key))
+            continue;
+        const parsed = parseValue(params, key, initial[key]);
+        if (parsed !== INVALID_VALUE)
+            Reflect.set(result, key, parsed);
+    }
+    return result;
+};
+export const toSearchParams = (data) => {
+    const params = new URLSearchParams();
+    for (const [key, value] of Object.entries(data)) {
+        if (Array.isArray(value)) {
+            for (const item of value) {
+                const serialized = serializeScalar(item);
+                if (serialized !== undefined)
+                    params.append(key, serialized);
+            }
+            continue;
+        }
+        const serialized = serializeScalar(value);
+        if (serialized !== undefined)
+            params.set(key, serialized);
+    }
+    return params;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@azure-net/kit",
-  "version": "5.4.0",
+  "version": "6.0.0-next",
   "license": "MIT",
   "author": "Pixel1917",
   "description": "Universal toolkit and library collection, developed as part of the Azure-net ecosystem",

package/dist/delivery/injectable-dependencies/ErrorHandler.d.ts

@@ -1,7 +0,0 @@
-import { AppError, type IAppError } from '../../shared/app-error/AppError.js';
-import { AppEvents } from '../../shared/event-bus/EventBus.js';
-import type { AsyncHelperRetry } from './AsyncHelpers.js';
-export type ErrorHandlerContext = {
-    AppEvents: typeof AppEvents;
-};
-export declare const createErrorHandler: <CustomData extends object>(handle?: <T = unknown>(error: AppError<T>, asyncHelperRetry: AsyncHelperRetry, context: ErrorHandlerContext) => Promise<IAppError<T> & CustomData>) => <T = unknown>(error: Error, asyncHelperRetry?: AsyncHelperRetry) => Promise<IAppError<T> & CustomData>;

package/dist/delivery/injectable-dependencies/ErrorHandler.js

@@ -1,15 +0,0 @@
-import { AppError } from '../../shared/app-error/AppError.js';
-import { AppEvents } from '../../shared/event-bus/EventBus.js';
-export const createErrorHandler = (handle) => {
-    return async (error, asyncHelperRetry) => {
-        const appError = new AppError(error);
-        if (handle) {
-            const handled = await handle(appError, asyncHelperRetry ?? { can: false }, { AppEvents });
-            if (handled?.appErrorConvert) {
-                return handled;
-            }
-            throw new Error('Method "handle" must return result of "toPlainObject" method in AppError');
-        }
-        return appError.toPlainObject();
-    };
-};