protobuf-fastdsl 0.1.6 → 0.1.9

package/dist/index.d.ts

@@ -12,30 +12,40 @@ type ImportedTypeNameResolver = (name: string) => string;
  */
 declare function typeNodeToMangledName(typeNode: ts.TypeNode, sf: ts.SourceFile, resolveImportedTypeName?: ImportedTypeNameResolver): string;
 
+type CanonicalProtobufFn = 'protobuf_encode' | 'protobuf_decode';
+
+interface WrapperBinding {
+    fnName: CanonicalProtobufFn;
+    typeArgIndex: number;
+    typePattern?: string;
+    typeParamNames?: string[];
+    sourceFilePath?: string;
+}
 interface ParsedFileEntry {
     filePath: string;
     concrete: ProtobufMessage[];
     templates: Map<string, GenericProtobufTemplate>;
     importedTypeSources: Map<string, string>;
     resolveImportedTypeName: ImportedTypeNameResolver;
+    exportedWrappers: Map<string, WrapperBinding>;
 }
 interface ImportedDefinitions {
     concrete: ProtobufMessage[];
     templates: Map<string, GenericProtobufTemplate>;
+    wrapperBindings: Map<string, WrapperBinding>;
 }
 /**
  * Resolve only the import definitions reachable from protobuf call-site roots.
  */
 declare function resolveImports(code: string, importerPath: string, cache: Map<string, ParsedFileEntry>): ImportedDefinitions;
 
-type CanonicalProtobufFn = 'protobuf_encode' | 'protobuf_decode';
-
 /** A recorded call-site for later replacement. */
 interface CallSiteRecord {
     fnName: CanonicalProtobufFn;
     exprStart: number;
     typeArgsEnd: number;
     firstTypeArg: ts.TypeNode;
+    typeSourceFile?: ts.SourceFile;
     line: number;
     column: number;
 }

package/dist/index.js

@@ -252,6 +252,26 @@ function matchProtobufCallSite(node, sf, bindings, options) {
 }
 
 // src/ast/analyzer.ts
+var syntheticTypeSourceFiles = /* @__PURE__ */ new WeakMap();
+function getCallableName(expr) {
+  if (ts5.isIdentifier(expr)) return expr.text;
+  if (ts5.isPropertyAccessExpression(expr)) return expr.name.text;
+  return null;
+}
+function instantiateWrapperTypePattern(binding, callerTypeArgs, sf) {
+  if (!binding.typePattern || !binding.typeParamNames?.length) return callerTypeArgs[binding.typeArgIndex] ?? null;
+  let text = binding.typePattern;
+  for (let i = 0; i < binding.typeParamNames.length; i++) {
+    const arg = callerTypeArgs[i];
+    if (!arg) return null;
+    text = text.replace(new RegExp(`\\b${binding.typeParamNames[i]}\\b`, "g"), arg.getText(sf));
+  }
+  const parsed = ts5.createSourceFile("wrapper-type.ts", `type __T = ${text};`, ts5.ScriptTarget.Latest, true);
+  const stmt = parsed.statements[0];
+  if (!ts5.isTypeAliasDeclaration(stmt)) return null;
+  syntheticTypeSourceFiles.set(stmt.type, parsed);
+  return stmt.type;
+}
 function analyze(code, filePath, imported) {
   const sf = ts5.createSourceFile(filePath, code, ts5.ScriptTarget.Latest, true);
   const concrete = [];
@@ -261,6 +281,7 @@ function analyze(code, filePath, imported) {
   const deferredTypeArgs = [];
   const importBindings = collectProtobufImportBindings(sf);
   const resolveImportedTypeName = createImportedTypeNameResolver(sf);
+  const wrapperBindings = imported?.wrapperBindings ?? /* @__PURE__ */ new Map();
   if (imported) {
     concrete.push(...imported.concrete);
     for (const [k, v] of imported.templates) templates.set(k, v);
@@ -282,12 +303,33 @@ function analyze(code, filePath, imported) {
       if (cs) {
         deferredTypeArgs.push(cs.firstTypeArg);
         callSites.push(cs);
+      } else if (node.typeArguments?.length && getCallableName(node.expression) && wrapperBindings.has(getCallableName(node.expression))) {
+        const binding = wrapperBindings.get(getCallableName(node.expression));
+        const firstTypeArg = instantiateWrapperTypePattern(binding, node.typeArguments, sf);
+        if (!firstTypeArg) {
+          ts5.forEachChild(node, visit);
+          return;
+        }
+        const exprStart = node.expression.getStart(sf);
+        const lc = sf.getLineAndCharacterOfPosition(exprStart);
+        deferredTypeArgs.push(firstTypeArg);
+        callSites.push({
+          fnName: binding.fnName,
+          exprStart,
+          typeArgsEnd: node.typeArguments.end + 1,
+          firstTypeArg,
+          typeSourceFile: syntheticTypeSourceFiles.get(firstTypeArg),
+          line: lc.line + 1,
+          column: lc.character + 1
+        });
       }
     }
     ts5.forEachChild(node, visit);
   });
   for (const typeArg of deferredTypeArgs) {
-    monomorphizeTypeNode(typeArg, sf, templates, mono, resolveImportedTypeName);
+    const typeSf = syntheticTypeSourceFiles.get(typeArg) ?? sf;
+    const typeResolver = createImportedTypeNameResolver(typeSf);
+    monomorphizeTypeNode(typeArg, typeSf, templates, mono, typeResolver);
   }
   for (const m of mono.values()) concrete.push(m);
   const names = new Set(concrete.map((m) => m.name));
@@ -313,7 +355,8 @@ function selectUsedRegistry(registry, callSites, sourceFile) {
   const resolved = [];
   const resolveImportedTypeName = createImportedTypeNameResolver(sourceFile);
   for (const cs of callSites) {
-    const typeName = typeNodeToMangledName(cs.firstTypeArg, sourceFile, resolveImportedTypeName);
+    const typeSf = cs.typeSourceFile ?? syntheticTypeSourceFiles.get(cs.firstTypeArg) ?? sourceFile;
+    const typeName = typeNodeToMangledName(cs.firstTypeArg, typeSf, createImportedTypeNameResolver(typeSf));
     if (!registry.has(typeName)) continue;
     roots.add(typeName);
     resolved.push({ ...cs, typeName });
@@ -390,6 +433,11 @@ function replaceCallSites(code, registry) {
 import ts7 from "typescript";
 import { readFileSync, existsSync } from "fs";
 import { dirname, resolve } from "path";
+function getCallableName2(expr) {
+  if (ts7.isIdentifier(expr)) return expr.text;
+  if (ts7.isPropertyAccessExpression(expr)) return expr.name.text;
+  return null;
+}
 function extractImports(sf) {
   const result = [];
   for (const stmt of sf.statements) {
@@ -402,6 +450,7 @@ function extractImports(sf) {
       for (const el of clause.namedBindings.elements) {
         result.push({
           importedName: (el.propertyName ?? el.name).text,
+          localName: el.name.text,
           specifier
         });
       }
@@ -420,6 +469,190 @@ function resolveModulePath(specifier, importerPath) {
   if (existsSync(indexTs)) return indexTs;
   return null;
 }
+function hasExportModifier(node) {
+  return ts7.canHaveModifiers(node) && !!ts7.getModifiers(node)?.some((m) => m.kind === ts7.SyntaxKind.ExportKeyword);
+}
+function matchForwardedProtobufFn(body, sf, typeParams) {
+  if (!body || !typeParams?.length) return null;
+  const typeParamIndexes = new Map(typeParams.map((p, index) => [p.name.text, index]));
+  const typeParamNames = typeParams.map((p) => p.name.text);
+  const bindings = collectProtobufImportBindings(sf);
+  let found = null;
+  function visit(node) {
+    if (found) return;
+    if (ts7.isCallExpression(node)) {
+      const cs = matchProtobufCallSite(node, sf, bindings, {
+        allowLegacyUnboundCanonical: true
+      });
+      if (cs && ts7.isTypeReferenceNode(cs.firstTypeArg) && ts7.isIdentifier(cs.firstTypeArg.typeName) && typeParamIndexes.has(cs.firstTypeArg.typeName.text)) {
+        found = {
+          fnName: cs.fnName,
+          typeArgIndex: typeParamIndexes.get(cs.firstTypeArg.typeName.text),
+          sourceFilePath: sf.fileName
+        };
+        return;
+      }
+      if (cs && containsTypeParameter(cs.firstTypeArg, typeParamIndexes)) {
+        found = {
+          fnName: cs.fnName,
+          typeArgIndex: firstTypeParameterIndex(cs.firstTypeArg, typeParamIndexes) ?? 0,
+          typePattern: cs.firstTypeArg.getText(sf),
+          typeParamNames,
+          sourceFilePath: sf.fileName
+        };
+        return;
+      }
+    }
+    ts7.forEachChild(node, visit);
+  }
+  visit(body);
+  return found;
+}
+function containsTypeParameter(typeNode, typeParamIndexes) {
+  let found = false;
+  function visit(node) {
+    if (found) return;
+    if (ts7.isTypeReferenceNode(node) && ts7.isIdentifier(node.typeName) && typeParamIndexes.has(node.typeName.text)) {
+      found = true;
+      return;
+    }
+    ts7.forEachChild(node, visit);
+  }
+  visit(typeNode);
+  return found;
+}
+function firstTypeParameterIndex(typeNode, typeParamIndexes) {
+  let index = null;
+  function visit(node) {
+    if (index !== null) return;
+    if (ts7.isTypeReferenceNode(node) && ts7.isIdentifier(node.typeName) && typeParamIndexes.has(node.typeName.text)) {
+      index = typeParamIndexes.get(node.typeName.text);
+      return;
+    }
+    ts7.forEachChild(node, visit);
+  }
+  visit(typeNode);
+  return index;
+}
+function instantiateWrapperTypePattern2(binding, callerTypeArgs, sf) {
+  if (!binding.typePattern || !binding.typeParamNames?.length) return callerTypeArgs[binding.typeArgIndex] ?? null;
+  let text = binding.typePattern;
+  for (let i = 0; i < binding.typeParamNames.length; i++) {
+    const arg = callerTypeArgs[i];
+    if (!arg) return null;
+    text = text.replace(new RegExp(`\\b${binding.typeParamNames[i]}\\b`, "g"), arg.getText(sf));
+  }
+  const parsed = ts7.createSourceFile("wrapper-type.ts", `type __T = ${text};`, ts7.ScriptTarget.Latest, true);
+  const stmt = parsed.statements[0];
+  if (!ts7.isTypeAliasDeclaration(stmt)) return null;
+  return stmt.type;
+}
+function matchForwardedKnownWrapper(body, typeParams, knownWrappers) {
+  if (!body || !typeParams?.length) return null;
+  const typeParamIndexes = new Map(typeParams.map((p, index) => [p.name.text, index]));
+  let found = null;
+  function visit(node) {
+    if (found) return;
+    if (ts7.isCallExpression(node) && node.typeArguments?.length) {
+      const callableName = getCallableName2(node.expression);
+      const wrapper = callableName ? knownWrappers.get(callableName) : void 0;
+      const forwardedTypeArg = wrapper ? node.typeArguments[wrapper.typeArgIndex] : void 0;
+      if (wrapper && forwardedTypeArg && ts7.isTypeReferenceNode(forwardedTypeArg) && ts7.isIdentifier(forwardedTypeArg.typeName) && !forwardedTypeArg.typeArguments?.length && typeParamIndexes.has(forwardedTypeArg.typeName.text)) {
+        found = {
+          fnName: wrapper.fnName,
+          typeArgIndex: typeParamIndexes.get(forwardedTypeArg.typeName.text)
+        };
+        return;
+      }
+    }
+    ts7.forEachChild(node, visit);
+  }
+  visit(body);
+  return found;
+}
+function collectWrapperCandidates(sf, exportedOnly) {
+  const candidates = [];
+  for (const stmt of sf.statements) {
+    if (ts7.isFunctionDeclaration(stmt) && stmt.name && (!exportedOnly || hasExportModifier(stmt))) {
+      candidates.push({ name: stmt.name.text, body: stmt.body, typeParameters: stmt.typeParameters });
+      continue;
+    }
+    if (!ts7.isVariableStatement(stmt) || exportedOnly && !hasExportModifier(stmt)) continue;
+    for (const decl of stmt.declarationList.declarations) {
+      if (!ts7.isIdentifier(decl.name) || !decl.initializer) continue;
+      const init = decl.initializer;
+      if (ts7.isArrowFunction(init) || ts7.isFunctionExpression(init)) {
+        candidates.push({ name: decl.name.text, body: init.body, typeParameters: init.typeParameters });
+        continue;
+      }
+      if (ts7.isObjectLiteralExpression(init)) {
+        for (const prop of init.properties) {
+          if (ts7.isPropertyAssignment(prop)) {
+            const propName = ts7.isIdentifier(prop.name) || ts7.isStringLiteral(prop.name) ? prop.name.text : null;
+            const propInit = prop.initializer;
+            if (propName && (ts7.isArrowFunction(propInit) || ts7.isFunctionExpression(propInit))) {
+              candidates.push({ name: propName, body: propInit.body, typeParameters: propInit.typeParameters });
+            }
+            continue;
+          }
+          if (ts7.isMethodDeclaration(prop)) {
+            const propName = ts7.isIdentifier(prop.name) || ts7.isStringLiteral(prop.name) ? prop.name.text : null;
+            if (propName) candidates.push({ name: propName, body: prop.body, typeParameters: prop.typeParameters });
+          }
+        }
+      }
+    }
+  }
+  return candidates;
+}
+function collectWrappers(sf, exportedOnly) {
+  const wrappers = /* @__PURE__ */ new Map();
+  const localWrapperMembers = /* @__PURE__ */ new Map();
+  const candidates = collectWrapperCandidates(sf, exportedOnly);
+  for (const candidate of candidates) {
+    const fn = matchForwardedProtobufFn(candidate.body, sf, candidate.typeParameters);
+    if (fn) wrappers.set(candidate.name, fn);
+  }
+  for (const candidate of candidates) {
+    if (wrappers.has(candidate.name)) continue;
+    const fn = matchForwardedKnownWrapper(candidate.body, candidate.typeParameters, wrappers);
+    if (fn) wrappers.set(candidate.name, fn);
+  }
+  for (const stmt of sf.statements) {
+    if (!ts7.isVariableStatement(stmt) || exportedOnly && !hasExportModifier(stmt)) continue;
+    for (const decl of stmt.declarationList.declarations) {
+      if (!ts7.isIdentifier(decl.name) || !decl.initializer) continue;
+      const init = decl.initializer;
+      if (ts7.isObjectLiteralExpression(init)) {
+        const memberWrappers = /* @__PURE__ */ new Map();
+        for (const prop of init.properties) {
+          if (!("name" in prop) || !prop.name) continue;
+          const propName = ts7.isIdentifier(prop.name) || ts7.isStringLiteral(prop.name) ? prop.name.text : null;
+          if (!propName) continue;
+          const fn = wrappers.get(propName);
+          if (fn) {
+            memberWrappers.set(propName, fn);
+          }
+        }
+        if (memberWrappers.size) localWrapperMembers.set(decl.name.text, memberWrappers);
+      }
+    }
+  }
+  for (const stmt of sf.statements) {
+    if (exportedOnly || !ts7.isVariableStatement(stmt)) continue;
+    for (const decl of stmt.declarationList.declarations) {
+      if (!ts7.isIdentifier(decl.name) || !decl.initializer || !ts7.isPropertyAccessExpression(decl.initializer)) continue;
+      if (!ts7.isIdentifier(decl.initializer.expression)) continue;
+      const memberWrappers = localWrapperMembers.get(decl.initializer.expression.text);
+      const fn = memberWrappers?.get(decl.initializer.name.text);
+      if (fn) wrappers.set(decl.name.text, fn);
+    }
+  }
+  return wrappers;
+}
+function collectExportedWrappers(sf) {
+  return collectWrappers(sf, true);
+}
 function parseFileForDefinitions(absolutePath, code) {
   const sourceText = code ?? readFileSync(absolutePath, "utf-8");
   const sf = ts7.createSourceFile(absolutePath, sourceText, ts7.ScriptTarget.Latest, true);
@@ -427,10 +660,12 @@ function parseFileForDefinitions(absolutePath, code) {
   const templates = /* @__PURE__ */ new Map();
   const resolveImportedTypeName = createImportedTypeNameResolver(sf);
   const importedTypeSources = /* @__PURE__ */ new Map();
+  const exportedWrappers = collectExportedWrappers(sf);
   for (const imp of extractImports(sf)) {
     const resolved = resolveModulePath(imp.specifier, absolutePath);
     if (!resolved) continue;
     importedTypeSources.set(imp.importedName, resolved);
+    importedTypeSources.set(imp.localName, resolved);
   }
   for (const stmt of sf.statements) {
     if (!ts7.isInterfaceDeclaration(stmt)) continue;
@@ -447,7 +682,8 @@ function parseFileForDefinitions(absolutePath, code) {
     concrete,
     templates,
     importedTypeSources,
-    resolveImportedTypeName
+    resolveImportedTypeName,
+    exportedWrappers
   };
 }
 function collectCallRootTypeNodes(sf) {
@@ -472,6 +708,7 @@ function resolveImports(code, importerPath, cache) {
   const fileEntries = /* @__PURE__ */ new Map([[entryPath, entry]]);
   const visitedConcrete = /* @__PURE__ */ new Set();
   const visitedTemplates = /* @__PURE__ */ new Set();
+  const importedObjectWrapperMembers = /* @__PURE__ */ new Map();
   function getEntry(filePath) {
     const abs = resolve(filePath);
     const known = fileEntries.get(abs);
@@ -484,6 +721,42 @@ function resolveImports(code, importerPath, cache) {
     fileEntries.set(abs, parsed);
     return parsed;
   }
+  function collectCalledGenericIdentifiers(sf) {
+    const names = /* @__PURE__ */ new Set();
+    ts7.forEachChild(sf, function visit(node) {
+      if (ts7.isCallExpression(node) && node.typeArguments?.length) {
+        const callableName = getCallableName2(node.expression);
+        if (callableName) names.add(callableName);
+      }
+      ts7.forEachChild(node, visit);
+    });
+    return names;
+  }
+  function collectWrapperBindings(from, sf) {
+    const bindings = /* @__PURE__ */ new Map();
+    const localWrappers = from.filePath === entryPath ? collectWrappers(sf, false) : from.exportedWrappers;
+    for (const [name, fn] of localWrappers) bindings.set(name, fn);
+    const calledGenericIdentifiers = collectCalledGenericIdentifiers(sf);
+    for (const imp of extractImports(sf)) {
+      if (!calledGenericIdentifiers.has(imp.localName)) continue;
+      const resolved = resolveModulePath(imp.specifier, from.filePath);
+      if (!resolved) continue;
+      const wrapperFn = getEntry(resolved).exportedWrappers.get(imp.importedName);
+      if (wrapperFn) bindings.set(imp.localName, wrapperFn);
+      const importedEntry = getEntry(resolved);
+      const memberNames = [...importedEntry.exportedWrappers.keys()].filter((name) => calledGenericIdentifiers.has(name));
+      if (memberNames.length) {
+        const members = /* @__PURE__ */ new Map();
+        for (const name of memberNames) {
+          const memberBinding = importedEntry.exportedWrappers.get(name);
+          members.set(name, memberBinding);
+          bindings.set(name, memberBinding);
+        }
+        importedObjectWrapperMembers.set(imp.localName, members);
+      }
+    }
+    return bindings;
+  }
   function resolveTypeName2(typeName, from) {
     if (typeName in PRIMITIVE_TYPE_MAP) return;
     const concreteMsg = from.concrete.find((msg) => msg.name === typeName);
@@ -526,11 +799,30 @@ function resolveImports(code, importerPath, cache) {
       resolveTypeNode(typeArg, from);
     }
   }
-  const rootTypeNodes = collectCallRootTypeNodes(ts7.createSourceFile(entryPath, code, ts7.ScriptTarget.Latest, true));
-  for (const rootTypeNode of rootTypeNodes) {
-    resolveTypeNode(rootTypeNode, entry);
+  const rootTypeNodes = collectCallRootTypeNodes(ts7.createSourceFile(entryPath, code, ts7.ScriptTarget.Latest, true)).map((typeNode) => ({ typeNode, from: entry }));
+  const entrySourceFile = ts7.createSourceFile(entryPath, code, ts7.ScriptTarget.Latest, true);
+  const wrapperBindings = collectWrapperBindings(entry, entrySourceFile);
+  ts7.forEachChild(entrySourceFile, function visit(node) {
+    if (ts7.isCallExpression(node) && node.typeArguments?.length && getCallableName2(node.expression) && (wrapperBindings.has(getCallableName2(node.expression)) || ts7.isPropertyAccessExpression(node.expression) && ts7.isIdentifier(node.expression.expression) && importedObjectWrapperMembers.get(node.expression.expression.text)?.has(node.expression.name.text))) {
+      const binding = wrapperBindings.get(getCallableName2(node.expression)) ?? (ts7.isPropertyAccessExpression(node.expression) && ts7.isIdentifier(node.expression.expression) ? importedObjectWrapperMembers.get(node.expression.expression.text)?.get(node.expression.name.text) : void 0);
+      if (!binding) return;
+      const typeArg = instantiateWrapperTypePattern2(binding, node.typeArguments, entrySourceFile);
+      if (typeArg) rootTypeNodes.push({
+        typeNode: typeArg,
+        from: binding.typePattern && binding.sourceFilePath ? getEntry(binding.sourceFilePath) : entry
+      });
+      if (binding.typePattern) {
+        for (const callerTypeArg of node.typeArguments) {
+          rootTypeNodes.push({ typeNode: callerTypeArg, from: entry });
+        }
+      }
+    }
+    ts7.forEachChild(node, visit);
+  });
+  for (const root of rootTypeNodes) {
+    resolveTypeNode(root.typeNode, root.from);
   }
-  return { concrete: [...concrete.values()], templates };
+  return { concrete: [...concrete.values()], templates, wrapperBindings };
 }
 
 // src/index.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "protobuf-fastdsl",
-  "version": "0.1.6",
+  "version": "0.1.9",
   "type": "module",
   "main": "dist/runtime.js",
   "types": "protobuf.d.ts",
@@ -31,7 +31,7 @@
     "typescript": "^5.5.0"
   },
   "peerDependencies": {
-    "vite": "^5.0.0 || ^6.0.0 || ^7.0.0"
+    "vite": "^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0"
   },
   "peerDependenciesMeta": {
     "vite": {