@azure-net/kit 6.0.0-next.1 → 6.0.0-next.2

package/dist/i18n/Translations.svelte.js

@@ -0,0 +1,254 @@
+import { bindTranslationLifecycle } from './Internal.js';
+import { RegisterProvider } from '../delivery/presenter/RegisterProvider.js';
+import { Cookies, TextUtil, BROWSER } from '../external/tools/index.js';
+import { RequestContext } from '../shared/request-context/Internal.js';
+const PLURAL_PATTERN = /{{\s*(\w+)\s*\|\s*plural\s*:(.*?)}}/g;
+const VARIABLE_PATTERN = /{{\s*(\w+)\s*}}/g;
+const normalizeLocale = (locale) => locale.trim().replaceAll('_', '-').toLowerCase();
+const parseAcceptLanguage = (value) => {
+    if (!value)
+        return [];
+    return value
+        .split(',')
+        .map((part, index) => {
+        const [locale = '', ...parameters] = part.trim().split(';');
+        const qualityParameter = parameters.find((parameter) => parameter.trim().toLowerCase().startsWith('q='));
+        const quality = qualityParameter ? Number(qualityParameter.split('=')[1]) : 1;
+        return { locale: locale.trim(), quality: Number.isFinite(quality) ? quality : 0, index };
+    })
+        .filter(({ locale, quality }) => locale.length > 0 && quality > 0)
+        .sort((left, right) => right.quality - left.quality || left.index - right.index)
+        .map(({ locale }) => locale);
+};
+export const createTranslations = (params) => {
+    const snapshotKey = params.prefix ?? 'default';
+    const availableLocales = Object.keys(params.messages);
+    const locales = Object.freeze(Object.fromEntries(availableLocales.map((locale) => [locale, locale])));
+    if (!Object.hasOwn(params.messages, params.initLang))
+        throw new Error('[AzureNetKit:i18n] initLang must exist in messages.');
+    const normalizedLocales = new Map();
+    const localeVariants = new Map();
+    for (const locale of availableLocales) {
+        const normalized = normalizeLocale(locale);
+        const base = normalized.split('-')[0];
+        normalizedLocales.set(normalized, locale);
+        if (base && !localeVariants.has(base))
+            localeVariants.set(base, locale);
+    }
+    const resolveLocale = (locale) => {
+        if (!locale)
+            return undefined;
+        const normalized = normalizeLocale(locale);
+        if (!normalized)
+            return undefined;
+        const exact = normalizedLocales.get(normalized);
+        if (exact)
+            return exact;
+        const base = normalized.split('-')[0];
+        return base ? (normalizedLocales.get(base) ?? localeVariants.get(base)) : undefined;
+    };
+    const factory = RegisterProvider(() => {
+        const translations = new Map();
+        const pendingLoads = new Map();
+        const localeListeners = new Set();
+        let locale = $state.raw(params.initLang);
+        let activeMessages = $state.raw({});
+        let synchronized = false;
+        let initializationPromise;
+        let switchRevision = 0;
+        const loadTranslation = (requestedLocale) => {
+            const resolvedLocale = resolveLocale(requestedLocale);
+            if (!resolvedLocale) {
+                return Promise.reject(new Error(`[AzureNetKit:i18n] Locale "${requestedLocale}" is not present in messages.`));
+            }
+            const cached = translations.get(resolvedLocale);
+            if (cached)
+                return Promise.resolve(cached);
+            const pending = pendingLoads.get(resolvedLocale);
+            if (pending)
+                return pending;
+            const request = Promise.resolve()
+                .then(() => params.messages[resolvedLocale]())
+                .then((loaded) => {
+                // Imported dictionaries are module-cached; request state must not expose that shared object.
+                const messages = BROWSER ? loaded : structuredClone(loaded);
+                translations.set(resolvedLocale, messages);
+                return messages;
+            })
+                .finally(() => {
+                if (pendingLoads.get(resolvedLocale) === request)
+                    pendingLoads.delete(resolvedLocale);
+            });
+            pendingLoads.set(resolvedLocale, request);
+            return request;
+        };
+        const getLocaleFromRequest = () => {
+            const event = RequestContext.current().event;
+            if (!event)
+                throw new Error('[AzureNetKit:i18n] RequestContext has no RequestEvent.');
+            const cookieLocale = params.cookieName ? resolveLocale(event.cookies.get(params.cookieName)) : undefined;
+            if (cookieLocale)
+                return cookieLocale;
+            if (params.initLangFromAcceptLanguage) {
+                for (const requestedLocale of parseAcceptLanguage(event.request.headers.get('accept-language'))) {
+                    if (requestedLocale === '*')
+                        return params.initLang;
+                    const resolvedLocale = resolveLocale(requestedLocale);
+                    if (resolvedLocale)
+                        return resolvedLocale;
+                }
+            }
+            return params.initLang;
+        };
+        const preloadTranslation = async (resolver) => {
+            if (BROWSER)
+                throw new Error('[AzureNetKit:i18n] preloadTranslation() is server-only.');
+            const revision = ++switchRevision;
+            const requestedLocale = resolver ? await resolver() : getLocaleFromRequest();
+            const resolvedLocale = resolveLocale(requestedLocale) ?? params.initLang;
+            const messages = await loadTranslation(resolvedLocale);
+            if (revision !== switchRevision)
+                return;
+            locale = resolvedLocale;
+            activeMessages = messages;
+            const state = RequestContext.current().state;
+            state.currLocale = resolvedLocale;
+            const snapshots = (state.i18n ??= {});
+            Object.defineProperty(snapshots, snapshotKey, { value: { locale }, enumerable: true, configurable: true, writable: true });
+        };
+        const getTranslation = (messageKey) => {
+            let current = activeMessages;
+            for (const key of messageKey.split('.')) {
+                if (typeof current === 'string' || !current || !Object.hasOwn(current, key))
+                    return undefined;
+                current = current[key];
+            }
+            return typeof current === 'string' ? current : undefined;
+        };
+        const translate = (messageKey, vars = {}) => {
+            let result = getTranslation(messageKey);
+            if (result === undefined)
+                return messageKey;
+            if (!result.includes('{{'))
+                return result;
+            result = result.replace(PLURAL_PATTERN, (_, variableName, titlesString) => {
+                const count = Number(vars[variableName]);
+                if (Number.isNaN(count)) {
+                    console.warn(`[AzureNetKit:i18n] Plural variable "${variableName}" is not numeric.`);
+                    return '';
+                }
+                return TextUtil.pluralize(count, titlesString.split(',').map((title) => title.trim()));
+            });
+            return result.replace(VARIABLE_PATTERN, (_, key) => (vars[key] === undefined ? '' : String(vars[key])));
+        };
+        const t = (translation, vars) => {
+            if (!translation)
+                return '';
+            const extended = typeof translation === 'object' ? translation : undefined;
+            return translate(String(extended?.key ?? translation), extended?.vars ?? vars);
+        };
+        const syncFromState = (state) => {
+            if (synchronized)
+                return;
+            const snapshot = state.i18n && Object.hasOwn(state.i18n, snapshotKey) ? state.i18n[snapshotKey] : undefined;
+            const nextLocale = resolveLocale(snapshot?.locale ?? state.currLocale);
+            if (snapshot && !nextLocale)
+                throw new Error('[AzureNetKit:i18n] Unsupported boot locale.');
+            synchronized = true;
+            ++switchRevision;
+            initializationPromise = undefined;
+            if (nextLocale)
+                locale = nextLocale;
+            activeMessages = translations.get(locale) ?? {};
+        };
+        const updateHtmlLocale = (currentLocale) => {
+            document.documentElement.lang = currentLocale;
+        };
+        const initializeClient = () => {
+            if (!BROWSER)
+                return Promise.resolve();
+            if (initializationPromise)
+                return initializationPromise;
+            // SSR marker is available before SvelteKit starts hydration; boot runs later.
+            const serverLocale = document.documentElement.getAttribute('data-azure-net-locale');
+            locale =
+                resolveLocale(serverLocale ?? undefined) ??
+                    resolveLocale((params.cookieName ? Cookies.get(params.cookieName) : undefined) ?? undefined) ??
+                    (params.initLangFromAcceptLanguage ? navigator.languages.map(resolveLocale).find(Boolean) : undefined) ??
+                    locale;
+            const revision = switchRevision;
+            const request = loadTranslation(locale)
+                .then((messages) => {
+                if (revision !== switchRevision) {
+                    if (initializationPromise === request)
+                        initializationPromise = undefined;
+                    return;
+                }
+                activeMessages = messages;
+                updateHtmlLocale(locale);
+            })
+                .catch((error) => {
+                if (initializationPromise === request)
+                    initializationPromise = undefined;
+                throw error;
+            });
+            initializationPromise = request;
+            return request;
+        };
+        const switchLocale = async (requestedLocale) => {
+            if (!BROWSER)
+                throw new Error('[AzureNetKit:i18n] switchLocale() is client-only.');
+            const resolvedLocale = resolveLocale(requestedLocale);
+            if (!resolvedLocale)
+                throw new Error(`[AzureNetKit:i18n] Locale "${requestedLocale}" is not present in messages.`);
+            const revision = ++switchRevision;
+            const messages = await loadTranslation(resolvedLocale);
+            if (revision !== switchRevision)
+                return;
+            locale = resolvedLocale;
+            activeMessages = messages;
+            if (params.cookieName) {
+                Cookies.set(params.cookieName, resolvedLocale, {
+                    path: '/',
+                    sameSite: 'Lax',
+                    ...params.cookieOptions
+                });
+            }
+            updateHtmlLocale(resolvedLocale);
+            for (const listener of localeListeners)
+                listener(resolvedLocale);
+        };
+        const subscribeLocaleChangeEvent = (listener) => {
+            if (!BROWSER)
+                throw new Error('[AzureNetKit:i18n] Locale change events are client-only.');
+            localeListeners.add(listener);
+            return () => localeListeners.delete(listener);
+        };
+        const applyHtmlLocaleAttr = (html) => html.replaceAll('%lang%', () => locale);
+        const manager = {
+            switchLocale,
+            applyHtmlLocaleAttr,
+            subscribeLocaleChangeEvent,
+            t,
+            get locale() {
+                return locale;
+            },
+            locales
+        };
+        const escapeAttribute = (value) => value.replaceAll('&', '&amp;').replaceAll('"', '&quot;').replaceAll('<', '&lt;').replaceAll('>', '&gt;');
+        bindTranslationLifecycle(manager, {
+            preloadTranslation,
+            initializeClient,
+            syncFromState,
+            transformHtml: (html) => applyHtmlLocaleAttr(html).replace(/<html\b([^>]*)>/i, (_, attrs) => '<html' +
+                attrs.replace(/\s+(?:data-azure-net-locale|lang)\s*=\s*(?:"[^"]*"|'[^']*'|[^\s>]+)/gi, '') +
+                ' lang="' +
+                escapeAttribute(locale) +
+                '" data-azure-net-locale="' +
+                escapeAttribute(locale) +
+                '">')
+        });
+        return manager;
+    }, 'singleton');
+    return factory;
+};

package/dist/i18n/Types.d.ts

@@ -0,0 +1,30 @@
+export interface TranslationSnapshot {
+    locale: string;
+}
+declare global {
+    namespace App {
+        interface RequestContextState {
+            currLocale?: string;
+            i18n?: Record<string, TranslationSnapshot>;
+        }
+    }
+}
+export type Translation = string | {
+    [key: string]: Translation;
+};
+export type TranslationShape<T> = T extends string ? string : T extends Record<string, unknown> ? {
+    [K in keyof T]: TranslationShape<T[K]>;
+} : never;
+export type Path<T, Prefix extends string = '', Depth extends unknown[] = []> = T extends string ? never : T extends Record<string, unknown> ? {
+    [K in keyof T & string]: T[K] extends string ? `${Prefix}${K}` : Depth['length'] extends 12 ? `${Prefix}${K}.${string}` : Path<T[K], `${Prefix}${K}.`, [...Depth, unknown]>;
+}[keyof T & string] : never;
+export interface TranslationCookieOptions {
+    expires?: Date | number;
+    maxAge?: number;
+    path?: string;
+    domain?: string;
+    secure?: boolean;
+    sameSite?: 'Strict' | 'Lax' | 'None';
+}
+export type MessageLoader = () => Promise<Translation>;
+export type TranslationVariables = Record<string, unknown>;

package/dist/i18n/Types.js

@@ -0,0 +1 @@
+export {};

package/dist/i18n/index.d.ts

@@ -0,0 +1,2 @@
+export { createTranslations } from './Translations.svelte.js';
+export type { Translation, TranslationShape, TranslationSnapshot, TranslationCookieOptions, Path } from './Types.js';

package/dist/i18n/index.js

@@ -0,0 +1 @@
+export { createTranslations } from './Translations.svelte.js';

package/dist/infra/datasource/BaseDatasource.d.ts

@@ -1,16 +1,29 @@
-import { type IHttpServiceInstance, type IHttpServiceResponse } from '../http-service/HttpServiceInstance.js';
-import { type IQueryBuilderInstance } from '../query/index.js';
+import { type IHttpInstanceOptions, type IHttpServiceInstance, type IHttpServiceResponse } from '../http-service/HttpServiceInstance.js';
+import { type IQueryBuilderInstance, type IQueryBuilderSettings } from '../query/index.js';
 export type CreateRequestCallbackType<T> = (params: {
     http: IHttpServiceInstance;
     query: IQueryBuilderInstance;
 }) => Promise<IHttpServiceResponse<T>>;
+type HttpClientParams = {
+    http: IHttpServiceInstance;
+    httpOptions?: never;
+} | {
+    http?: never;
+    httpOptions?: IHttpInstanceOptions;
+};
+type QueryBuilderParams = {
+    query: IQueryBuilderInstance;
+    queryOptions?: never;
+} | {
+    query?: never;
+    queryOptions?: IQueryBuilderSettings;
+};
+type DatasourceParams = HttpClientParams & QueryBuilderParams;
 export declare class BaseHttpDatasource {
     protected readonly httpClient: IHttpServiceInstance;
     protected readonly query: IQueryBuilderInstance;
-    constructor(params: {
-        http?: IHttpServiceInstance;
-        query?: IQueryBuilderInstance;
-    });
+    constructor(params: DatasourceParams);
     private _createRawRequest;
     readonly createRawRequest: <T>(callback: CreateRequestCallbackType<T>) => Promise<IHttpServiceResponse<T>>;
 }
+export {};

package/dist/infra/datasource/BaseDatasource.js

@@ -1,11 +1,11 @@
-import { createHttpServiceInstance } from '../http-service/HttpServiceInstance.js';
-import { createQueryInstance } from '../query/index.js';
+import { HttpServiceInstance } from '../http-service/HttpServiceInstance.js';
+import { QueryBuilder } from '../query/index.js';
 export class BaseHttpDatasource {
     httpClient;
     query;
     constructor(params) {
-        this.httpClient = params.http ?? createHttpServiceInstance();
-        this.query = params.query ?? createQueryInstance();
+        this.httpClient = params.http ?? new HttpServiceInstance(params?.httpOptions);
+        this.query = params.query ?? new QueryBuilder(params?.queryOptions);
     }
     _createRawRequest(callback) {
         return callback({ http: this.httpClient, query: this.query });

package/dist/infra/http-service/HttpServiceInstance.d.ts

@@ -47,7 +47,7 @@ export declare class HttpServiceError<T> extends Error implements IHttpServiceEr
     response?: Response;
     constructor({ status, data, message, original, type, response }: Partial<IHttpServiceError<T>>);
 }
-export interface HttpInstanceNormalizedRequest {
+export interface IHttpInstanceNormalizedRequest {
     url: string | URL;
     method: HttpInstanceFetchMethods;
     headers: Headers;
@@ -60,9 +60,9 @@ export interface HttpInstanceNormalizedRequest {
     fetch: typeof fetch;
     requestInit: Omit<RequestInit, 'method' | 'headers' | 'body'>;
 }
-export type HttpInstanceOnRequest = (request: HttpInstanceNormalizedRequest) => void | Promise<void>;
-export type HttpInstanceOnError = (error: HttpServiceError<unknown>, request: HttpInstanceNormalizedRequest) => void | Promise<void>;
-export type HttpInstanceDoFetch = <T = unknown>(request: HttpInstanceNormalizedRequest) => Promise<IHttpServiceResponse<T>>;
+export type IHttpInstanceOnRequest = (request: IHttpInstanceNormalizedRequest) => void | Promise<void>;
+export type IHttpInstanceOnError = (error: HttpServiceError<unknown>, request: IHttpInstanceNormalizedRequest) => void | Promise<void>;
+export type IHttpInstanceDoFetch = <T = unknown>(request: IHttpInstanceNormalizedRequest) => Promise<IHttpServiceResponse<T>>;
 export interface IHttpInstanceOptions<T = unknown> extends Omit<RequestInit, 'headers' | 'method'> {
     headers?: NonNullable<RequestInit['headers']> | Record<string, string | undefined>;
     json?: unknown;
@@ -73,19 +73,29 @@ export interface IHttpInstanceOptions<T = unknown> extends Omit<RequestInit, 'he
     retry?: number;
     includeRaw?: boolean;
     responseFormat?: 'json' | 'blob' | 'text' | 'arrayBuffer' | 'body';
-    onRequest?: HttpInstanceOnRequest;
-    onError?: HttpInstanceOnError;
+    onRequest?: IHttpInstanceOnRequest;
+    onError?: IHttpInstanceOnError;
     onResponse?: (response: IHttpServiceResponse<T>) => void | Promise<void>;
-    doFetch?: HttpInstanceDoFetch;
+    doFetch?: IHttpInstanceDoFetch;
 }
-export type HttpInstanceRequestMethod = <T = unknown>(url: string | URL, options?: IHttpInstanceOptions<T>) => Promise<IHttpServiceResponse<T>>;
+export type IHttpInstanceRequestMethod = <T = unknown>(url: string | URL, options?: IHttpInstanceOptions<T>) => Promise<IHttpServiceResponse<T>>;
 export interface IHttpServiceInstance {
-    get: HttpInstanceRequestMethod;
-    post: HttpInstanceRequestMethod;
-    put: HttpInstanceRequestMethod;
-    delete: HttpInstanceRequestMethod;
-    patch: HttpInstanceRequestMethod;
-    head: HttpInstanceRequestMethod;
-    options: HttpInstanceRequestMethod;
+    get: IHttpInstanceRequestMethod;
+    post: IHttpInstanceRequestMethod;
+    put: IHttpInstanceRequestMethod;
+    delete: IHttpInstanceRequestMethod;
+    patch: IHttpInstanceRequestMethod;
+    head: IHttpInstanceRequestMethod;
+    options: IHttpInstanceRequestMethod;
+}
+export declare class HttpServiceInstance implements IHttpServiceInstance {
+    private readonly defaults;
+    readonly get: IHttpInstanceRequestMethod;
+    readonly post: IHttpInstanceRequestMethod;
+    readonly put: IHttpInstanceRequestMethod;
+    readonly delete: IHttpInstanceRequestMethod;
+    readonly patch: IHttpInstanceRequestMethod;
+    readonly head: IHttpInstanceRequestMethod;
+    readonly options: IHttpInstanceRequestMethod;
+    constructor(config?: IHttpInstanceOptions);
 }
-export declare const createHttpServiceInstance: (config?: IHttpInstanceOptions) => IHttpServiceInstance;

package/dist/infra/http-service/HttpServiceInstance.js

@@ -1,5 +1,5 @@
 import { BROWSER } from '../../external/tools/index.js';
-import { RequestContext } from '../../external/edges/ServerContext.js';
+import { RequestContext } from '../../shared/request-context/Internal.js';
 export var HttpInstanceFetchMethods;
 (function (HttpInstanceFetchMethods) {
     HttpInstanceFetchMethods["GET"] = "GET";
@@ -344,15 +344,23 @@ const makeMethod = (method, defaults) => {
         }
     };
 };
-export const createHttpServiceInstance = (config = {}) => {
-    const defaults = { ...config };
-    return {
-        get: makeMethod(HttpInstanceFetchMethods.GET, defaults),
-        post: makeMethod(HttpInstanceFetchMethods.POST, defaults),
-        put: makeMethod(HttpInstanceFetchMethods.PUT, defaults),
-        delete: makeMethod(HttpInstanceFetchMethods.DELETE, defaults),
-        patch: makeMethod(HttpInstanceFetchMethods.PATCH, defaults),
-        head: makeMethod(HttpInstanceFetchMethods.HEAD, defaults),
-        options: makeMethod(HttpInstanceFetchMethods.OPTIONS, defaults)
-    };
-};
+export class HttpServiceInstance {
+    defaults;
+    get;
+    post;
+    put;
+    delete;
+    patch;
+    head;
+    options;
+    constructor(config = {}) {
+        this.defaults = { ...config };
+        this.get = makeMethod(HttpInstanceFetchMethods.GET, this.defaults);
+        this.post = makeMethod(HttpInstanceFetchMethods.POST, this.defaults);
+        this.put = makeMethod(HttpInstanceFetchMethods.PUT, this.defaults);
+        this.delete = makeMethod(HttpInstanceFetchMethods.DELETE, this.defaults);
+        this.patch = makeMethod(HttpInstanceFetchMethods.PATCH, this.defaults);
+        this.head = makeMethod(HttpInstanceFetchMethods.HEAD, this.defaults);
+        this.options = makeMethod(HttpInstanceFetchMethods.OPTIONS, this.defaults);
+    }
+}

package/dist/infra/index.d.ts

@@ -1,5 +1,5 @@
 export { BaseHttpDatasource, type CreateRequestCallbackType } from './datasource/index.js';
 export { DTOMapper, type IDTOMapper } from './resource/index.js';
-export { HttpStatusCode, createHttpServiceInstance, HttpInstanceFetchMethods, HttpErrorTypes, HttpServiceResponse, HttpServiceError, type IHttpServiceError, type IHttpServiceResponse, type IHttpServiceInstance, type IHttpInstanceOptions, type HttpInstanceNormalizedRequest, type HttpInstanceOnRequest, type HttpInstanceOnError, type HttpInstanceDoFetch, type HttpInstanceRequestMethod } from './http-service/index.js';
+export { HttpStatusCode, HttpServiceInstance, HttpInstanceFetchMethods, HttpErrorTypes, HttpServiceResponse, HttpServiceError, type IHttpServiceError, type IHttpServiceResponse, type IHttpServiceInstance, type IHttpInstanceOptions, type IHttpInstanceNormalizedRequest, type IHttpInstanceOnRequest, type IHttpInstanceOnError, type IHttpInstanceDoFetch, type IHttpInstanceRequestMethod } from './http-service/index.js';
 export { ResponseBuilder } from './response/index.js';
-export { createQueryInstance, type IQueryBuilderInstance, type ArrayFormat, type ObjectFormat, type IQueryBuilderSettings } from './query/QueryBuilder.js';
+export { QueryBuilder, type IQueryBuilderInstance, type ArrayFormat, type ObjectFormat, type IQueryBuilderSettings } from './query/QueryBuilder.js';

package/dist/infra/index.js

@@ -1,5 +1,5 @@
 export { BaseHttpDatasource } from './datasource/index.js';
 export { DTOMapper } from './resource/index.js';
-export { HttpStatusCode, createHttpServiceInstance, HttpInstanceFetchMethods, HttpErrorTypes, HttpServiceResponse, HttpServiceError } from './http-service/index.js';
+export { HttpStatusCode, HttpServiceInstance, HttpInstanceFetchMethods, HttpErrorTypes, HttpServiceResponse, HttpServiceError } from './http-service/index.js';
 export { ResponseBuilder } from './response/index.js';
-export { createQueryInstance } from './query/QueryBuilder.js';
+export { QueryBuilder } from './query/QueryBuilder.js';

package/dist/infra/query/QueryBuilder.d.ts

@@ -10,4 +10,9 @@ export interface IQueryBuilderInstance<TTransformInput extends object = object>
     toString: (query: object, settings?: IQueryBuilderSettings<TTransformInput>) => string;
     toSearchParams: (query: object, settings?: Omit<IQueryBuilderSettings<TTransformInput>, 'delimiter'>) => URLSearchParams;
 }
-export declare const createQueryInstance: <TTransformInput extends object = object>(defaults?: IQueryBuilderSettings<TTransformInput>) => IQueryBuilderInstance<TTransformInput>;
+export declare class QueryBuilder<TTransformInputGlobal extends object = object> implements IQueryBuilderInstance<TTransformInputGlobal> {
+    private readonly defaults;
+    constructor(config?: IQueryBuilderSettings<TTransformInputGlobal>);
+    readonly toSearchParams: <TTransformInput extends TTransformInputGlobal = TTransformInputGlobal>(query: object, settings?: Omit<IQueryBuilderSettings<TTransformInput>, "delimiter">) => URLSearchParams;
+    readonly toString: <TTransformInput extends TTransformInputGlobal = TTransformInputGlobal>(query: object, settings?: IQueryBuilderSettings<TTransformInput>) => string;
+}

package/dist/infra/query/QueryBuilder.js

@@ -75,16 +75,18 @@ const toSearchParamsWithSettings = (query, settings) => {
     }
     return params;
 };
-export const createQueryInstance = (defaults) => {
-    return {
-        toSearchParams: (query, settings) => {
-            const resolved = normalizeSettings(defaults, settings);
-            return toSearchParamsWithSettings(query, resolved);
-        },
-        toString: (query, settings) => {
-            const resolved = normalizeSettings(defaults, settings);
-            const serialized = encodeQuery(Array.from(toSearchParamsWithSettings(query, resolved).entries()));
-            return resolved.delimiter && serialized ? `?${serialized}` : serialized;
-        }
+export class QueryBuilder {
+    defaults;
+    constructor(config) {
+        this.defaults = { ...config };
+    }
+    toSearchParams = (query, settings) => {
+        const resolved = normalizeSettings(this.defaults, settings);
+        return toSearchParamsWithSettings(query, resolved);
     };
-};
+    toString = (query, settings) => {
+        const resolved = normalizeSettings(this.defaults, settings);
+        const serialized = encodeQuery(Array.from(toSearchParamsWithSettings(query, resolved).entries()));
+        return resolved.delimiter && serialized ? `?${serialized}` : serialized;
+    };
+}

package/dist/plugin/AzureNetPlugin.d.ts

@@ -1,5 +1,2 @@
 import type { Plugin } from 'vite';
-export interface AzureNetPluginOptions {
-    silentChromeDevtools?: boolean;
-}
-export declare const AzureNetPlugin: (options?: AzureNetPluginOptions) => Plugin;
+export declare const AzureNetPlugin: () => Plugin;