@deessejs/functions 0.0.62 → 0.0.63

package/dist/context/define.js

@@ -3,16 +3,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.defineContext = defineContext;
 function defineContext() {
     return {
-        // ON UTILISE 'readonly any[]'.
-        // C'est vital. Si on met un type plus précis ici, TypeScript risque 
-        // de simplifier le générique de 'rpc' avant qu'on puisse l'injecter.
+        // any[] préserve la généricité de rpc jusqu'au bout
         withExtensions: (config) => {
             const runtimeBuilder = {};
             const dummyContext = {};
             for (const extension of config.extensions) {
-                // Runtime only
-                if (extension && typeof extension.functions === "function") {
-                    const extensionMethods = extension.functions(dummyContext);
+                // Cast runtime uniquement
+                const ext = extension;
+                if (ext && typeof ext.functions === "function") {
+                    const extensionMethods = ext.functions(dummyContext);
                     Object.assign(runtimeBuilder, extensionMethods);
                 }
             }

package/dist/extensions/index.js

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.extensions = extensions;
-// N'importe PAS FunctionsForContext ici pour le typage, ça brise la généricité.
+// Retirez l'import de Extension et FunctionsForContext s'ils ne servent qu'au typage de retour
 function extensions(config) {
-    // On laisse TypeScript retourner l'objet tel quel.
+    // 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);

package/dist/extensions/types.d.ts

@@ -1,20 +1,17 @@
 import z, { ZodType } from "zod";
 /**
- * LA SOLUTION ULTIME : Intersection de ReturnType.
- *
- * 1. F & ((c: C) => unknown) : On crée une fonction hybride qui doit satisfaire
- *    TA fonction générique ET une fonction qui prend ton Contexte.
- * 2. ReturnType<...> : Pour résoudre le type de retour de cette hybride,
- *    TypeScript est obligé de remplacer le générique de F par C.
- * 3. Le "& unknown" assure qu'on ne pollue pas le type de retour (R & unknown = R).
+ * Maintenant que F est une fonction générique "propre" (grâce à l'étape 1),
+ * l'inférence directe fonctionne parfaitement.
+ * TS va voir : <C>(c: C) => ... extends (c: TContext) => infer R
+ * Il va mathématiquement remplacer C par TContext.
  */
-type ApplyContext<F, C> = F extends (c: any) => any ? ReturnType<F & ((c: C) => unknown)> : never;
+type ApplyContext<F, C> = F extends (context: C) => infer R ? R : never;
 export type MergeExtensions<TContext, TExtensions extends readonly any[]> = TExtensions extends readonly [infer Head, ...infer Tail] ? (Head extends {
     functions: infer F;
 } ? ApplyContext<F, TContext> : {}) & MergeExtensions<TContext, Tail> : {};
-export type InferOptions<T extends ZodType | undefined> = T extends ZodType ? z.infer<T> : undefined;
-export type Extension<TSchema extends ZodType | undefined, TContextAddon extends Record<string, unknown>, TFunctionsFactory> = (...args: TSchema extends ZodType ? [options: z.input<TSchema>] : [options?: undefined]) => {
-    context: TContextAddon;
-    functions: TFunctionsFactory;
+export type ExtensionBase = {
+    context: any;
+    functions: any;
 };
+export type InferOptions<T extends ZodType | undefined> = T extends ZodType ? z.infer<T> : undefined;
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@deessejs/functions",
-    "version": "0.0.62",
+    "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",