@jskit-ai/jskit-cli 0.2.92 → 0.2.96

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/jskit-cli",
-  "version": "0.2.92",
+  "version": "0.2.96",
   "description": "Bundle and package orchestration CLI for JSKIT apps.",
   "type": "module",
   "files": [

package/src/server/helperMap.js

@@ -1,3 +1,6 @@
+import {
+  createHash
+} from "node:crypto";
 import {
   mkdir,
   readFile,
@@ -17,10 +20,11 @@ const {
   ModuleKind,
   ModuleResolutionKind,
   Project,
-  ScriptTarget
+  ScriptTarget,
+  ts
 } = tsMorph;
 
-const HELPER_MAP_SCHEMA_VERSION = 1;
+const HELPER_MAP_SCHEMA_VERSION = 2;
 const CODE_EXTENSIONS = new Set([".cjs", ".js", ".jsx", ".mjs", ".ts", ".tsx", ".vue"]);
 const APP_SCAN_ROOTS = Object.freeze(["src", "packages", "config", "server", "scripts"]);
 const EXCLUDED_DIR_NAMES = new Set([
@@ -50,6 +54,12 @@ async function readJsonFile(filePath) {
   return JSON.parse(await readFile(filePath, "utf8"));
 }
 
+async function readFileHash(filePath) {
+  return createHash("sha256")
+    .update(await readFile(filePath))
+    .digest("hex");
+}
+
 function normalizePackageDependencies(packageJson = {}) {
   const dependencies = {
     ...(packageJson.dependencies || {}),
@@ -89,37 +99,6 @@ function createExportAnalysisProject() {
   });
 }
 
-function kindFromDeclaration(declaration, exportName = "") {
-  if (exportName === "default") {
-    return "default";
-  }
-  switch (declaration.getKindName()) {
-    case "ClassDeclaration":
-      return "class";
-    case "EnumDeclaration":
-      return "enum";
-    case "FunctionDeclaration":
-    case "FunctionExpression":
-    case "MethodDeclaration":
-      return "function";
-    case "InterfaceDeclaration":
-      return "interface";
-    case "TypeAliasDeclaration":
-      return "type";
-    case "VariableDeclaration": {
-      const initializer = typeof declaration.getInitializer === "function"
-        ? declaration.getInitializer()
-        : null;
-      const initializerKind = initializer?.getKindName?.() || "";
-      return initializerKind === "ArrowFunction" || initializerKind === "FunctionExpression"
-        ? "function"
-        : "value";
-    }
-    default:
-      return "export";
-  }
-}
-
 function addSymbol(symbols, symbol) {
   if (!symbol.name) {
     return;
@@ -135,14 +114,116 @@ function addSymbol(symbols, symbol) {
   });
 }
 
+function compilerNodeHasModifier(node, modifierKind) {
+  return Array.isArray(node?.modifiers) && node.modifiers.some((modifier) => modifier.kind === modifierKind);
+}
+
+function exportedDeclarationName(node) {
+  if (compilerNodeHasModifier(node, ts.SyntaxKind.DefaultKeyword)) {
+    return "default";
+  }
+  return String(node?.name?.text || node?.name?.escapedText || "").trim();
+}
+
+function addExportedDeclarationSymbol(symbols, node, kind = "export") {
+  const name = exportedDeclarationName(node);
+  if (!name) {
+    return;
+  }
+  addSymbol(symbols, {
+    kind: name === "default" ? "default" : kind,
+    name
+  });
+}
+
+function bindingNameTexts(bindingName, names = []) {
+  if (!bindingName) {
+    return names;
+  }
+  if (ts.isIdentifier(bindingName)) {
+    names.push(String(bindingName.text || ""));
+    return names;
+  }
+  if (ts.isObjectBindingPattern(bindingName) || ts.isArrayBindingPattern(bindingName)) {
+    for (const element of bindingName.elements || []) {
+      if (element.name) {
+        bindingNameTexts(element.name, names);
+      }
+    }
+  }
+  return names;
+}
+
+function addVariableStatementExports(symbols, statement) {
+  if (!compilerNodeHasModifier(statement, ts.SyntaxKind.ExportKeyword)) {
+    return;
+  }
+  for (const declaration of statement.declarationList?.declarations || []) {
+    for (const name of bindingNameTexts(declaration.name)) {
+      addSymbol(symbols, {
+        kind: declaration.initializer &&
+          (ts.isArrowFunction(declaration.initializer) || ts.isFunctionExpression(declaration.initializer))
+          ? "function"
+          : "value",
+        name
+      });
+    }
+  }
+}
+
+function addNamedExportSymbols(symbols, exportClause) {
+  if (!exportClause) {
+    return;
+  }
+  if (ts.isNamespaceExport(exportClause)) {
+    addSymbol(symbols, {
+      kind: "export",
+      name: String(exportClause.name?.text || "")
+    });
+    return;
+  }
+  if (!ts.isNamedExports(exportClause)) {
+    return;
+  }
+  for (const specifier of exportClause.elements || []) {
+    addSymbol(symbols, {
+      kind: "export",
+      name: String(specifier.name?.text || "")
+    });
+  }
+}
+
 function extractExportedSymbols(sourceFile) {
   const symbols = new Map();
-  for (const [name, declarations] of sourceFile.getExportedDeclarations()) {
-    for (const declaration of declarations) {
+  for (const statement of sourceFile.compilerNode.statements || []) {
+    if (ts.isExportDeclaration(statement)) {
+      addNamedExportSymbols(symbols, statement.exportClause);
+      continue;
+    }
+    if (ts.isExportAssignment(statement)) {
       addSymbol(symbols, {
-        name,
-        kind: kindFromDeclaration(declaration, name)
+        kind: "default",
+        name: "default"
       });
+      continue;
+    }
+    if (ts.isVariableStatement(statement)) {
+      addVariableStatementExports(symbols, statement);
+      continue;
+    }
+    if (!compilerNodeHasModifier(statement, ts.SyntaxKind.ExportKeyword)) {
+      continue;
+    }
+    if (ts.isFunctionDeclaration(statement)) {
+      addExportedDeclarationSymbol(symbols, statement, "function");
+    } else if (ts.isClassDeclaration(statement)) {
+      addExportedDeclarationSymbol(symbols, statement, "class");
+    } else if (ts.isInterfaceDeclaration(statement)) {
+      addExportedDeclarationSymbol(symbols, statement, "interface");
+    } else if (ts.isTypeAliasDeclaration(statement)) {
+      addExportedDeclarationSymbol(symbols, statement, "type");
+    } else if (ts.isEnumDeclaration(statement)) {
+      addExportedDeclarationSymbol(symbols, statement, "enum");
     }
   }
 
@@ -277,11 +358,75 @@ function flattenPackageExports(exportsField) {
   });
 }
 
-async function collectJskitPackageExports(targetRoot, packageJson = {}) {
+async function packageExportTargetRecords(packageRoot, exportTargets = []) {
+  const records = [];
+  for (const exportTarget of exportTargets) {
+    const normalizedTarget = exportTarget.target.replace(/^\.\//u, "");
+    const targetPath = path.join(packageRoot, normalizedTarget);
+    const ext = path.extname(targetPath);
+    if (!CODE_EXTENSIONS.has(ext) || !await pathExists(targetPath)) {
+      continue;
+    }
+    records.push({
+      absolutePath: targetPath,
+      hash: await readFileHash(targetPath),
+      subpath: exportTarget.subpath,
+      target: normalizedTarget.split(path.sep).join("/")
+    });
+  }
+  return records;
+}
+
+function packageExportFingerprint({
+  installedPackageJson = {},
+  packageName = "",
+  targetRecords = []
+} = {}) {
+  return createHash("sha256")
+    .update(JSON.stringify({
+      name: packageName,
+      version: installedPackageJson.version || "",
+      targets: targetRecords.map((record) => ({
+        hash: record.hash,
+        subpath: record.subpath,
+        target: record.target
+      }))
+    }))
+    .digest("hex");
+}
+
+function cachedPackageExports(previousPackagesByName = new Map(), packageName = "", fingerprint = "") {
+  const previous = previousPackagesByName.get(packageName);
+  if (
+    !previous ||
+    previous.installed !== true ||
+    previous.fingerprint !== fingerprint ||
+    !Array.isArray(previous.exports)
+  ) {
+    return null;
+  }
+  return {
+    name: previous.name,
+    version: previous.version || "",
+    fingerprint: previous.fingerprint,
+    installed: true,
+    exports: previous.exports
+  };
+}
+
+function previousPackageMap(previousMap = null) {
+  return new Map(
+    (Array.isArray(previousMap?.jskitPackages) ? previousMap.jskitPackages : [])
+      .map((packageEntry) => [packageEntry.name, packageEntry])
+      .filter(([name]) => name)
+  );
+}
+
+async function collectJskitPackageExports(targetRoot, packageJson = {}, previousMap = null) {
   const packageNames = normalizePackageDependencies(packageJson)
     .filter((name) => name.startsWith("@jskit-ai/"));
   const packages = [];
-  const project = createExportAnalysisProject();
+  const previousPackagesByName = previousPackageMap(previousMap);
 
   for (const packageName of packageNames) {
     const packageRoot = path.join(targetRoot, "node_modules", ...packageName.split("/"));
@@ -297,21 +442,28 @@ async function collectJskitPackageExports(targetRoot, packageJson = {}) {
 
     const installedPackageJson = await readJsonFile(packageJsonPath);
     const exportTargets = flattenPackageExports(installedPackageJson.exports || {});
+    const targetRecords = await packageExportTargetRecords(packageRoot, exportTargets);
+    const fingerprint = packageExportFingerprint({
+      installedPackageJson,
+      packageName,
+      targetRecords
+    });
+    const cachedEntry = cachedPackageExports(previousPackagesByName, packageName, fingerprint);
+    if (cachedEntry) {
+      packages.push(cachedEntry);
+      continue;
+    }
+
+    const project = createExportAnalysisProject();
     const exports = [];
-    for (const exportTarget of exportTargets) {
-      const normalizedTarget = exportTarget.target.replace(/^\.\//u, "");
-      const targetPath = path.join(packageRoot, normalizedTarget);
-      const ext = path.extname(targetPath);
-      if (!CODE_EXTENSIONS.has(ext) || !await pathExists(targetPath)) {
-        continue;
-      }
+    for (const targetRecord of targetRecords) {
       const sourceFile = await addCodeFileToProject(project, {
-        absolutePath: targetPath,
-        relativePath: normalizedTarget
+        absolutePath: targetRecord.absolutePath,
+        relativePath: targetRecord.target
       });
       exports.push({
-        subpath: exportTarget.subpath,
-        target: normalizedTarget.split(path.sep).join("/"),
+        subpath: targetRecord.subpath,
+        target: targetRecord.target,
         exports: sourceFile ? extractExportedSymbols(sourceFile) : []
       });
     }
@@ -319,6 +471,7 @@ async function collectJskitPackageExports(targetRoot, packageJson = {}) {
     packages.push({
       name: packageName,
       version: installedPackageJson.version || "",
+      fingerprint,
       installed: true,
       exports
     });
@@ -383,7 +536,7 @@ function renderHelperMapMarkdown(map) {
   return `${lines.join("\n").replace(/\n{3,}/gu, "\n\n").trimEnd()}\n`;
 }
 
-async function buildHelperMap({ targetRoot }) {
+async function buildHelperMap({ targetRoot, previousMap = null }) {
   const packageJsonPath = path.join(targetRoot, "package.json");
   const packageJson = await readJsonFile(packageJsonPath);
   const map = {
@@ -396,7 +549,7 @@ async function buildHelperMap({ targetRoot }) {
     app: {
       files: await collectAppExports(targetRoot)
     },
-    jskitPackages: await collectJskitPackageExports(targetRoot, packageJson)
+    jskitPackages: await collectJskitPackageExports(targetRoot, packageJson, previousMap)
   };
   return {
     ok: true,
@@ -430,12 +583,17 @@ async function readHelperMap({ targetRoot }) {
 }
 
 async function updateHelperMap({ targetRoot }) {
-  const payload = await buildHelperMap({ targetRoot });
+  const helperMapJsonPath = path.join(targetRoot, HELPER_MAP_JSON_RELATIVE_PATH);
+  const currentJson = await pathExists(helperMapJsonPath)
+    ? await readFile(helperMapJsonPath, "utf8")
+    : "";
+  const previousMap = currentJson ? JSON.parse(currentJson) : null;
+  const payload = await buildHelperMap({
+    previousMap,
+    targetRoot
+  });
   const markdown = renderHelperMapMarkdown(payload.map);
   const json = `${JSON.stringify(payload.map, null, 2)}\n`;
-  const currentJson = await pathExists(payload.helperMapJsonPath)
-    ? await readFile(payload.helperMapJsonPath, "utf8")
-    : "";
   const currentMarkdown = await pathExists(payload.helperMapMarkdownPath)
     ? await readFile(payload.helperMapMarkdownPath, "utf8")
     : "";