@azure-net/kit 6.0.0-next.5 → 6.0.0-next.7

package/README.md

@@ -68,27 +68,51 @@ import type { OrdersUseCases } from '#contexts/Orders/Application/UseCases/Order
 export class OrdersPresenter {
 	constructor(private readonly useCases: OrdersUseCases) {}
 
-	collection = () => createAsyncResource(() => this.useCases.collection());
+	collection() {
+		return createAsyncResource(() => this.useCases.collection());
+	}
 }
 
-export const useOrdersPresenter = RegisterProvider(() => {
-	const { Orders } = ApplicationProvider();
-	return new OrdersPresenter(Orders);
-}, 'scoped');
+export const useOrdersPresenter = RegisterProvider(
+	() => {
+		const { Orders } = ApplicationProvider();
+		return new OrdersPresenter(Orders);
+	},
+	{ lifecycle: 'scoped', bindMethods: true }
+);
 ```
 
 Call `useOrdersPresenter()` during component initialization, not at module scope.
 The registration itself is safe at module scope and does not resolve dependencies.
-Arrow fields remain callable after destructuring. `RegisterProvider` returns the
-actual class instance, without a proxy or automatic method binding.
+`RegisterProvider` returns the actual class instance, without a proxy. The optional
+second argument is an options object: `{ lifecycle?: ..., bindMethods?: ... }`.
+Defaults are `lifecycle: 'scoped'` and `bindMethods: false`. The old string argument
+is no longer supported. With binding disabled, methods and property descriptors are
+left untouched.
+
+Use `bindMethods: true` to bind function-valued data properties, including inherited
+methods, or `bindMethods: ['collection']` to select typed method names. Binding runs
+only after the factory returns, once for each newly created instance. Accessors are
+never evaluated or replaced, including Svelte rune accessors. Constructors and
+Object.prototype methods are excluded. A selected accessor (even one returning a
+function), missing method, or protected property throws instead of silently failing.
+TypeScript cannot distinguish a function-returning getter from a method, so the
+accessor check also happens at runtime.
+
+Method references are stable after binding. Frozen/non-extensible instances cannot
+receive inherited bound methods. Arbitrary proxies and exotic built-in objects are
+not supported binding targets. Function-valued fields are also bound with `true`;
+use an explicit list if the instance holds component constructors or other callable
+dependencies. No global cache retains instances or bound functions. Binding does not
+apply retroactively to callbacks captured during construction or methods replaced later.
 Classes using Svelte runes such as `$state` must be placed in a `.svelte.ts` module
 (or declared inside a Svelte component), not a regular `.ts` file.
 
-| Lifecycle                                  | Server                                    | Browser                       |
-| ------------------------------------------ | ----------------------------------------- | ----------------------------- |
-| `scoped` (default)                         | One instance per registration per request | New instance per call         |
-| `transient` (`trancient` is also accepted) | New instance per call                     | New instance per call         |
-| `singleton`                                | One instance per registration per request | One instance per registration |
+| Lifecycle          | Server                                    | Browser                       |
+| ------------------ | ----------------------------------------- | ----------------------------- |
+| `scoped` (default) | One instance per registration per request | New instance per call         |
+| `transient`        | New instance per call                     | New instance per call         |
+| `singleton`        | One instance per registration per request | One instance per registration |
 
 Server caching requires `AzureNetPlugin` request context and fails
 outside it. There is no process-wide server singleton. Request caches have weak

package/dist/delivery/index.d.ts

@@ -1,5 +1,5 @@
 export { createAsyncAction, createAsyncResource, type AsyncActionSettings, type AsyncHelperRetry, type AsyncResourceSettings, type AsyncActionResponse } from './injectable-dependencies/index.js';
-export { RegisterProvider, type ProviderLifecycle } from './presenter/RegisterProvider.js';
+export { RegisterProvider, type ProviderLifecycle, type RegisterProviderOptions, type ProviderMethodKey } from './presenter/RegisterProvider.js';
 export { Bound } from './presenter/Bound.js';
 export { createSchemaFactory, schema, type Schema, type RequestErrors, type ISchemaError, type ValidationResult, type ValidationRuleResult, type ValidationParams, type ValidationMessage, type ValidationErrorsMap } from './schema/index.js';
 export { createRules, validationMessagesRu, validationMessagesI18n, validationMessagesEn, type ValidationRuleParams, type BaseValidationMessages } from './schema/rules/index.js';

package/dist/delivery/presenter/RegisterProvider.d.ts

@@ -1,4 +1,11 @@
 export type ProviderLifecycle = 'scoped' | 'transient' | 'singleton';
+export type ProviderMethodKey<T> = Exclude<{
+    [K in keyof T]-?: T[K] extends (...args: never[]) => unknown ? K : never;
+}[keyof T], 'constructor'>;
+export interface RegisterProviderOptions<T> {
+    lifecycle?: ProviderLifecycle;
+    bindMethods?: boolean | readonly ProviderMethodKey<T>[];
+}
 /**
  * Registration is safe at module scope; the factory is called only by the returned accessor.
  * scoped: per request on the server, per call in the browser.
@@ -6,4 +13,4 @@ export type ProviderLifecycle = 'scoped' | 'transient' | 'singleton';
  * transient: a new instance on every call.
  * No hydration, component context, effects or disposal are managed by this function.
  */
-export declare function RegisterProvider<T extends object>(factory: () => T extends PromiseLike<unknown> ? never : T, lifecycle?: ProviderLifecycle): () => T;
+export declare function RegisterProvider<T extends object>(factory: () => T extends PromiseLike<unknown> ? never : T, options?: RegisterProviderOptions<NoInfer<T>>): () => T;

package/dist/delivery/presenter/RegisterProvider.js

@@ -1,5 +1,45 @@
 import { RequestContext } from '../../shared/request-context/Internal.js';
 import { BROWSER } from '../../external/tools/index.js';
+const bindInstanceMethods = (instance, selection) => {
+    const descriptors = new Map();
+    const selected = selection === true ? undefined : new Set(selection);
+    const seen = new Set();
+    let target = instance;
+    while (target && target !== Object.prototype && target !== Function.prototype) {
+        for (const key of selected ?? Reflect.ownKeys(target)) {
+            if (key === 'constructor' || seen.has(key))
+                continue;
+            const descriptor = Object.getOwnPropertyDescriptor(target, key);
+            if (!descriptor)
+                continue;
+            seen.add(key);
+            // Never evaluate accessors, including getters returning functions or Svelte state.
+            if ('value' in descriptor && typeof descriptor.value === 'function')
+                descriptors.set(key, descriptor);
+            else if (selected)
+                throw new TypeError(`[RegisterProvider] Cannot bind non-method ${String(key)}.`);
+        }
+        if (selected && seen.size === selected.size)
+            break;
+        target = Object.getPrototypeOf(target);
+    }
+    if (selected) {
+        for (const key of selected) {
+            if (!descriptors.has(key))
+                throw new TypeError(`[RegisterProvider] Method ${String(key)} was not found or cannot be bound.`);
+        }
+    }
+    // Validate every write before changing ordinary instances, avoiding partial binding on errors.
+    for (const key of descriptors.keys()) {
+        const own = Object.getOwnPropertyDescriptor(instance, key);
+        if (own ? !own.configurable && !own.writable : !Object.isExtensible(instance)) {
+            throw new TypeError(`[RegisterProvider] Cannot bind protected method ${String(key)}.`);
+        }
+    }
+    for (const [key, descriptor] of descriptors) {
+        Object.defineProperty(instance, key, { ...descriptor, value: Function.prototype.bind.call(descriptor.value, instance) });
+    }
+};
 /**
  * Registration is safe at module scope; the factory is called only by the returned accessor.
  * scoped: per request on the server, per call in the browser.
@@ -7,10 +47,16 @@ import { BROWSER } from '../../external/tools/index.js';
  * transient: a new instance on every call.
  * No hydration, component context, effects or disposal are managed by this function.
  */
-export function RegisterProvider(factory, lifecycle = 'scoped') {
+export function RegisterProvider(factory, options = {}) {
+    if (!options || typeof options !== 'object' || Array.isArray(options))
+        throw new TypeError('[RegisterProvider] Options must be an object.');
+    const { lifecycle = 'scoped', bindMethods = false } = options;
     if (!['scoped', 'transient', 'singleton'].includes(lifecycle)) {
         throw new TypeError(`[RegisterProvider] Unknown lifecycle: ${lifecycle}`);
     }
+    if (typeof bindMethods !== 'boolean' && !Array.isArray(bindMethods))
+        throw new TypeError('[RegisterProvider] bindMethods must be a boolean or method list.');
+    const selection = Array.isArray(bindMethods) ? [...bindMethods] : bindMethods;
     const requests = new WeakMap();
     let clientInstance;
     let constructing = false;
@@ -28,6 +74,8 @@ export function RegisterProvider(factory, lifecycle = 'scoped') {
                 void Promise.resolve(instance).catch(() => undefined);
                 throw new TypeError('[RegisterProvider] Factory must be synchronous.');
             }
+            if (selection === true || (Array.isArray(selection) && selection.length > 0))
+                bindInstanceMethods(instance, selection);
             return instance;
         }
         finally {

package/dist/i18n/Translations.svelte.js

@@ -249,6 +249,6 @@ export const createTranslations = (params) => {
                 '">')
         });
         return manager;
-    }, 'singleton');
+    }, { lifecycle: 'singleton' });
     return factory;
 };

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

@@ -19,5 +19,5 @@ export interface QueryController<T extends Record<string, unknown>> {
     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 declare const createQuery: <T extends Record<string, unknown>>(initialValue: T | (() => T), options?: CreateQueryOptions<T>) => QueryController<T>;
 export {};

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

@@ -1,5 +1,6 @@
-import { replaceState } from '$app/navigation';
+import { goto } from '$app/navigation';
 import { page } from '$app/state';
+import { untrack } from 'svelte';
 import { createEffect } from '../effect/Effect.svelte.js';
 import { cloneStateValue } from '../shared/cloneStateValue.js';
 import { fromSearchParams, toSearchParams } from './SearchParamsSync.js';
@@ -53,14 +54,15 @@ const createDeepDependency = (read) => {
     };
 };
 export const createQuery = (initialValue, options) => {
-    const baseInitial = cloneStateValue(initialValue);
+    // Capture defaults once; reset restores this snapshot rather than rerunning the initializer.
+    const baseInitial = untrack(() => cloneStateValue(typeof initialValue === 'function' ? initialValue() : initialValue));
     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.toString()), cloneStateValue(baseInitial))
+        ? parseSearchParams(new URLSearchParams((page.shallow?.url ?? page.url).searchParams.toString()), cloneStateValue(baseInitial))
         : undefined;
     let data = $state(parsedInitial ? { ...cloneStateValue(baseInitial), ...cloneStateValue(parsedInitial) } : cloneStateValue(baseInitial));
     const reset = () => {
@@ -94,13 +96,17 @@ export const createQuery = (initialValue, options) => {
                 if (nextParams.toString() === initialParams.toString())
                     return;
             }
-            const url = new URL(page.url.href);
+            const currentUrl = page.shallow?.url ?? page.url;
+            const url = new URL(currentUrl.href);
             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);
+            if (url.search !== currentUrl.search) {
+                void goto(url, { state: page.state, shallow: true, replace: true, reset: false }).catch((error) => {
+                    console.error('[createQuery] Failed to synchronize search parameters', error);
+                });
+            }
         }, [createDeepDependency(() => data)]);
     }
     return {

package/package.json

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