@deessejs/functions 0.0.57 → 0.0.59

package/dist/context/define.d.ts

@@ -1,8 +1,8 @@
-import { ExtensionBase, MergeExtensions } from "../extensions/types";
+import { MergeExtensions } from "../extensions/types";
 export declare function defineContext<TContext extends Record<string, any>>(): {
-    withExtensions: <E extends readonly ExtensionBase<TContext, any>[]>(config: {
-        extensions: readonly [...E];
-    }) => MergeExtensions<TContext, E> & {
+    withExtensions: <TExtensions extends readonly any[]>(config: {
+        extensions: readonly [...TExtensions];
+    }) => MergeExtensions<TContext, TExtensions> & {
         context: TContext;
     };
 };

package/dist/context/define.js

@@ -3,14 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.defineContext = defineContext;
 function defineContext() {
     return {
-        // CHANGEMENT CRITIQUE :
-        // On demande à TS d'inférer E comme étant des extensions qui acceptent TContext.
-        // TS va automatiquement calculer le type de retour spécifique pour TContext.
+        // ON NE MET AUCUNE CONTRAINTE ICI.
+        // TExtensions capture le type brut et exact (ex: le générique <C> de rpc).
         withExtensions: (config) => {
             const runtimeBuilder = {};
             const dummyContext = {};
             for (const extension of config.extensions) {
-                // Le cast est safe car on sait que ça match ExtensionBase au runtime
+                // Cast runtime uniquement pour éviter les erreurs TS dans la boucle
                 const ext = extension;
                 if (ext && typeof ext.functions === "function") {
                     const extensionMethods = ext.functions(dummyContext);

package/dist/extensions/types.d.ts

@@ -1,11 +1,26 @@
 import z, { ZodType } from "zod";
-export type ExtensionBase<Context = any, Output = any> = {
+/**
+ * LA SOLUTION MATHÉMATIQUE.
+ * On ne demande pas "Est-ce que ça marche ?" (extends), on dit "Fais-le marcher !" (&).
+ *
+ * On crée une intersection entre :
+ * 1. Ta fonction générique F: <C>(c: C) => API<C>
+ * 2. Une fonction factice: (c: TContext) => unknown
+ *
+ * Pour calculer le ReturnType de cette intersection, TypeScript DOIT instancier
+ * le générique <C> de F avec TContext.
+ */
+type ApplyContext<F, C> = F extends (c: any) => any ? ReturnType<F & ((c: C) => unknown)> : 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 ExtensionBase = {
     context: any;
-    functions: (context: Context) => Output;
+    functions: any;
 };
-export type MergeExtensions<TContext, TExtensions extends readonly any[]> = TExtensions extends readonly [infer Head, ...infer Tail] ? (Head extends ExtensionBase<any, infer Out> ? Out : {}) & 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 extends <C>(context: C) => 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;
 };
+export {};

package/package.json

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