@azure-net/kit 5.2.0 → 5.3.0

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/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/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.3.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 ."
   }