@deessejs/functions 0.0.36 → 0.0.37

package/dist/context/define.js

@@ -1,17 +1,21 @@
 "use strict";
+// defineContext.ts
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.defineContext = defineContext;
 function defineContext() {
     return {
         withExtensions: (config) => {
-            const builder = {};
+            // runtime builder (inchangé)
+            const runtimeBuilder = {};
             const dummyContext = {};
             for (const extension of config.extensions) {
+                // appele runtime, pour construire les méthodes effectives
                 const extensionMethods = extension.functions(dummyContext);
-                Object.assign(builder, extensionMethods);
+                Object.assign(runtimeBuilder, extensionMethods);
             }
+            // On retourne runtimeBuilder mais on force le type public attendu.
             return {
-                ...builder,
+                ...runtimeBuilder,
                 context: {},
             };
         },

package/dist/extensions/index.js

@@ -5,9 +5,7 @@ function extensions(config) {
     return (...args) => {
         const optionsInput = args[0];
         const options = (config.schema ? config.schema.parse(optionsInput) : undefined);
-        const contextPart = config.context
-            ? config.context(options)
-            : {};
+        const contextPart = config.context ? config.context(options) : {};
         const functionsBuilder = config.functions(options);
         return {
             context: contextPart,

package/dist/extensions/types.d.ts

@@ -1,24 +1,28 @@
 import z, { ZodType } from "zod";
-export type InferOptions<T extends ZodType | undefined> = T extends ZodType ? z.infer<T> : undefined;
-export type ExtensionBase = {
-    context: any;
-    functions: <C>(context: C) => any;
-};
+/** Utilitaire d'inférence d'appel générique (déjà présent chez toi) */
 type FnCallSignatureMatchesWith<C, F> = F extends {
     (context: C): infer R;
 } ? R : F extends {
     <U>(context: U): infer RGeneric;
 } ? RGeneric : F extends (context: any) => infer R ? R : never;
+/** MergeExtensions : applique la logique d'inférence sur une tuple d'extensions */
 export type MergeExtensions<TContext, TExtensions extends readonly any[]> = TExtensions extends readonly [infer Head, ...infer Tail] ? (Head extends {
     functions: infer F;
 } ? FnCallSignatureMatchesWith<TContext, F> : {}) & MergeExtensions<TContext, Tail> : {};
+/** Ici : functions est *explicitement* une call signature générique */
+export type ExtensionBase = {
+    context: any;
+    functions: <C>(context: C) => any;
+};
+/** Helpers pour extensions/InferOptions et définition d'Extension */
+export type InferOptions<T extends ZodType | undefined> = T extends ZodType ? z.infer<T> : undefined;
 export type ExtensionConfig<TSchema extends ZodType | undefined, TContextAddon extends Record<string, unknown>> = {
     name: string;
     schema?: TSchema;
     context?: (options: InferOptions<TSchema>) => TContextAddon;
-    functions: (options: InferOptions<TSchema>) => (context: any) => any;
+    functions: (options: InferOptions<TSchema>) => (<C>(context: C) => any);
 };
-export type Extension<TSchema extends ZodType | undefined, TContextAddon extends Record<string, unknown>, TFunctionsFactory extends (context: any) => any> = (...args: TSchema extends ZodType ? [options: z.input<TSchema>] : [options?: undefined]) => {
+export type Extension<TSchema extends ZodType | undefined, TContextAddon extends Record<string, unknown>, TFunctionsFactory extends (<C>(context: C) => any)> = (...args: TSchema extends ZodType ? [options: z.input<TSchema>] : [options?: undefined]) => {
     context: TContextAddon;
     functions: TFunctionsFactory;
 };

package/dist/extensions/types.js

@@ -1,2 +1,3 @@
 "use strict";
+// types.ts (ou fichier équivalent)
 Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@deessejs/functions",
-    "version": "0.0.36",
+    "version": "0.0.37",
     "description": "A powerful utility library for building type-safe APIs and functions with context management",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",