@lark-apaas/fullstack-cli 1.1.60 → 1.1.61-alpha.20260818172555

package/dist/client-dependency-graph.d.ts

@@ -0,0 +1,37 @@
+interface ClientDependencyGraphEntry {
+    specifier: string;
+    packagePath: string;
+}
+interface ClientDependencyGraphPackage {
+    path: string;
+    version: string;
+    integrity: string | null;
+    edges: Record<string, string>;
+}
+interface ClientDependencyConfigFile {
+    path: string;
+    sha256: string;
+}
+interface ClientDependencyGraph {
+    schemaVersion: 1;
+    algorithm: 'npm-installed-client-closure-v2';
+    runtimeAbiHash: string;
+    resolveConditions: ['browser', 'development', 'module', 'import'];
+    configFiles: ClientDependencyConfigFile[];
+    configEnvironment: Record<string, string>;
+    entries: ClientDependencyGraphEntry[];
+    packages: ClientDependencyGraphPackage[];
+}
+interface BuildClientDependencyGraphResult {
+    graph: ClientDependencyGraph;
+    hash: string;
+    optimizeDependencies: string[];
+}
+declare function packageNameFromSpecifier(specifier: string): string | undefined;
+declare function buildClientDependencyGraph(options: {
+    projectRoot: string;
+    runtimeAbiHash: string;
+    includeAllProductionDependencies?: boolean;
+}): BuildClientDependencyGraphResult;
+
+export { type BuildClientDependencyGraphResult, type ClientDependencyConfigFile, type ClientDependencyGraph, type ClientDependencyGraphEntry, type ClientDependencyGraphPackage, buildClientDependencyGraph, packageNameFromSpecifier };

package/dist/client-dependency-graph.js

@@ -0,0 +1,466 @@
+// src/client-dependency-graph.ts
+import crypto from "crypto";
+import fs from "fs";
+import path from "path";
+import { builtinModules } from "module";
+import { Node, Project, SyntaxKind } from "ts-morph";
+var BUILTIN_MODULES = /* @__PURE__ */ new Set([
+  ...builtinModules,
+  ...builtinModules.map((name) => `node:${name}`)
+]);
+var SOURCE_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"];
+var STYLE_EXTENSIONS = [
+  ".css",
+  ".less",
+  ".sass",
+  ".scss",
+  ".styl",
+  ".stylus"
+];
+function packageNameFromSpecifier(specifier) {
+  if (!specifier || specifier.startsWith(".") || specifier.startsWith("/") || specifier.startsWith("\0") || specifier.includes("://") || BUILTIN_MODULES.has(specifier)) {
+    return void 0;
+  }
+  const parts = specifier.split("/");
+  return specifier.startsWith("@") ? parts.length >= 2 ? `${parts[0]}/${parts[1]}` : void 0 : parts[0];
+}
+function isStyleSpecifier(specifier) {
+  return STYLE_EXTENSIONS.some(
+    (extension) => new RegExp(`\\${extension}(?:$|\\?)`, "i").test(specifier)
+  );
+}
+function resolveLocalFile(specifier, importer, projectRoot, clientRoot) {
+  let candidate;
+  if (specifier.startsWith("@/")) {
+    candidate = path.join(clientRoot, "src", specifier.slice(2));
+  } else if (specifier.startsWith("@client/")) {
+    candidate = path.join(clientRoot, specifier.slice("@client/".length));
+  } else if (specifier.startsWith("@shared/")) {
+    candidate = path.join(
+      projectRoot,
+      "shared",
+      specifier.slice("@shared/".length)
+    );
+  } else if (specifier.startsWith(".") || path.isAbsolute(specifier)) {
+    candidate = path.resolve(path.dirname(importer), specifier);
+  }
+  if (!candidate) return void 0;
+  const projectRelative = path.relative(projectRoot, path.resolve(candidate));
+  if (projectRelative === ".." || projectRelative.startsWith(`..${path.sep}`) || path.isAbsolute(projectRelative)) {
+    throw new Error(
+      `MIAODA_CLIENT_SOURCE_PATH_ESCAPE: ${specifier} from ${path.relative(
+        projectRoot,
+        importer
+      )}`
+    );
+  }
+  const extensions = [...SOURCE_EXTENSIONS, ...STYLE_EXTENSIONS];
+  const candidates = [
+    candidate,
+    ...extensions.map((extension) => `${candidate}${extension}`),
+    ...extensions.map((extension) => path.join(candidate, `index${extension}`))
+  ];
+  const resolvedFile = candidates.find((file) => {
+    try {
+      return fs.statSync(file).isFile();
+    } catch {
+      return false;
+    }
+  });
+  if (!resolvedFile) return void 0;
+  const realProjectRoot = fs.realpathSync(projectRoot);
+  const realFile = fs.realpathSync(resolvedFile);
+  const relative = path.relative(realProjectRoot, realFile);
+  if (relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
+    throw new Error(`MIAODA_CLIENT_SOURCE_SYMLINK_ESCAPE: ${resolvedFile}`);
+  }
+  return resolvedFile;
+}
+function discoverClientSpecifiers(projectRoot, scanAllSourceFiles = false) {
+  const clientRoot = fs.existsSync(path.join(projectRoot, "client")) ? path.join(projectRoot, "client") : projectRoot;
+  if (!fs.existsSync(path.join(clientRoot, "src"))) {
+    return { specifiers: [], optimizeDependencies: [] };
+  }
+  const project = new Project({
+    skipAddingFilesFromTsConfig: true,
+    compilerOptions: { allowJs: true, jsx: 2 }
+  });
+  const specifiers = /* @__PURE__ */ new Set();
+  const optimizeDependencies = /* @__PURE__ */ new Set();
+  const pending = SOURCE_EXTENSIONS.map(
+    (extension) => path.join(clientRoot, "src", `index${extension}`)
+  ).filter((file) => fs.existsSync(file));
+  if (scanAllSourceFiles) {
+    const visit = (directory) => {
+      for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
+        const file = path.join(directory, entry.name);
+        if (entry.isSymbolicLink()) {
+          throw new Error(`MIAODA_CLIENT_SOURCE_SYMLINK_REJECTED: ${file}`);
+        }
+        if (entry.isDirectory()) visit(file);
+        else if (entry.isFile() && [...SOURCE_EXTENSIONS, ...STYLE_EXTENSIONS].includes(
+          path.extname(file)
+        )) {
+          pending.push(file);
+        }
+      }
+    };
+    visit(path.join(clientRoot, "src"));
+  }
+  const visited = /* @__PURE__ */ new Set();
+  const addBare = (specifier, optimize) => {
+    if (!packageNameFromSpecifier(specifier)) return;
+    specifiers.add(specifier);
+    if (optimize) optimizeDependencies.add(specifier);
+  };
+  const traverse = (specifier, importer, optimize = true) => {
+    const dependency = resolveLocalFile(
+      specifier,
+      importer,
+      projectRoot,
+      clientRoot
+    );
+    if (dependency) pending.push(dependency);
+    else addBare(specifier, optimize && !isStyleSpecifier(specifier));
+  };
+  while (pending.length > 0) {
+    const sourcePath = path.resolve(pending.pop());
+    if (visited.has(sourcePath)) continue;
+    visited.add(sourcePath);
+    if (STYLE_EXTENSIONS.includes(path.extname(sourcePath))) {
+      const css = fs.readFileSync(sourcePath, "utf8");
+      for (const match of css.matchAll(
+        /@(import|plugin)\s+(?:url\(\s*)?["']([^"']+)["']/g
+      )) {
+        traverse(match[2], sourcePath, false);
+      }
+      for (const match of css.matchAll(/@source\s+["']([^"']+)["']/g)) {
+        const marker = /(?:^|[\\/])node_modules[\\/]((?:@[^\\/]+[\\/])?[^\\/*?{}]+)/.exec(
+          match[1]
+        );
+        if (marker) addBare(marker[1].replace(/\\/g, "/"), false);
+      }
+      continue;
+    }
+    const sourceFile = project.addSourceFileAtPath(sourcePath);
+    for (const declaration of sourceFile.getImportDeclarations()) {
+      if (declaration.isTypeOnly()) continue;
+      const namedImports = declaration.getNamedImports();
+      const hasRuntimeBinding = Boolean(declaration.getDefaultImport()) || Boolean(declaration.getNamespaceImport()) || namedImports.length === 0 || namedImports.some((specifier) => !specifier.isTypeOnly());
+      if (hasRuntimeBinding) {
+        traverse(declaration.getModuleSpecifierValue(), sourcePath);
+      }
+    }
+    for (const declaration of sourceFile.getExportDeclarations()) {
+      if (declaration.isTypeOnly()) continue;
+      const namedExports = declaration.getNamedExports();
+      const specifier = declaration.getModuleSpecifierValue();
+      if (specifier && (namedExports.length === 0 || namedExports.some((namedExport) => !namedExport.isTypeOnly()))) {
+        traverse(specifier, sourcePath);
+      }
+    }
+    for (const call of sourceFile.getDescendantsOfKind(
+      SyntaxKind.CallExpression
+    )) {
+      const expression = call.getExpression();
+      const isDynamicImport = expression.getKind() === SyntaxKind.ImportKeyword;
+      const isRequire = Node.isIdentifier(expression) && expression.getText() === "require";
+      if (!isDynamicImport && !isRequire) continue;
+      const argument = call.getArguments()[0];
+      if (!argument || !Node.isStringLiteral(argument)) {
+        throw new Error(
+          `MIAODA_CLIENT_DYNAMIC_DEPENDENCY_UNSUPPORTED: ${path.relative(
+            projectRoot,
+            sourcePath
+          )}:${call.getStartLineNumber()}`
+        );
+      }
+      traverse(argument.getLiteralValue(), sourcePath);
+    }
+  }
+  return {
+    specifiers: [...specifiers].sort(),
+    optimizeDependencies: [...optimizeDependencies].sort()
+  };
+}
+function parentPackagePath(packagePath) {
+  const nestedMarker = packagePath.lastIndexOf("/node_modules/");
+  if (nestedMarker >= 0) return packagePath.slice(0, nestedMarker);
+  return packagePath.startsWith("node_modules/") ? "" : void 0;
+}
+function resolveLockedPackagePath(packages, fromPackagePath, packageName) {
+  let current = fromPackagePath;
+  while (current !== void 0) {
+    const candidate = current ? `${current}/node_modules/${packageName}` : `node_modules/${packageName}`;
+    if (packages[candidate]?.version) return candidate;
+    current = current ? parentPackagePath(current) : void 0;
+  }
+  return void 0;
+}
+function canonicalize(value) {
+  return JSON.stringify(value);
+}
+function clientConfigFiles(projectRoot) {
+  const fixedNames = [
+    "vite.config.ts",
+    "vite.config.mts",
+    "vite.config.js",
+    "vite.config.mjs",
+    "vite.config.cjs",
+    "postcss.config.js",
+    "postcss.config.cjs",
+    "postcss.config.mjs",
+    "tailwind.config.ts",
+    "tailwind.config.js",
+    "tailwind.config.cjs",
+    "tailwind.config.mjs",
+    "tsconfig.json",
+    "tsconfig.app.json",
+    "tsconfig.node.json",
+    ".env",
+    ".env.development",
+    ".env.development.local"
+  ];
+  const pending = fixedNames.map((name) => path.join(projectRoot, name));
+  for (const patchRootName of ["patches", ".yarn/patches"]) {
+    const patchRoot = path.join(projectRoot, patchRootName);
+    if (!fs.existsSync(patchRoot)) continue;
+    const visit = (directory) => {
+      for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
+        const file = path.join(directory, entry.name);
+        if (entry.isSymbolicLink()) {
+          throw new Error(`MIAODA_CLIENT_CONFIG_SYMLINK_REJECTED: ${file}`);
+        }
+        if (entry.isDirectory()) visit(file);
+        else if (entry.isFile()) pending.push(file);
+      }
+    };
+    visit(patchRoot);
+  }
+  const visited = /* @__PURE__ */ new Set();
+  const result = [];
+  const resolveRelativeConfig = (specifier, importer) => {
+    if (!specifier.startsWith(".")) return void 0;
+    const candidate = path.resolve(path.dirname(importer), specifier);
+    const candidates = [
+      candidate,
+      ...[...SOURCE_EXTENSIONS, ".json"].map(
+        (extension) => `${candidate}${extension}`
+      ),
+      ...[...SOURCE_EXTENSIONS, ".json"].map(
+        (extension) => path.join(candidate, `index${extension}`)
+      )
+    ];
+    return candidates.find((file) => {
+      const relative = path.relative(projectRoot, file);
+      return relative !== ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative) && fs.existsSync(file) && fs.statSync(file).isFile();
+    });
+  };
+  while (pending.length > 0) {
+    const file = path.resolve(pending.pop());
+    if (visited.has(file) || !fs.existsSync(file) || !fs.statSync(file).isFile()) {
+      continue;
+    }
+    visited.add(file);
+    const content = fs.readFileSync(file);
+    result.push({
+      path: path.relative(projectRoot, file),
+      sha256: crypto.createHash("sha256").update(content).digest("hex")
+    });
+    if (SOURCE_EXTENSIONS.includes(path.extname(file))) {
+      const source = content.toString("utf8");
+      for (const match of source.matchAll(
+        /(?:from\s*|import\s*\(|require\s*\()\s*["']([^"']+)["']/g
+      )) {
+        const dependency = resolveRelativeConfig(match[1], file);
+        if (dependency) pending.push(dependency);
+      }
+    } else if (path.extname(file) === ".json") {
+      try {
+        const json = JSON.parse(content.toString("utf8"));
+        for (const specifier of [
+          json.extends,
+          ...(json.references ?? []).map((reference) => reference.path)
+        ]) {
+          if (!specifier) continue;
+          const dependency = resolveRelativeConfig(specifier, file);
+          if (dependency) pending.push(dependency);
+        }
+      } catch {
+      }
+    }
+  }
+  return result.sort((left, right) => left.path.localeCompare(right.path));
+}
+function clientConfigEnvironment() {
+  const names = [
+    "APP_FLAGS",
+    "ASSETS_CDN_PATH",
+    "BUILD_TOOL",
+    "CLIENT_BASE_PATH",
+    "DISABLE_INSPECTOR",
+    "FORCE_FRAMEWORK_BUILD_LOOSE_MODE",
+    "FORCE_FRAMEWORK_DOMAIN_MAIN",
+    "FORCE_FRAMEWORK_ENVIRONMENT",
+    "MIAODA_APP_ARCH_TYPE",
+    "MIAODA_APP_SOURCE",
+    "MIAODA_APP_TYPE",
+    "MIAODA_FONTS_MIRROR_OFF",
+    "NEED_ROUTES",
+    "STATIC_ASSETS_BASE_URL",
+    "__API_ROUTE_DEFINITIONS__",
+    "__PAGE_ROUTE_DEFINITIONS__"
+  ];
+  return Object.fromEntries(
+    names.map((name) => [
+      name,
+      crypto.createHash("sha256").update(process.env[name] ?? "").digest("hex")
+    ])
+  );
+}
+function installedDependencyLockFile(projectRoot) {
+  const hiddenLock = path.join(
+    projectRoot,
+    "node_modules",
+    ".package-lock.json"
+  );
+  if (fs.existsSync(hiddenLock)) {
+    if (fs.lstatSync(hiddenLock).isSymbolicLink() || !fs.statSync(hiddenLock).isFile()) {
+      throw new Error("MIAODA_NPM_HIDDEN_PACKAGE_LOCK_INVALID");
+    }
+    return hiddenLock;
+  }
+  return path.join(projectRoot, "package-lock.json");
+}
+function buildClientDependencyGraph(options) {
+  const projectRoot = path.resolve(options.projectRoot);
+  const packageLockFile = installedDependencyLockFile(projectRoot);
+  const lock = JSON.parse(
+    fs.readFileSync(packageLockFile, "utf8")
+  );
+  if (!lock.packages || (lock.lockfileVersion ?? 0) < 2) {
+    throw new Error("MIAODA_NPM_PACKAGE_LOCK_V2_REQUIRED");
+  }
+  const discovery = discoverClientSpecifiers(
+    projectRoot,
+    options.includeAllProductionDependencies === true
+  );
+  if (options.includeAllProductionDependencies) {
+    const packageJson = JSON.parse(
+      fs.readFileSync(path.join(projectRoot, "package.json"), "utf8")
+    );
+    for (const specifier of Object.keys(packageJson.dependencies ?? {})) {
+      if (!lock.packages[`node_modules/${specifier}`]?.version) continue;
+      if (!discovery.specifiers.includes(specifier)) {
+        discovery.specifiers.push(specifier);
+      }
+    }
+  }
+  const implicitSpecifiers = [
+    "react",
+    "react-dom",
+    "react/jsx-runtime",
+    "react/jsx-dev-runtime",
+    "clsx",
+    "echarts",
+    "echarts-for-react",
+    "@lark-apaas/client-toolkit/runtime",
+    ...process.env.DISABLE_INSPECTOR === "true" ? [] : ["@lark-apaas/miaoda-inspector"]
+  ];
+  for (const specifier of implicitSpecifiers) {
+    const packageName = packageNameFromSpecifier(specifier);
+    if (lock.packages[`node_modules/${packageName}`]?.version && !discovery.specifiers.includes(specifier)) {
+      discovery.specifiers.push(specifier);
+      discovery.optimizeDependencies.push(specifier);
+    }
+  }
+  discovery.specifiers.sort();
+  discovery.optimizeDependencies.sort();
+  const entries = discovery.specifiers.map((specifier) => {
+    const packageName = packageNameFromSpecifier(specifier);
+    const packagePath = resolveLockedPackagePath(
+      lock.packages,
+      "",
+      packageName
+    );
+    if (!packagePath) {
+      throw new Error(`MIAODA_CLIENT_DEPENDENCY_LOCK_MISSING: ${specifier}`);
+    }
+    return { specifier, packagePath };
+  });
+  const pending = [...new Set(entries.map((entry) => entry.packagePath))];
+  const graphPackages = /* @__PURE__ */ new Map();
+  while (pending.length > 0) {
+    const packagePath = pending.pop();
+    if (graphPackages.has(packagePath)) continue;
+    const lockedPackage = lock.packages[packagePath];
+    if (!lockedPackage?.version) {
+      throw new Error(`MIAODA_CLIENT_DEPENDENCY_LOCK_MISSING: ${packagePath}`);
+    }
+    const edges = {};
+    const addEdge = (name, required) => {
+      const resolvedPath = resolveLockedPackagePath(
+        lock.packages,
+        packagePath,
+        name
+      );
+      if (!resolvedPath) {
+        if (required) {
+          throw new Error(
+            `MIAODA_CLIENT_DEPENDENCY_EDGE_MISSING: ${packagePath} -> ${name}`
+          );
+        }
+        return;
+      }
+      edges[name] = resolvedPath;
+      pending.push(resolvedPath);
+    };
+    for (const name of Object.keys(lockedPackage.dependencies ?? {}).sort()) {
+      addEdge(name, true);
+    }
+    for (const name of Object.keys(
+      lockedPackage.optionalDependencies ?? {}
+    ).sort()) {
+      addEdge(name, false);
+    }
+    for (const name of Object.keys(
+      lockedPackage.peerDependencies ?? {}
+    ).sort()) {
+      addEdge(
+        name,
+        lockedPackage.peerDependenciesMeta?.[name]?.optional !== true
+      );
+    }
+    graphPackages.set(packagePath, {
+      path: packagePath,
+      version: lockedPackage.version,
+      integrity: lockedPackage.integrity ?? null,
+      edges: Object.fromEntries(
+        Object.entries(edges).sort(
+          ([left], [right]) => left.localeCompare(right)
+        )
+      )
+    });
+  }
+  const graph = {
+    schemaVersion: 1,
+    algorithm: "npm-installed-client-closure-v2",
+    runtimeAbiHash: options.runtimeAbiHash,
+    resolveConditions: ["browser", "development", "module", "import"],
+    configFiles: clientConfigFiles(projectRoot),
+    configEnvironment: clientConfigEnvironment(),
+    entries,
+    packages: [...graphPackages.values()].sort(
+      (left, right) => left.path.localeCompare(right.path)
+    )
+  };
+  return {
+    graph,
+    hash: crypto.createHash("sha256").update(canonicalize(graph)).digest("hex"),
+    optimizeDependencies: discovery.optimizeDependencies
+  };
+}
+export {
+  buildClientDependencyGraph,
+  packageNameFromSpecifier
+};