@azure-net/kit 4.1.0 → 5.0.0-2

package/dist/shared/app/App.d.ts

@@ -0,0 +1,96 @@
+import { type ContextData } from '../../external/edges/ServerContext.js';
+import { type IServerMiddleware } from './middleware/ServerMiddleware.js';
+import type { Handle, HandleClientError, HandleServerError, RequestEvent, ServerInit } from '@sveltejs/kit';
+import { type IClientMiddleware } from './middleware/ClientMiddleware.js';
+type MaybePromise<T> = T | Promise<T>;
+type HandleInput = Parameters<Handle>[0];
+type Resolve = HandleInput['resolve'];
+type AppDependencyFactory<TApp, TReturn = unknown> = (app: TApp) => TReturn;
+type AppDependencyFactories<TApp> = Record<string, AppDependencyFactory<TApp>>;
+type ResolvedDependencies<T> = {
+    [K in keyof T]: T[K] extends (...args: never[]) => infer TReturn ? TReturn : never;
+};
+type BuilderFlags = Partial<Record<'use' | 'useClient' | 'useClientInit' | 'useClientError' | 'useServerInit' | 'useServer' | 'useServerError', true>>;
+type WithFlag<TFlags extends BuilderFlags, TKey extends keyof BuilderFlags> = TFlags & Record<TKey, true>;
+type BuilderDependencies<TBuilder> = TBuilder extends {
+    readonly __types__?: infer TDependencies;
+} ? TDependencies : never;
+type OnceMethod<TFlags extends BuilderFlags, TKey extends keyof BuilderFlags, TMethod> = TFlags[TKey] extends true ? object : TMethod;
+export type AppContainer<TDependencies extends Record<string, unknown>> = Readonly<TDependencies>;
+export interface AppUniversalLifecycleContext<TDependencies extends Record<string, unknown>> {
+    Container: AppContainer<TDependencies>;
+    isClient: boolean;
+    isServer: boolean;
+    requestContext?: ContextData;
+    event?: RequestEvent;
+}
+export interface AppClientLifecycleContext<TDependencies extends Record<string, unknown>> {
+    Container: AppContainer<TDependencies>;
+    useMiddlewares: (middlewares: IClientMiddleware[]) => void;
+}
+export interface AppClientInitLifecycleContext<TDependencies extends Record<string, unknown>> {
+    Container: AppContainer<TDependencies>;
+}
+export interface AppClientErrorContext<TDependencies extends Record<string, unknown>> extends Omit<AppClientLifecycleContext<TDependencies>, 'useMiddlewares'> {
+    error: unknown;
+    event: Parameters<HandleClientError>[0]['event'];
+    status: number;
+    message: string;
+}
+export interface AppServerInitLifecycleContext<TDependencies extends Record<string, unknown>> {
+    Container: AppContainer<TDependencies>;
+}
+export interface AppServerLifecycleContext<TDependencies extends Record<string, unknown>> {
+    Container: AppContainer<TDependencies>;
+    requestContext: ContextData;
+    event: RequestEvent;
+    resolve: Resolve;
+    useMiddlewares: (middlewares: IServerMiddleware[]) => Promise<void>;
+}
+export interface AppServerErrorContext<TDependencies extends Record<string, unknown>> {
+    Container: AppContainer<TDependencies>;
+    requestContext: ContextData;
+    error: unknown;
+    event: RequestEvent;
+    status: number;
+    message: string;
+}
+export type AppUniversalLifecycleCallback<TDependencies extends Record<string, unknown>> = (context: AppUniversalLifecycleContext<TDependencies>) => MaybePromise<void>;
+export type AppClientLifecycleCallback<TDependencies extends Record<string, unknown>> = (context: AppClientLifecycleContext<TDependencies>) => MaybePromise<void>;
+export type AppClientInitLifecycleCallback<TDependencies extends Record<string, unknown>> = (context: AppClientInitLifecycleContext<TDependencies>) => MaybePromise<void>;
+export type AppClientErrorCallback<TDependencies extends Record<string, unknown>> = (context: AppClientErrorContext<TDependencies>) => ReturnType<HandleClientError>;
+export type AppServerInitLifecycleCallback<TDependencies extends Record<string, unknown>> = (context: AppServerInitLifecycleContext<TDependencies>) => ReturnType<ServerInit>;
+export type AppServerLifecycleCallback<TDependencies extends Record<string, unknown>> = (context: AppServerLifecycleContext<TDependencies>) => MaybePromise<Response | void>;
+export type AppServerErrorCallback<TDependencies extends Record<string, unknown>> = (context: AppServerErrorContext<TDependencies>) => ReturnType<HandleServerError>;
+export type CreateAppBuilder<TDependencies extends Record<string, unknown>, TFlags extends BuilderFlags = object> = {
+    readonly __types__?: TDependencies;
+    dependencies<TNext extends AppDependencyFactories<AppContainer<TDependencies>>>(dependencies: TNext): CreateAppBuilder<TDependencies & ResolvedDependencies<TNext>, TFlags>;
+} & OnceMethod<TFlags, 'use', {
+    use(callback: AppUniversalLifecycleCallback<TDependencies>): CreateAppBuilder<TDependencies, WithFlag<TFlags, 'use'>>;
+}> & OnceMethod<TFlags, 'useClient', {
+    useClient(callback: AppClientLifecycleCallback<TDependencies>): CreateAppBuilder<TDependencies, WithFlag<TFlags, 'useClient'>>;
+}> & OnceMethod<TFlags, 'useClientInit', {
+    useClientInit(callback: AppClientInitLifecycleCallback<TDependencies>): CreateAppBuilder<TDependencies, WithFlag<TFlags, 'useClientInit'>>;
+}> & OnceMethod<TFlags, 'useClientError', {
+    useClientError(callback: AppClientErrorCallback<TDependencies>): CreateAppBuilder<TDependencies, WithFlag<TFlags, 'useClientError'>>;
+}> & OnceMethod<TFlags, 'useServerInit', {
+    useServerInit(callback: AppServerInitLifecycleCallback<TDependencies>): CreateAppBuilder<TDependencies, WithFlag<TFlags, 'useServerInit'>>;
+}> & OnceMethod<TFlags, 'useServer', {
+    useServer(callback: AppServerLifecycleCallback<TDependencies>): CreateAppBuilder<TDependencies, WithFlag<TFlags, 'useServer'>>;
+}> & OnceMethod<TFlags, 'useServerError', {
+    useServerError(callback: AppServerErrorCallback<TDependencies>): CreateAppBuilder<TDependencies, WithFlag<TFlags, 'useServerError'>>;
+}>;
+export interface AppRegistrar {
+    (): MaybePromise<void>;
+    clientInit(): MaybePromise<void>;
+    clientError: HandleClientError;
+    serverInit: ServerInit;
+    serverError: HandleServerError;
+    handle: Handle;
+}
+export interface CreateAppInstance<TDependencies extends Record<string, unknown>> {
+    Container: AppContainer<TDependencies>;
+    register: AppRegistrar;
+}
+export declare const createApp: <TBuilder>(callback: (app: CreateAppBuilder<Record<string, never>>) => TBuilder, name?: string) => CreateAppInstance<BuilderDependencies<TBuilder> & Record<string, unknown>>;
+export {};

package/dist/shared/app/App.js

@@ -0,0 +1,244 @@
+import { BROWSER } from '../../external/tools/index.js';
+import { RequestContext } from '../../external/edges/ServerContext.js';
+import { createBoundaryProvider } from '../boundary-provider/Provider.js';
+import { AzureNetKitInternalError } from '../app-error/AppError.js';
+import { executeServerMiddlewares } from './middleware/ServerMiddleware.js';
+import { beforeNavigate } from '$app/navigation';
+import { executeClientMiddlewares } from './middleware/ClientMiddleware.js';
+const DEFAULT_APP_NAME = '__AzureNetKitGlobalAppContainer__';
+const clientLifecycleFlags = new WeakMap();
+const serverInitLifecycleFlags = new WeakMap();
+const getRequestContext = () => {
+    try {
+        return RequestContext.current();
+    }
+    catch {
+        return undefined;
+    }
+};
+const getServerRequestContext = (event) => {
+    const requestContext = getRequestContext();
+    if (requestContext)
+        return requestContext;
+    if (event) {
+        return { data: {}, event };
+    }
+    throw new AzureNetKitInternalError('[createApp] RequestContext is not initialized on server.');
+};
+const getLifecycleFlags = (appKey, requestContext) => {
+    if (BROWSER) {
+        let flags = clientLifecycleFlags.get(appKey);
+        if (!flags) {
+            flags = {};
+            clientLifecycleFlags.set(appKey, flags);
+        }
+        return flags;
+    }
+    const context = requestContext ?? getRequestContext();
+    if (!context) {
+        throw new AzureNetKitInternalError('[createApp] RequestContext is not initialized on server.');
+    }
+    const flagsMap = (context.data.appLifecycleFlags ??= new WeakMap());
+    let flags = flagsMap.get(appKey);
+    if (!flags) {
+        flags = {};
+        flagsMap.set(appKey, flags);
+    }
+    return flags;
+};
+const setCallback = (callbacks, key, callback) => {
+    if (callbacks[key]) {
+        throw new AzureNetKitInternalError(`[createApp] '${key}' can be registered only once.`);
+    }
+    callbacks[key] = callback;
+};
+const createBuilder = (dependencies, callbacks) => {
+    const builder = {
+        use(callback) {
+            setCallback(callbacks, 'use', callback);
+            return builder;
+        },
+        useClient(callback) {
+            setCallback(callbacks, 'useClient', callback);
+            return builder;
+        },
+        useClientInit(callback) {
+            setCallback(callbacks, 'useClientInit', callback);
+            return builder;
+        },
+        useClientError(callback) {
+            setCallback(callbacks, 'useClientError', callback);
+            return builder;
+        },
+        useServerInit(callback) {
+            setCallback(callbacks, 'useServerInit', callback);
+            return builder;
+        },
+        useServer(callback) {
+            setCallback(callbacks, 'useServer', callback);
+            return builder;
+        },
+        useServerError(callback) {
+            setCallback(callbacks, 'useServerError', callback);
+            return builder;
+        },
+        dependencies(nextDependencies) {
+            for (const [key, factory] of Object.entries(nextDependencies)) {
+                dependencies.set(key, factory);
+            }
+            return builder;
+        }
+    };
+    return builder;
+};
+export const createApp = (callback, name = DEFAULT_APP_NAME) => {
+    const appKey = {};
+    const dependencies = new Map();
+    const callbacks = {};
+    let clientInitialized = false;
+    callback(createBuilder(dependencies, callbacks));
+    const AppProvider = createBoundaryProvider(name, {
+        register: () => {
+            const factories = {};
+            for (const [key, factory] of dependencies.entries()) {
+                factories[key] = () => factory(Container);
+            }
+            return factories;
+        }
+    });
+    const Container = new Proxy({}, {
+        get(_, key) {
+            if (typeof key === 'symbol')
+                return undefined;
+            return AppProvider()[key];
+        },
+        has(_, key) {
+            return typeof key === 'string' && key in AppProvider();
+        },
+        ownKeys() {
+            return Reflect.ownKeys(AppProvider());
+        },
+        getOwnPropertyDescriptor(_, key) {
+            if (typeof key !== 'string' || !(key in AppProvider()))
+                return undefined;
+            return {
+                configurable: true,
+                enumerable: true,
+                value: AppProvider()[key]
+            };
+        }
+    });
+    const runClient = (kind) => {
+        if (!BROWSER)
+            return undefined;
+        const flags = getLifecycleFlags(appKey);
+        if (flags[kind])
+            return undefined;
+        flags[kind] = true;
+        if (kind === 'clientInit') {
+            const universalContext = {
+                Container,
+                isClient: true,
+                isServer: false
+            };
+            const universalResult = callbacks.use?.(universalContext);
+            if (universalResult && typeof universalResult.then === 'function') {
+                return universalResult.then(() => callbacks.useClientInit?.({ Container }));
+            }
+            return callbacks.useClientInit?.({ Container });
+        }
+        let internalMiddlewares = [];
+        const clientResult = callbacks.useClient?.({
+            Container,
+            useMiddlewares: (middlewares) => {
+                internalMiddlewares = middlewares;
+            }
+        });
+        const registerNavigation = () => {
+            if (clientInitialized)
+                return;
+            clientInitialized = true;
+            beforeNavigate(async (navigation) => {
+                await executeClientMiddlewares(internalMiddlewares, navigation);
+            });
+        };
+        if (clientResult && typeof clientResult.then === 'function') {
+            return clientResult.then(registerNavigation);
+        }
+        registerNavigation();
+    };
+    const runServerInit = () => {
+        if (BROWSER)
+            return undefined;
+        let flags = serverInitLifecycleFlags.get(appKey);
+        if (!flags) {
+            flags = {};
+            serverInitLifecycleFlags.set(appKey, flags);
+        }
+        if (flags.serverInit)
+            return undefined;
+        flags.serverInit = true;
+        return callbacks.useServerInit?.({ Container });
+    };
+    const runServerError = ({ error, event, status, message }) => {
+        if (BROWSER)
+            return undefined;
+        return callbacks.useServerError?.({
+            Container,
+            requestContext: getServerRequestContext(event),
+            error,
+            event,
+            status,
+            message
+        });
+    };
+    const runClientError = ({ error, event, status, message }) => {
+        if (!BROWSER)
+            return undefined;
+        return callbacks.useClientError?.({
+            Container,
+            error,
+            event,
+            status,
+            message
+        });
+    };
+    const handle = async ({ event, resolve }) => {
+        const requestContext = getServerRequestContext(event);
+        const flags = getLifecycleFlags(appKey, requestContext);
+        if (!flags.server) {
+            flags.server = true;
+            const universalResult = callbacks.use?.({
+                Container,
+                isClient: false,
+                isServer: true,
+                requestContext,
+                event
+            });
+            if (universalResult && typeof universalResult.then === 'function') {
+                await universalResult;
+            }
+            const serverResult = await callbacks.useServer?.({
+                Container,
+                requestContext,
+                event,
+                resolve,
+                useMiddlewares: executeServerMiddlewares
+            });
+            if (serverResult)
+                return serverResult;
+        }
+        return resolve(event);
+    };
+    const register = Object.assign(() => runClient('client'), {
+        clientInit: () => runClient('clientInit'),
+        clientError: runClientError,
+        serverInit: runServerInit,
+        serverError: runServerError,
+        handle
+    });
+    return {
+        Container,
+        register
+    };
+};

package/dist/shared/app/index.d.ts

@@ -0,0 +1,4 @@
+export { createApp, type AppClientErrorCallback, type AppClientErrorContext, type AppClientInitLifecycleCallback, type AppClientInitLifecycleContext, type AppClientLifecycleCallback, type AppClientLifecycleContext, type AppContainer, type AppRegistrar, type AppServerErrorCallback, type AppServerErrorContext, type AppServerInitLifecycleCallback, type AppServerInitLifecycleContext, type AppServerLifecycleCallback, type AppServerLifecycleContext, type AppUniversalLifecycleCallback, type AppUniversalLifecycleContext, type CreateAppInstance } from './App.js';
+export type { IClientMiddleware } from './middleware/ClientMiddleware.js';
+export type { IServerMiddleware } from './middleware/ServerMiddleware.js';
+export type { RedirectStatus } from './middleware/Shared.js';

package/dist/shared/app/index.js

@@ -0,0 +1 @@
+export { createApp } from './App.js';

package/dist/shared/app/middleware/ClientMiddleware.d.ts

@@ -0,0 +1,8 @@
+import { type BeforeNavigate } from '@sveltejs/kit';
+import type { RedirectStatus } from './Shared.js';
+export type IClientMiddleware = (middlewareData: {
+    to: URL;
+    from?: URL;
+    next: (location?: string | URL, status?: RedirectStatus) => void;
+}) => Promise<void> | void;
+export declare const executeClientMiddlewares: (middlewares: IClientMiddleware[], navigation?: BeforeNavigate) => Promise<void>;

package/dist/shared/app/middleware/ClientMiddleware.js

@@ -0,0 +1,31 @@
+import {} from '@sveltejs/kit';
+import { page } from '$app/state';
+import { goto } from '$app/navigation';
+export const executeClientMiddlewares = async (middlewares, navigation) => {
+    const from = navigation?.from?.url ?? undefined;
+    const to = navigation?.to?.url ?? page?.url;
+    for (const middleware of middlewares) {
+        let shouldContinue = false;
+        const next = (location) => {
+            shouldContinue = true;
+            if (location) {
+                if (navigation) {
+                    navigation?.cancel();
+                }
+                return goto(location);
+            }
+        };
+        await middleware({
+            to,
+            from,
+            next
+        });
+        if (!shouldContinue) {
+            navigation?.cancel();
+            if (from) {
+                void goto(from.pathname);
+                console.warn('Navigation blocked: middleware chain stopped (next() not called).');
+            }
+        }
+    }
+};

package/dist/shared/app/middleware/ServerMiddleware.d.ts

@@ -0,0 +1,9 @@
+import { type RequestEvent } from '@sveltejs/kit';
+import type { RedirectStatus } from './Shared.js';
+export type IServerMiddleware = (middlewareData: {
+    to: RequestEvent['url'];
+    from?: RequestEvent['url'];
+    next: (location?: string | URL, status?: RedirectStatus) => void;
+    event?: RequestEvent;
+}) => Promise<void> | void;
+export declare const executeServerMiddlewares: (middlewares: IServerMiddleware[]) => Promise<void>;

package/dist/shared/app/middleware/ServerMiddleware.js

@@ -0,0 +1,31 @@
+import { error, redirect } from '@sveltejs/kit';
+import { BROWSER } from '../../../external/tools/index.js';
+import { RequestContext } from '../../../external/edges/ServerContext.js';
+export const executeServerMiddlewares = async (middlewares) => {
+    if (!BROWSER && middlewares.length) {
+        const event = RequestContext.current().event;
+        if (event) {
+            const referer = event?.request.headers.get('referer');
+            const from = referer ? new URL(referer) : undefined;
+            const to = event?.url;
+            for (const middleware of middlewares) {
+                let shouldContinue = false;
+                const next = (location, status = 301) => {
+                    shouldContinue = true;
+                    if (location) {
+                        return redirect(status, location);
+                    }
+                };
+                await middleware({
+                    event,
+                    to,
+                    from,
+                    next
+                });
+                if (!shouldContinue) {
+                    error(403, 'Navigation blocked: middleware chain stopped (next() not called).');
+                }
+            }
+        }
+    }
+};

package/dist/shared/app/middleware/Shared.d.ts

@@ -0,0 +1 @@
+export type RedirectStatus = 300 | 301 | 302 | 303 | 304 | 305 | 306 | 307 | 308;

package/dist/{core/shared/appError → shared/app-error}/AppError.d.ts

@@ -1,4 +1,4 @@
-import { HttpServiceError } from '../../infra/httpService/HttpServiceInstance.js';
+import { HttpServiceError } from '../../infra/http-service/HttpServiceInstance.js';
 import { type RequestErrors } from '../../delivery/schema/Schema.js';
 export declare enum ErrorTypes {
     Http = "Http",

package/dist/{core/shared/appError → shared/app-error}/AppError.js

@@ -1,6 +1,6 @@
-import { HttpErrorTypes, HttpServiceError } from '../../infra/httpService/HttpServiceInstance.js';
+import { HttpErrorTypes, HttpServiceError } from '../../infra/http-service/HttpServiceInstance.js';
 import { SchemaFail } from '../../delivery/schema/Schema.js';
-import { AsyncHelperError } from '../../delivery/injectableDependencies/AsyncHelpers.js';
+import { AsyncHelperError } from '../../delivery/injectable-dependencies/AsyncHelpers.js';
 export var ErrorTypes;
 (function (ErrorTypes) {
     ErrorTypes["Http"] = "Http";

package/dist/shared/app-error/index.d.ts

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

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

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

package/dist/{core/shared/boundaryProvider → shared/boundary-provider}/Provider.js

@@ -1,6 +1,6 @@
-import { RequestContext } from '../../../edges/context/index.js';
-import { BROWSER } from '@azure-net/tools/environment';
-import { AzureNetKitInternalError } from '../appError/AppError.js';
+import { RequestContext } from '../../external/edges/ServerContext.js';
+import { BROWSER } from '../../external/tools/index.js';
+import { AzureNetKitInternalError } from '../app-error/AppError.js';
 const clientCache = new Map();
 const factoriesCache = new WeakMap();
 const providerProxyCache = new Map();

package/dist/{core/shared → shared}/cookie/UniversalCookie.js

@@ -1,6 +1,5 @@
-import { Cookies } from '@azure-net/tools';
-import { BROWSER } from '@azure-net/tools/environment';
-import { RequestContext } from '@azure-net/edges/context';
+import { BROWSER, Cookies } from '../../external/tools/index.js';
+import { RequestContext } from '../../external/edges/ServerContext.js';
 /**
  * Utility class for managing cookies in svelte ssr (browser and server).
  * Supports setting, getting, deleting, checking, and clearing cookies.

package/dist/shared/event-bus/EventBus.d.ts

@@ -0,0 +1,2 @@
+import { EventBus } from '../../external/tools/index.js';
+export declare const AppEvents: () => EventBus<any>;

package/dist/shared/event-bus/EventBus.js

@@ -0,0 +1,6 @@
+import { EventBus } from '../../external/tools/index.js';
+import { createPresenter } from '../../external/edges/Edges.js';
+export const AppEvents = createPresenter(() => {
+    const appEventBus = new EventBus({});
+    return appEventBus;
+});

package/dist/shared/index.d.ts

@@ -0,0 +1,5 @@
+export { UniversalCookie, type CookieOptions } from './cookie/index.js';
+export { AppEvents } from './event-bus/index.js';
+export { ClassMirror } from './class-mirror/index.js';
+export { createBoundaryProvider, cleanupProvider, type ProviderSettings } from './boundary-provider/index.js';
+export { createApp, type AppContainer, type CreateAppInstance } from './app/index.js';

package/dist/shared/index.js

@@ -0,0 +1,5 @@
+export { UniversalCookie } from './cookie/index.js';
+export { AppEvents } from './event-bus/index.js';
+export { ClassMirror } from './class-mirror/index.js';
+export { createBoundaryProvider, cleanupProvider } from './boundary-provider/index.js';
+export { createApp } from './app/index.js';

package/dist/{core/svelte/ActiveForm → svelte/active-form}/ActiveForm.svelte.d.ts

@@ -1,5 +1,5 @@
 import type { RequestErrors } from '../../delivery/schema/index.js';
-import type { AsyncActionResponse } from '../../delivery/injectableDependencies/AsyncHelpers.js';
+import type { AsyncActionResponse } from '../../delivery/injectable-dependencies/AsyncHelpers.js';
 type InitialData<FormData, Initial extends Partial<FormData>> = () => Initial | Promise<Initial>;
 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/{core/svelte/ActiveForm → svelte/active-form}/ActiveForm.svelte.js

@@ -1,4 +1,4 @@
-import { ObjectUtil } from '@azure-net/tools';
+import { ObjectUtil } from '../../external/tools/index.js';
 export const createActiveForm = (onSubmit, config) => {
     const isPromise = (value) => {
         return typeof value?.then === 'function';

package/dist/{core/svelte/AsyncSignal → svelte/async-signal}/AsyncSignal.svelte.js

@@ -1,5 +1,5 @@
 import { untrack } from 'svelte';
-import { BROWSER } from '@azure-net/tools/environment';
+import { BROWSER } from '../../external/tools/index.js';
 const createAsyncSignalManager = () => {
     const instances = BROWSER ? new Map() : undefined;
     const generateUid = () => {

package/dist/svelte/index.d.ts

@@ -0,0 +1,3 @@
+export { createAsyncSignal, refreshAsyncSignal, refreshAllAsyncSignals, type AsyncSignalOptions, type AsyncSignalSvelte, type AsyncStatus, type AsyncSignalSource } from './async-signal/AsyncSignal.svelte.js';
+export { createActiveForm } from './active-form/ActiveForm.svelte.js';
+export { createQuery, type QueryController, type CreateQueryOptions } from './query/Query.svelte.js';

package/dist/svelte/index.js

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

package/dist/{core/svelte/Query → svelte/query}/Query.svelte.js

@@ -1,4 +1,4 @@
-import { ObjectUtil } from '@azure-net/tools';
+import { ObjectUtil } from '../../external/tools/index.js';
 import { untrack } from 'svelte';
 export const createQuery = (initialValue, options) => {
     const baseInitial = ObjectUtil.deepClone(initialValue);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@azure-net/kit",
-  "version": "4.1.0",
+  "version": "5.0.0-2",
   "license": "MIT",
   "author": "Pixel1917",
   "description": "Universal toolkit and library collection, developed as part of the Azure-net ecosystem",
@@ -11,7 +11,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/Pixel1917/azure-net-kit.git"
+    "url": "git+https://github.com/Pixel1917/azure-net-kit.git"
   },
   "publishConfig": {
     "access": "public",
@@ -34,49 +34,42 @@
       "svelte": "./dist/index.js"
     },
     "./infra": {
-      "types": "./dist/core/infra.d.ts",
-      "svelte": "./dist/core/infra.js"
+      "types": "./dist/infra.d.ts",
+      "svelte": "./dist/infra.js"
     },
     "./delivery": {
-      "types": "./dist/core/delivery.d.ts",
-      "svelte": "./dist/core/delivery.js"
+      "types": "./dist/delivery.d.ts",
+      "svelte": "./dist/delivery.js"
     },
     "./errors": {
-      "types": "./dist/core/errors.d.ts",
-      "svelte": "./dist/core/errors.js"
+      "types": "./dist/errors.d.ts",
+      "svelte": "./dist/errors.js"
     },
-    "./edges": {
-      "types": "./dist/edges/index.d.ts",
-      "svelte": "./dist/edges/index.js"
+    "./plugin": {
+      "types": "./dist/plugin/index.d.ts",
+      "svelte": "./dist/plugin/index.js",
+      "import": "./dist/plugin/index.js"
     },
-    "./edges/server": {
-      "types": "./dist/edges/server/index.d.ts",
-      "svelte": "./dist/edges/server/index.js"
-    },
-    "./edges/state": {
-      "types": "./dist/edges/state/index.d.ts",
-      "svelte": "./dist/edges/state/index.js"
-    },
-    "./edges/context": {
-      "types": "./dist/edges/context/index.d.ts",
-      "svelte": "./dist/edges/context/index.js"
+    "./server-context": {
+      "types": "./dist/external/edges/ServerContext.d.ts",
+      "svelte": "./dist/external/edges/ServerContext.js"
     },
     "./edges/dev": {
-      "types": "./dist/edges/dev/index.d.ts",
-      "svelte": "./dist/edges/dev/index.js"
-    },
-    "./edges/plugin": {
-      "types": "./dist/edges/plugin/index.d.ts",
-      "svelte": "./dist/edges/plugin/index.js",
-      "import": "./dist/edges/plugin/index.js"
+      "types": "./dist/external/edges/Dev.d.ts",
+      "svelte": "./dist/external/edges/Dev.js"
     },
     "./tools": {
-      "types": "./dist/tools/index.d.ts",
-      "svelte": "./dist/tools/index.js"
+      "types": "./dist/external/tools/index.d.ts",
+      "svelte": "./dist/external/tools/index.js"
     },
     "./i18n": {
-      "types": "./dist/i18n/index.d.ts",
-      "svelte": "./dist/i18n/index.js"
+      "types": "./dist/external/i18n/index.d.ts",
+      "svelte": "./dist/external/i18n/index.js"
+    },
+    "./edges/internal-package/utils": {
+      "types": "./dist/external/edges/_edges.d.ts",
+      "svelte": "./dist/external/edges/_edges.js",
+      "import": "./dist/external/edges/_edges.js"
     }
   },
   "peerDependencies": {

package/dist/core/delivery/index.js

@@ -1 +0,0 @@
-"use strict";