@deessejs/functions 0.0.63 → 0.0.65

package/dist/api/index.js

@@ -1,39 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createAPI = createAPI;
-const errors_1 = require("../errors");
-const parse_1 = require("../functions/parse");
-const types_1 = require("../types");
+const query_1 = require("../functions/query");
 function createAPI(config) {
     const hydrate = (node) => {
         if (node &&
             typeof node === "object" &&
             (node._type === "query" || node._type === "mutation")) {
             const def = node;
-            return (input) => {
-                const parsed = (0, parse_1.parseArgs)(def.args, input);
-                return parsed.match({
-                    onSuccess: (data) => {
-                        return def.handler(data, config.context);
-                    },
-                    onFailure: (error) => {
-                        const ValidationError = (0, errors_1.exception)({
-                            name: "ValidationError",
-                            message: error.message,
-                        });
-                        return Promise.resolve((0, types_1.failure)(ValidationError));
-                    },
-                });
+            const api = { context: ctx };
+            const query = () => {
+                return (options) => {
+                    return (0, query_1.query)(options);
+                };
             };
+            return hydrate(config.root);
         }
-        if (node && typeof node === "object") {
-            const group = {};
-            for (const key in node) {
-                group[key] = hydrate(node[key]);
-            }
-            return group;
-        }
-        return node;
     };
-    return hydrate(config.root);
 }

package/dist/context/define.d.ts

@@ -1,8 +1,13 @@
-import { MergeExtensions } from "../extensions/types";
-export declare function defineContext<TContext extends Record<string, any>>(): {
-    withExtensions: <TExtensions extends readonly any[]>(config: {
-        extensions: readonly [...TExtensions];
-    }) => MergeExtensions<TContext, TExtensions> & {
-        context: TContext;
+import { ExtensionWithHKT, ExtractContext, MergeAPIs, TransformAPI } from "../extensions/types";
+import { UnionToIntersection } from "../utils";
+export declare const defineContext: <const InitCtx = {}>(defaultContext?: InitCtx) => {
+    withExtensions: <const Exts extends readonly ExtensionWithHKT<any>[]>(extensions: Exts) => {
+        t: MergeAPIs<Exts, InitCtx & UnionToIntersection<ExtractContext<Exts[number]>>> & {
+            router: <R>(routes: R) => R;
+        };
+        createAPI: <Root>(options: {
+            root: Root;
+            context?: InitCtx | (() => Promise<InitCtx> | InitCtx);
+        }) => TransformAPI<Root>;
     };
 };

package/dist/context/define.js

@@ -1,24 +1,47 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.defineContext = defineContext;
-function defineContext() {
-    return {
-        // any[] préserve la généricité de rpc jusqu'au bout
-        withExtensions: (config) => {
-            const runtimeBuilder = {};
-            const dummyContext = {};
-            for (const extension of config.extensions) {
-                // Cast runtime uniquement
-                const ext = extension;
-                if (ext && typeof ext.functions === "function") {
-                    const extensionMethods = ext.functions(dummyContext);
-                    Object.assign(runtimeBuilder, extensionMethods);
+exports.defineContext = void 0;
+const defineContext = (defaultContext = {}) => ({
+    withExtensions: (extensions) => {
+        // --- Runtime t ---
+        const t = extensions.reduce((acc, ext) => ({
+            ...acc,
+            ...(ext.functions ? ext.functions() : {})
+        }), { router: (r) => r });
+        // --- Runtime createAPI ---
+        const createAPI = (options) => {
+            const states = new Map();
+            extensions.forEach((e) => e.init && states.set(e.name, e.init()));
+            const getContext = async () => {
+                let base = defaultContext;
+                if (options.context) {
+                    base = typeof options.context === 'function'
+                        ? await options.context()
+                        : options.context;
+                }
+                let ctx = { ...base };
+                for (const ext of extensions) {
+                    if (ext.request) {
+                        const part = await ext.request(states.get(ext.name), ctx);
+                        ctx = { ...ctx, ...part };
+                    }
                 }
-            }
-            return {
-                ...runtimeBuilder,
-                context: {},
+                return ctx;
             };
-        },
-    };
-}
+            const activate = (node) => {
+                if (typeof node === "function")
+                    return node(getContext);
+                if (typeof node === "object" && node !== null) {
+                    const res = {};
+                    for (const k in node)
+                        res[k] = activate(node[k]);
+                    return res;
+                }
+                return node;
+            };
+            return activate(options.root);
+        };
+        return { t, createAPI };
+    },
+});
+exports.defineContext = defineContext;

package/dist/extensions/index.d.ts

@@ -1,11 +1,8 @@
-import { ZodType } from "zod";
-import { InferOptions } from "./types";
-export declare function extensions<TSchema extends ZodType | undefined = undefined, TContextAddon extends Record<string, unknown> = Record<string, unknown>, TFunctionsFactory = any>(config: {
-    name: string;
-    schema?: TSchema;
-    context?: (options: InferOptions<TSchema>) => TContextAddon;
-    functions: (options: InferOptions<TSchema>) => TFunctionsFactory;
-}): (...args: any[]) => {
-    context: TContextAddon;
-    functions: TFunctionsFactory;
+import { HKT } from "../utils/hkt";
+import { DefaultHKT, ExtensionConfig } from "./types";
+export declare const extension: <const C extends ExtensionConfig>(config: C) => C & {
+    readonly _HKT: DefaultHKT;
+};
+export declare const withKind: <Kind extends HKT>() => <Config extends ExtensionConfig>(config: Config) => Config & {
+    readonly _HKT: Kind;
 };

package/dist/extensions/index.js

@@ -1,18 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.extensions = extensions;
-// Retirez l'import de Extension et FunctionsForContext s'ils ne servent qu'au typage de retour
-function extensions(config) {
-    // SUPPRESSION DU TYPE DE RETOUR EXPLICITE ": Extension<...>"
-    // C'est ça qui causait le "unknown". On laisse TS inférer le type réel.
-    return (...args) => {
-        const optionsInput = args[0];
-        const options = (config.schema ? config.schema.parse(optionsInput) : undefined);
-        const contextPart = config.context ? config.context(options) : {};
-        const functionsBuilder = config.functions(options);
-        return {
-            context: contextPart,
-            functions: functionsBuilder,
-        };
-    };
-}
+exports.withKind = exports.extension = void 0;
+const extension = (config) => config;
+exports.extension = extension;
+// 4. Helper 'withKind'
+const withKind = () => (config) => config;
+exports.withKind = withKind;

package/dist/extensions/rpc.d.ts

@@ -1,22 +1,24 @@
 import z, { ZodType } from "zod";
 import { Exception } from "../errors/types";
 import { AsyncResult } from "../types";
-import { CommandsDefinition, MutationDefinition, QueryDefinition } from "../context/types";
-export type APINode = CommandsDefinition | {
-    [key: string]: APINode;
+import { HKT } from "../utils/hkt";
+type CoreAPI<C> = {
+    mutation: <TArgs extends ZodType<any, any, any>, TOutput, TError extends Exception>(options: {
+        args: TArgs;
+        handler: (ctx: C, args: z.infer<TArgs>) => AsyncResult<TOutput, TError>;
+    }) => (contextProvider: () => Promise<C>) => (input: z.input<TArgs>) => AsyncResult<TOutput, TError>;
 };
-export declare const rpc: (...args: any[]) => {
-    context: Record<string, unknown>;
-    functions: <C>(context: C) => {
-        query: <TArgs extends ZodType<any, any, any>, TOutput, TError extends Exception>(options: {
-            args: TArgs;
-            handler: (ctx: C, // C sera ici { user: ... }
-            args: z.core.output<TArgs>) => AsyncResult<TOutput, TError>;
-        }) => QueryDefinition<C, TArgs, TOutput, TError>;
-        mutation: <TArgs extends ZodType<any, any, any>, TOutput_1, TError_1 extends Exception>(options: {
-            args: TArgs;
-            handler: (ctx: C, args: z.core.output<TArgs>) => AsyncResult<TOutput_1, TError_1>;
-        }) => MutationDefinition<C, TArgs, TOutput_1, TError_1>;
-        group: <T extends Record<string, APINode>>(definitions: T) => T;
+interface MutationHKT extends HKT {
+    new: CoreAPI<this["_C"]>;
+}
+export declare const rpc: {
+    readonly name: "core";
+    readonly functions: <C>() => {
+        mutation: (options: any) => (contextProvider: () => Promise<C>) => (input: any) => Promise<any>;
     };
+} & {
+    readonly _HKT: import("./types").DefaultHKT;
+} & {
+    readonly _HKT: MutationHKT;
 };
+export {};

package/dist/extensions/rpc.js

@@ -1,19 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.rpc = void 0;
+const types_1 = require("../types");
 const _1 = require(".");
-exports.rpc = (0, _1.extensions)({
-    name: "rpc",
-    schema: undefined, // Pas d'options pour le moment
-    context: undefined,
-    // On garde une signature ultra-clean : <C>(context: C) => ...
-    functions: (_options) => (context) => ({
-        query: (options) => {
-            return { _type: "query", ...options };
+const parse_1 = require("../functions/parse");
+exports.rpc = (0, _1.withKind)()((0, _1.extension)({
+    name: "core",
+    functions: () => ({
+        mutation: (options) => (contextProvider) => async (input) => {
+            const parsed = (0, parse_1.parseArgs)(options.args, input);
+            return parsed.match({
+                onSuccess: async (data) => {
+                    const ctx = await contextProvider();
+                    return options.handler(ctx, data);
+                },
+                onFailure: (error) => Promise.resolve((0, types_1.failure)(error)),
+            });
         },
-        mutation: (options) => {
-            return { _type: "mutation", ...options };
-        },
-        group: (definitions) => definitions,
     }),
-});
+}));

package/dist/extensions/types.d.ts

@@ -1,4 +1,5 @@
 import z, { ZodType } from "zod";
+import { Apply, HKT } from "../utils/hkt";
 /**
  * Maintenant que F est une fonction générique "propre" (grâce à l'étape 1),
  * l'inférence directe fonctionne parfaitement.
@@ -14,4 +15,26 @@ export type ExtensionBase = {
     functions: any;
 };
 export type InferOptions<T extends ZodType | undefined> = T extends ZodType ? z.infer<T> : undefined;
+export type ExtensionConfig = {
+    name: string;
+    init?: () => any;
+    request?: (state: any, ctx: any) => any;
+    functions?: <C>() => any;
+};
+export interface DefaultHKT extends HKT {
+    readonly new: {};
+}
+export type ExtensionWithHKT<Kind extends HKT> = ExtensionConfig & {
+    readonly _HKT: Kind;
+};
+export type ExtractContext<T> = T extends {
+    request: (...args: any) => infer R;
+} ? Awaited<R> : {};
+export type GetHKT<T> = T extends {
+    _HKT: infer K;
+} ? (K extends HKT ? K : DefaultHKT) : DefaultHKT;
+export type TransformAPI<T> = T extends (ctxProvider: any) => infer Func ? Func : T extends object ? {
+    [K in keyof T]: TransformAPI<T[K]>;
+} : T;
+export type MergeAPIs<Exts extends readonly any[], Ctx> = Exts extends readonly [infer Head, ...infer Tail] ? Apply<GetHKT<Head>, Ctx> & MergeAPIs<Tail, Ctx> : {};
 export {};

package/dist/index.d.ts

@@ -1,5 +1,3 @@
-export * from "./api";
-export * from "./api/types";
 export * from "./functions";
 export * from "./types";
 export * from './extensions/rpc';

package/dist/index.js

@@ -14,8 +14,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./api"), exports);
-__exportStar(require("./api/types"), exports);
 __exportStar(require("./functions"), exports);
 __exportStar(require("./types"), exports);
 __exportStar(require("./extensions/rpc"), exports);

package/dist/utils/hkt.d.ts

@@ -0,0 +1,7 @@
+export interface HKT {
+    readonly _C: unknown;
+    readonly new: unknown;
+}
+export type Apply<F extends HKT, C> = (F & {
+    readonly _C: C;
+})["new"];

package/dist/utils/hkt.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,111 +1,111 @@
-{
-    "name": "@deessejs/functions",
-    "version": "0.0.63",
-    "description": "A powerful utility library for building type-safe APIs and functions with context management",
-    "main": "dist/index.js",
-    "types": "dist/index.d.ts",
-    "module": "dist/index.esm.js",
-    "exports": {
-        ".": {
-            "types": "./dist/index.d.ts",
-            "import": "./dist/index.esm.js",
-            "require": "./dist/index.js"
-        },
-        "./api": {
-            "types": "./dist/api.d.ts",
-            "import": "./dist/api.esm.js",
-            "require": "./dist/api.js"
-        },
-        "./checks": {
-            "types": "./dist/checks.d.ts",
-            "import": "./dist/checks.esm.js",
-            "require": "./dist/checks.js"
-        },
-        "./context": {
-            "types": "./dist/context.d.ts",
-            "import": "./dist/context.esm.js",
-            "require": "./dist/context.js"
-        },
-        "./errors": {
-            "types": "./dist/errors.d.ts",
-            "import": "./dist/errors.esm.js",
-            "require": "./dist/errors.js"
-        },
-        "./events": {
-            "types": "./dist/events.d.ts",
-            "import": "./dist/events.esm.js",
-            "require": "./dist/events.js"
-        },
-        "./functions": {
-            "types": "./dist/functions.d.ts",
-            "import": "./dist/functions.esm.js",
-            "require": "./dist/functions.js"
-        },
-        "./types": {
-            "types": "./dist/types.d.ts",
-            "import": "./dist/types.esm.js",
-            "require": "./dist/types.js"
-        }
-    },
-    "files": [
-        "dist/**/*",
-        "README.md",
-        "LICENSE"
-    ],
-    "scripts": {
-        "build": "tsc",
-        "build:watch": "tsc --watch",
-        "prepublishOnly": "npm run build",
-        "test": "vitest",
-        "test:ui": "vitest --ui",
-        "test:run": "vitest run",
-        "test:coverage": "vitest run --coverage",
-        "test:watch": "vitest watch",
-        "lint": "eslint src --ext .ts",
-        "lint:fix": "eslint src --ext .ts --fix"
-    },
-    "keywords": [
-        "typescript",
-        "api",
-        "functions",
-        "context",
-        "validation",
-        "zod",
-        "type-safe",
-        "utility"
-    ],
-    "author": "Votre Nom",
-    "license": "MIT",
-    "repository": {
-        "type": "git",
-        "url": "https://github.com/votre-organisation/deesse-api.git",
-        "directory": "packages/functions"
-    },
-    "bugs": {
-        "url": "https://github.com/votre-organisation/deesse-api/issues"
-    },
-    "homepage": "https://github.com/votre-organisation/deesse-api#readme",
-    "engines": {
-        "node": ">=16.0.0"
-    },
-    "packageManager": "pnpm@10.11.1",
-    "dependencies": {
-        "zod": "^4.1.12"
-    },
-    "devDependencies": {
-        "@testing-library/dom": "^10.4.1",
-        "@testing-library/user-event": "^14.6.1",
-        "@types/jsdom": "^27.0.0",
-        "@types/node": "^20.0.0",
-        "@types/sinon": "^21.0.0",
-        "@typescript-eslint/eslint-plugin": "^6.0.0",
-        "@typescript-eslint/parser": "^6.0.0",
-        "@vitest/coverage-v8": "^4.0.13",
-        "@vitest/ui": "^4.0.13",
-        "eslint": "^8.0.0",
-        "jsdom": "^27.2.0",
-        "sinon": "^21.0.0",
-        "typescript": "^5.0.0",
-        "vitest": "^4.0.13"
-    }
-}
+{
+    "name": "@deessejs/functions",
+    "version": "0.0.65",
+    "description": "A powerful utility library for building type-safe APIs and functions with context management",
+    "main": "dist/index.js",
+    "types": "dist/index.d.ts",
+    "module": "dist/index.esm.js",
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.ts",
+            "import": "./dist/index.esm.js",
+            "require": "./dist/index.js"
+        },
+        "./api": {
+            "types": "./dist/api.d.ts",
+            "import": "./dist/api.esm.js",
+            "require": "./dist/api.js"
+        },
+        "./checks": {
+            "types": "./dist/checks.d.ts",
+            "import": "./dist/checks.esm.js",
+            "require": "./dist/checks.js"
+        },
+        "./context": {
+            "types": "./dist/context.d.ts",
+            "import": "./dist/context.esm.js",
+            "require": "./dist/context.js"
+        },
+        "./errors": {
+            "types": "./dist/errors.d.ts",
+            "import": "./dist/errors.esm.js",
+            "require": "./dist/errors.js"
+        },
+        "./events": {
+            "types": "./dist/events.d.ts",
+            "import": "./dist/events.esm.js",
+            "require": "./dist/events.js"
+        },
+        "./functions": {
+            "types": "./dist/functions.d.ts",
+            "import": "./dist/functions.esm.js",
+            "require": "./dist/functions.js"
+        },
+        "./types": {
+            "types": "./dist/types.d.ts",
+            "import": "./dist/types.esm.js",
+            "require": "./dist/types.js"
+        }
+    },
+    "files": [
+        "dist/**/*",
+        "README.md",
+        "LICENSE"
+    ],
+    "scripts": {
+        "build": "tsc",
+        "build:watch": "tsc --watch",
+        "prepublishOnly": "npm run build",
+        "test": "vitest",
+        "test:ui": "vitest --ui",
+        "test:run": "vitest run",
+        "test:coverage": "vitest run --coverage",
+        "test:watch": "vitest watch",
+        "lint": "eslint src --ext .ts",
+        "lint:fix": "eslint src --ext .ts --fix"
+    },
+    "keywords": [
+        "typescript",
+        "api",
+        "functions",
+        "context",
+        "validation",
+        "zod",
+        "type-safe",
+        "utility"
+    ],
+    "author": "Votre Nom",
+    "license": "MIT",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/votre-organisation/deesse-api.git",
+        "directory": "packages/functions"
+    },
+    "bugs": {
+        "url": "https://github.com/votre-organisation/deesse-api/issues"
+    },
+    "homepage": "https://github.com/votre-organisation/deesse-api#readme",
+    "engines": {
+        "node": ">=16.0.0"
+    },
+    "packageManager": "pnpm@10.11.1",
+    "dependencies": {
+        "zod": "^4.1.12"
+    },
+    "devDependencies": {
+        "@testing-library/dom": "^10.4.1",
+        "@testing-library/user-event": "^14.6.1",
+        "@types/jsdom": "^27.0.0",
+        "@types/node": "^20.0.0",
+        "@types/sinon": "^21.0.0",
+        "@typescript-eslint/eslint-plugin": "^6.0.0",
+        "@typescript-eslint/parser": "^6.0.0",
+        "@vitest/coverage-v8": "^4.0.13",
+        "@vitest/ui": "^4.0.13",
+        "eslint": "^8.0.0",
+        "jsdom": "^27.2.0",
+        "sinon": "^21.0.0",
+        "typescript": "^5.0.0",
+        "vitest": "^4.0.13"
+    }
+}

package/dist/context/generated.d.ts

@@ -1,2 +0,0 @@
-export * from './index';
-export type BaseContext = Record<string, unknown>;

package/dist/context/generated.js

@@ -1,40 +0,0 @@
-"use strict";
-// This file is automatically generated by the context type generator.
-// Do not modify this file directly. It will be overwritten when new context types are generated.
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-// Import utilities for context access
-__exportStar(require("./index"), exports);
-// Generated context types will be added here by the generator
-// Example:
-// declare module "./generated" {
-//   export interface AppContext {
-//     user: null;
-//     permissions: string[];
-//     settings: {
-//       theme: string;
-//       language: string;
-//     };
-//     database: {
-//       host: string;
-//       port: number;
-//     };
-//   }
-//
-//   export type AppAPI<T extends AppContext = AppContext> = T & {
-//     __contextName: "App";
-//   };
-// }

package/dist/context/generator.d.ts

@@ -1,9 +0,0 @@
-export interface GeneratorOptions {
-    outputPath: string;
-    moduleName: string;
-    contextName: string;
-}
-export declare const generateContextDeclaration: (contextName: string, context: Record<string, unknown>) => string;
-export declare const generateContextDeclarationFile: (contextName: string, context: Record<string, unknown>) => Promise<void>;
-export declare const clearGeneratedCache: () => void;
-export declare const getGeneratedContextNames: () => string[];

package/dist/context/generator.js

@@ -1,116 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getGeneratedContextNames = exports.clearGeneratedCache = exports.generateContextDeclarationFile = exports.generateContextDeclaration = void 0;
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
-const process_1 = __importDefault(require("process"));
-// Cache pour éviter de générer plusieurs fois le même contexte
-const generatedContexts = new Set();
-const generateContextDeclaration = (contextName, context) => {
-    const properties = Object.entries(context)
-        .map(([key, value]) => {
-        const type = inferTypeFromValue(value);
-        return `  ${key}: ${type};`;
-    })
-        .join('\n');
-    return `
-declare module "${process_1.default.cwd()}/packages/functions/src/context/generated" {
-  export interface ${contextName}Context {
-${properties}
-  }
-
-  export type ${contextName}API<T extends ${contextName}Context = ${contextName}Context> = T & {
-    __contextName: "${contextName}";
-  };
-}
-`;
-};
-exports.generateContextDeclaration = generateContextDeclaration;
-const generateContextDeclarationFile = async (contextName, context) => {
-    // Vérifier si le contexte a déjà été généré
-    if (generatedContexts.has(contextName)) {
-        return;
-    }
-    const declaration = (0, exports.generateContextDeclaration)(contextName, context);
-    const outputPath = path_1.default.join(process_1.default.cwd(), 'packages', 'functions', 'src', 'context', 'generated.ts');
-    try {
-        // S'assurer que le répertoire existe
-        const dir = path_1.default.dirname(outputPath);
-        if (!fs_1.default.existsSync(dir)) {
-            fs_1.default.mkdirSync(dir, { recursive: true });
-        }
-        // Lire le contenu existant s'il existe
-        let existingContent = '';
-        if (fs_1.default.existsSync(outputPath)) {
-            existingContent = fs_1.default.readFileSync(outputPath, 'utf8');
-        }
-        // Vérifier si le fichier contient déjà notre déclaration
-        if (existingContent.includes(`__contextName: "${contextName}"`)) {
-            generatedContexts.add(contextName);
-            return;
-        }
-        // Écrire ou ajouter au fichier généré
-        const finalContent = existingContent ?
-            `${existingContent}\n\n${declaration}` :
-            declaration;
-        fs_1.default.writeFileSync(outputPath, finalContent, 'utf8');
-        generatedContexts.add(contextName);
-    }
-    catch (error) {
-        console.error(`Failed to generate context types for ${contextName}:`, error);
-        throw error;
-    }
-};
-exports.generateContextDeclarationFile = generateContextDeclarationFile;
-const clearGeneratedCache = () => {
-    generatedContexts.clear();
-};
-exports.clearGeneratedCache = clearGeneratedCache;
-const getGeneratedContextNames = () => {
-    return Array.from(generatedContexts);
-};
-exports.getGeneratedContextNames = getGeneratedContextNames;
-const inferTypeFromValue = (value) => {
-    if (value === null) {
-        return 'null';
-    }
-    if (Array.isArray(value)) {
-        if (value.length > 0) {
-            const elementType = inferTypeFromValue(value[0]);
-            return `${elementType}[]`;
-        }
-        return 'unknown[]';
-    }
-    switch (typeof value) {
-        case 'string':
-            return 'string';
-        case 'number':
-            return 'number';
-        case 'boolean':
-            return 'boolean';
-        case 'object': {
-            if (value !== null && !Array.isArray(value)) {
-                const obj = value;
-                const properties = Object.entries(obj)
-                    .map(([key, val]) => {
-                    const type = inferTypeFromValue(val);
-                    return `    ${key}: ${type};`;
-                })
-                    .join('\n');
-                return `{\n${properties}\n  }`;
-            }
-            return 'Record<string, unknown>';
-        }
-        case 'bigint':
-            return 'bigint';
-        case 'symbol':
-            return 'symbol';
-        case 'undefined':
-            return 'undefined';
-        default:
-            return 'unknown';
-    }
-};

package/dist/context/typing.d.ts

@@ -1,10 +0,0 @@
-export type ContextValidator<TContext> = (context: unknown) => context is TContext;
-export declare const createContextValidator: <TContext>(validator: ContextValidator<TContext>) => ContextValidator<TContext>;
-export declare const getValidatedContext: <TContext>(validator: ContextValidator<TContext>) => TContext;
-export declare const assertContextProperties: <TContext extends Record<string, unknown>, TKeys extends readonly (keyof TContext)[]>(keys: TKeys) => asserts keys is TKeys;
-export type AppContext = Record<string, unknown>;
-export declare const getTypedContext: <TContext extends AppContext = AppContext>() => TContext;
-export declare const getSafeTypedContext: <TContext extends AppContext = AppContext>() => TContext | null;
-export declare const assertContextProperty: <K extends keyof AppContext>(key: K) => asserts key is K;
-export declare const getContextPropertyTyped: <K extends keyof AppContext, T>(key: K) => T | undefined;
-export declare const setContextPropertyTyped: <K extends string, T>(key: K, value: T) => void;

package/dist/context/typing.js

@@ -1,60 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.setContextPropertyTyped = exports.getContextPropertyTyped = exports.assertContextProperty = exports.getSafeTypedContext = exports.getTypedContext = exports.assertContextProperties = exports.getValidatedContext = exports.createContextValidator = void 0;
-const index_1 = require("./index");
-const createContextValidator = (validator) => {
-    return validator;
-};
-exports.createContextValidator = createContextValidator;
-// Generic context access with validation
-const getValidatedContext = (validator) => {
-    const context = (0, index_1.getContext)();
-    if (validator(context)) {
-        return context;
-    }
-    throw new Error("Context validation failed");
-};
-exports.getValidatedContext = getValidatedContext;
-// Utility for partial context validation
-const assertContextProperties = (keys) => {
-    const context = (0, index_1.getContext)();
-    for (const key of keys) {
-        if (!(key in context)) {
-            throw new Error(`Required context property '${String(key)}' is missing`);
-        }
-    }
-};
-exports.assertContextProperties = assertContextProperties;
-const getTypedContext = () => {
-    return (0, index_1.getContext)();
-};
-exports.getTypedContext = getTypedContext;
-const getSafeTypedContext = () => {
-    try {
-        const context = (0, index_1.getContext)();
-        return context;
-    }
-    catch {
-        return null;
-    }
-};
-exports.getSafeTypedContext = getSafeTypedContext;
-const assertContextProperty = (key) => {
-    const context = (0, index_1.getContext)();
-    if (!(key in context)) {
-        throw new Error(`Context property '${key}' does not exist`);
-    }
-};
-exports.assertContextProperty = assertContextProperty;
-const getContextPropertyTyped = (key) => {
-    const context = (0, index_1.getContext)();
-    return context[key];
-};
-exports.getContextPropertyTyped = getContextPropertyTyped;
-const setContextPropertyTyped = (key, value) => {
-    const context = (0, index_1.getContext)();
-    const updatedContext = { ...context, [key]: value };
-    // Note: Update global context as needed
-};
-exports.setContextPropertyTyped = setContextPropertyTyped;
-// Other utilities (validator, etc.) remain unchanged...