@azure-net/kit 4.0.0 → 5.0.0-1

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,9 +1,10 @@
-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();
+const clientConstructionStack = [];
 const clientBootFlags = new Map();
 const getProviderCache = (providerName) => {
     if (BROWSER) {
@@ -54,6 +55,29 @@ const setBootFlag = (providerName, value) => {
         bootFlags.set(providerName, value);
     }
 };
+const getConstructionStack = () => {
+    if (BROWSER)
+        return clientConstructionStack;
+    const context = RequestContext.current();
+    return (context.data.boundaryProviderConstructionStack ??= []);
+};
+const runWithCycleGuard = (key, callback) => {
+    const stack = getConstructionStack();
+    if (stack.includes(key)) {
+        const cycleStart = stack.indexOf(key);
+        const cyclePath = [...stack.slice(cycleStart), key].join(' -> ');
+        throw new AzureNetKitInternalError(`[BoundaryProvider] Circular provider dependency detected: ${cyclePath}`);
+    }
+    stack.push(key);
+    try {
+        return callback();
+    }
+    finally {
+        const idx = stack.lastIndexOf(key);
+        if (idx !== -1)
+            stack.splice(idx, 1);
+    }
+};
 export const createBoundaryProvider = (name, settings) => {
     const { dependsOn = {}, boot, register } = settings;
     const providerFn = () => {
@@ -101,7 +125,7 @@ export const createBoundaryProvider = (name, settings) => {
                 if (typeof factory !== 'function') {
                     throw new AzureNetKitInternalError('[BoundaryProvider] Factory must be a function');
                 }
-                const instance = factory();
+                const instance = runWithCycleGuard(`${name}.${key}`, () => factory());
                 if (instance && typeof instance?.then === 'function') {
                     throw new AzureNetKitInternalError(`[BoundaryProvider] Service '${key}' in provider '${name}' returned Promise.`);
                 }

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.0.0",
+  "version": "5.0.0-1",
   "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": {
@@ -128,9 +121,9 @@
     "utils"
   ],
   "dependencies": {
-    "@azure-net/edges": "^1.2.5",
-    "@azure-net/edges-translations": "^1.2.5",
-    "@azure-net/tools": "^1.2.5"
+    "@azure-net/edges": "^1.2.7",
+    "@azure-net/edges-translations": "^1.2.7",
+    "@azure-net/tools": "^1.2.7"
   },
   "scripts": {
     "dev": "vite dev",

package/dist/core/delivery/index.js

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

package/dist/core/delivery/injectableDependencies/ErrorHandler.d.ts

@@ -1,3 +0,0 @@
-import { AppError, type IAppError } from '../../shared/appError/AppError.js';
-import type { AsyncHelperRetry } from './AsyncHelpers.js';
-export declare const createErrorHandler: <CustomData extends object>(handle?: <T = unknown>(error: AppError<T>, asyncHelperRetry: AsyncHelperRetry) => Promise<IAppError<T> & CustomData>) => <T = unknown>(error: Error, asyncHelperRetry?: AsyncHelperRetry) => Promise<IAppError<T> & CustomData>;

package/dist/core/delivery.d.ts

@@ -1,5 +0,0 @@
-export { createPresenter, createStore, createPresenterFactory, createStoreFactory, clearCache } from '../edges/index.js';
-export { createAsyncHelpers, type AsyncHelperRetry, type AsyncResourceSettings, type AsyncActionResponse } from './delivery/injectableDependencies/AsyncHelpers.js';
-export { createErrorHandler } from './delivery/injectableDependencies/ErrorHandler.js';
-export { createSchemaFactory, schema, type Schema, type RequestErrors, type ISchemaError, type ValidationResult, type ValidationRuleResult, type ValidationParams, type ValidationMessage, type ValidationErrorsMap } from './delivery/schema/Schema.js';
-export { createRules, validationMessagesRu, validationMessagesI18n, validationMessagesEn, type ValidationRuleParams, type BaseValidationMessages } from './delivery/schema/rules/index.js';

package/dist/core/delivery.js

@@ -1,5 +0,0 @@
-export { createPresenter, createStore, createPresenterFactory, createStoreFactory, clearCache } from '../edges/index.js';
-export { createAsyncHelpers } from './delivery/injectableDependencies/AsyncHelpers.js';
-export { createErrorHandler } from './delivery/injectableDependencies/ErrorHandler.js';
-export { createSchemaFactory, schema } from './delivery/schema/Schema.js';
-export { createRules, validationMessagesRu, validationMessagesI18n, validationMessagesEn } from './delivery/schema/rules/index.js';

package/dist/core/errors.d.ts

@@ -1,4 +0,0 @@
-export { AppError, ErrorTypes, AzureNetKitInternalError, type IAppError } from './shared/appError/AppError.js';
-export { HttpServiceError } from './infra/httpService/HttpServiceInstance.js';
-export { AsyncHelperError } from './delivery/injectableDependencies/AsyncHelpers.js';
-export { SchemaFail } from './delivery/schema/Schema.js';

package/dist/core/errors.js

@@ -1,4 +0,0 @@
-export { AppError, ErrorTypes, AzureNetKitInternalError } from './shared/appError/AppError.js';
-export { HttpServiceError } from './infra/httpService/HttpServiceInstance.js';
-export { AsyncHelperError } from './delivery/injectableDependencies/AsyncHelpers.js';
-export { SchemaFail } from './delivery/schema/Schema.js';

package/dist/core/index.d.ts

@@ -1,6 +0,0 @@
-export { createQuery, createAsyncSignal, createActiveForm, refreshAsyncSignal, refreshAllAsyncSignals, type AsyncSignalOptions, type AsyncSignalSvelte, type QueryController, type CreateQueryOptions, type AsyncSignalSource, type AsyncStatus } from './svelte/index.js';
-export { createMiddlewareManager, type IMiddleware } from './shared/middleware/index.js';
-export { ClassMirror } from './shared/classMirror/index.js';
-export { UniversalCookie, type CookieOptions } from './shared/cookie/index.js';
-export { createBoundaryProvider, cleanupProvider, type ProviderSettings } from './shared/boundaryProvider/index.js';
-export { AppEvents } from './shared/appEventBus/index.js';