zova-cli-set-front 1.2.113 → 1.2.115

package/dist/index.js

@@ -6,18 +6,18 @@ import { rimraf } from 'rimraf';
 import { rolldown } from 'rolldown';
 import { dts } from 'rolldown-plugin-dts';
 import { build } from 'vite';
-import { createRequire } from 'node:module';
+import { createRequire, isBuiltin } from 'node:module';
 import { camelToKebab, toUpperCaseFirstChar, toLowerCaseFirstChar, skipPrefix, stringToCapitalize, replaceTemplate } from '@cabloy/word-utils';
 import fse from 'fs-extra';
 import { build as build$1 } from 'tsdown';
-import yaml from 'yaml';
 import { createConfigUtils, saveJSONFile as saveJSONFile$1 } from 'zova-vite';
+import ts from 'typescript';
+import yaml from 'yaml';
 import fs from 'node:fs';
 import 'node:url';
 import { getOnionScenesMeta, getOnionMetasMeta } from '@cabloy/module-info';
 import { extend } from '@cabloy/extend';
 import { catchError, matchSelector, getPropertyObject, evaluateSimple, StringPrefixRegexp } from '@cabloy/utils';
-import ts from 'typescript';
 import { globbySync, globby } from 'globby';
 import gogocode from 'gogocode';
 import { optimize } from 'svgo';
@@ -151,6 +151,213 @@ class CliBinBuildModule extends BeanCliBase {
   }
 }
 
+function extractRestDependencies(content) {
+  const source = ts.createSourceFile('index.d.mts', content, ts.ScriptTarget.Latest);
+  // createSourceFile exposes syntax diagnostics at runtime, but not in its public return type.
+  const {
+    parseDiagnostics
+  } = source;
+  if (parseDiagnostics.length) {
+    const diagnostic = parseDiagnostics[0];
+    const {
+      line,
+      character
+    } = source.getLineAndCharacterOfPosition(diagnostic.start ?? 0);
+    throw new Error(`Invalid REST declaration at ${source.fileName}:${line + 1}:${character + 1}: ${ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n')}`);
+  }
+  for (const kind of ['path', 'types']) {
+    const references = kind === 'path' ? source.referencedFiles : source.typeReferenceDirectives;
+    if (references.length) {
+      throw new Error(`Unsupported REST declaration reference directive: ${kind} ${JSON.stringify(references[0].fileName)}. ` + 'The current REST bundling workflow does not support this directive.');
+    }
+  }
+  // lib references are compiler-owned, not package dependencies.
+  const dependencies = new Set();
+  function addDependency(specifier) {
+    if (!specifier) return;
+    if (!ts.isStringLiteral(specifier)) {
+      throw new Error('Unsupported REST declaration module specifier');
+    }
+    const id = specifier.text;
+    if (id.startsWith('.') || id.startsWith('#') || id.startsWith('\0') || path.isAbsolute(id) || path.win32.isAbsolute(id) || /^[a-z][a-z\d+.-]*:/i.test(id) || isBuiltin(id)) {
+      return;
+    }
+    if (!id || id.includes(':')) {
+      throw new Error(`Unsupported REST declaration package reference: ${id}`);
+    }
+    const parts = id.split('/');
+    if (id.startsWith('@') && (!parts[0].slice(1) || !parts[1])) {
+      throw new Error(`Invalid REST declaration package reference: ${id}`);
+    }
+    dependencies.add(parts.slice(0, id.startsWith('@') ? 2 : 1).join('/'));
+  }
+  function visit(node) {
+    if (ts.isImportDeclaration(node) || ts.isExportDeclaration(node)) {
+      addDependency(node.moduleSpecifier);
+    } else if (ts.isImportTypeNode(node)) {
+      if (!ts.isLiteralTypeNode(node.argument)) {
+        throw new Error('Unsupported REST declaration import type');
+      }
+      addDependency(node.argument.literal);
+    } else if (ts.isImportEqualsDeclaration(node) && ts.isExternalModuleReference(node.moduleReference)) {
+      addDependency(node.moduleReference.expression);
+    } else if (ts.isCallExpression(node) && node.expression.kind === ts.SyntaxKind.ImportKeyword) {
+      throw new Error('Unsupported REST declaration dynamic import');
+    }
+    ts.forEachChild(node, visit);
+  }
+  visit(source);
+  return Array.from(dependencies).sort();
+}
+
+const dependencySections = ['dependencies', 'devDependencies', 'optionalDependencies'];
+async function extractRestDependencyVersions(projectPath, deps, moduleRoots = []) {
+  const lockfilePath = path.join(projectPath, 'pnpm-lock.yaml');
+  const lockfileContent = await fse.readFile(lockfilePath, 'utf8');
+  const parsedLockfile = parseWorkspaceLockfile(lockfileContent);
+  const depsVersion = {};
+  for (const dep of deps) {
+    const rootRange = getPackageDependencyRangeFromLock(parsedLockfile, dep);
+    if (rootRange) {
+      depsVersion[dep] = rootRange;
+      continue;
+    }
+    const moduleCandidates = await getModuleCandidates(projectPath, parsedLockfile, dep, moduleRoots);
+    const distinctCandidates = getDistinctCandidates(moduleCandidates);
+    if (distinctCandidates.length > 1) {
+      throw createConflictingCandidatesError(dep, distinctCandidates);
+    }
+    if (distinctCandidates.length === 1) {
+      depsVersion[dep] = distinctCandidates[0].range;
+      continue;
+    }
+    const rootVersion = await getPackageVersionFromNodeModules(projectPath, dep);
+    if (rootVersion) {
+      depsVersion[dep] = `^${rootVersion}`;
+      continue;
+    }
+    throw createUnresolvedDependencyError(projectPath, dep, moduleRoots);
+  }
+  return depsVersion;
+}
+function parseWorkspaceLockfile(content) {
+  const documents = yaml.parseAllDocuments(content);
+  for (const document of documents) {
+    if (document.errors.length) throw document.errors[0];
+  }
+
+  // pnpm 12 places the workspace lock after its package-manager/config dependency lock.
+  const document = documents.findLast(({
+    contents
+  }) => {
+    return contents !== null && !(yaml.isScalar(contents) && contents.value === null && contents.source === '');
+  });
+  if (!document || !yaml.isMap(document.contents) || !yaml.isMap(document.get('importers', true))) {
+    throw new Error('Invalid pnpm-lock.yaml: expected a workspace document with an importers mapping.');
+  }
+  return document.toJS();
+}
+function getPackageDependencyRangeFromLock(parsedLockfile, packageName) {
+  const importer = parsedLockfile.importers?.['.'];
+  return getImporterDependencyRange(importer, packageName);
+}
+function getImporterDependencyRange(importer, packageName) {
+  if (!importer) return null;
+  for (const section of dependencySections) {
+    const dependencyRange = normalizeImporterDependency(importer[section]?.[packageName]);
+    if (dependencyRange) return dependencyRange;
+  }
+  return null;
+}
+function normalizeImporterDependency(importerDependency) {
+  if (!importerDependency) return null;
+  const specifier = importerDependency.specifier;
+  if (specifier?.startsWith('npm:')) return specifier;
+  const version = normalizeLockfileVersion(importerDependency.version);
+  if (!version) return null;
+  return `^${version}`;
+}
+function normalizeLockfileVersion(version) {
+  if (!version) return null;
+  if (version.startsWith('link:') || version.startsWith('file:')) return null;
+  const versionWithoutPeers = version.split('(')[0];
+  if (!versionWithoutPeers) return null;
+  if (/^\d/.test(versionWithoutPeers)) return versionWithoutPeers;
+  const aliasSeparator = versionWithoutPeers.lastIndexOf('@');
+  if (aliasSeparator === -1) return null;
+  const aliasedVersion = versionWithoutPeers.slice(aliasSeparator + 1);
+  if (!aliasedVersion || !/^\d/.test(aliasedVersion)) return null;
+  return aliasedVersion;
+}
+async function getModuleCandidates(projectPath, parsedLockfile, packageName, moduleRoots) {
+  const candidates = [];
+  for (const moduleRoot of moduleRoots) {
+    const absoluteModuleRoot = path.resolve(projectPath, moduleRoot);
+    if (absoluteModuleRoot === path.resolve(projectPath)) continue;
+    const importerKey = getImporterKey(projectPath, absoluteModuleRoot);
+    const importerRange = getImporterDependencyRange(parsedLockfile.importers?.[importerKey], packageName);
+    if (importerRange) {
+      candidates.push({
+        range: importerRange,
+        moduleRoot: importerKey
+      });
+      continue;
+    }
+    const manifestSpecifier = await getManifestDependencySpecifier(absoluteModuleRoot, packageName);
+    if (!manifestSpecifier) continue;
+    const installedVersion = await getPackageVersionFromNodeModules(absoluteModuleRoot, packageName);
+    if (!installedVersion) continue;
+    candidates.push({
+      range: manifestSpecifier.startsWith('npm:') ? manifestSpecifier : `^${installedVersion}`,
+      moduleRoot: importerKey
+    });
+  }
+  return candidates;
+}
+async function getManifestDependencySpecifier(moduleRoot, packageName) {
+  const manifestPath = path.join(moduleRoot, 'package.json');
+  if (!fse.existsSync(manifestPath)) return null;
+  const manifest = await fse.readJson(manifestPath);
+  for (const section of dependencySections) {
+    const sectionDependencies = manifest[section];
+    if (!sectionDependencies || typeof sectionDependencies !== 'object') continue;
+    const specifier = sectionDependencies[packageName];
+    if (typeof specifier === 'string') return specifier;
+  }
+  return null;
+}
+function getDistinctCandidates(candidates) {
+  const distinctCandidates = new Map();
+  for (const candidate of candidates) {
+    if (!distinctCandidates.has(candidate.range)) {
+      distinctCandidates.set(candidate.range, candidate);
+    }
+  }
+  return Array.from(distinctCandidates.values());
+}
+async function getPackageVersionFromNodeModules(packageRoot, packageName) {
+  const pkgFile = path.join(packageRoot, 'node_modules', packageName, 'package.json');
+  if (!fse.existsSync(pkgFile)) return null;
+  const pkgContent = await fse.readJson(pkgFile);
+  return typeof pkgContent.version === 'string' && pkgContent.version ? pkgContent.version : null;
+}
+function getImporterKey(projectPath, moduleRoot) {
+  const relativePath = path.relative(projectPath, moduleRoot);
+  return relativePath.replaceAll(path.sep, '/') || '.';
+}
+function getRepoRelativePath(projectPath, filePath) {
+  const relativePath = path.relative(projectPath, filePath).replaceAll(path.sep, '/');
+  return relativePath || '.';
+}
+function createConflictingCandidatesError(packageName, candidates) {
+  const details = candidates.map(candidate => `${candidate.moduleRoot} (${candidate.range})`).join(', ');
+  return new Error(`Conflicting REST dependency versions for ${packageName} in module importers: ${details}. ` + `Align the dependency versions or declare ${packageName} in the project root package.json ` + '(pnpm-lock.yaml).');
+}
+function createUnresolvedDependencyError(projectPath, packageName, moduleRoots) {
+  const checkedModuleRoots = moduleRoots.length ? moduleRoots.map(moduleRoot => getRepoRelativePath(projectPath, path.resolve(projectPath, moduleRoot))).join(', ') : '(none)';
+  return new Error(`Unable to resolve REST dependency version for ${packageName}. Add it to the project or an owning ` + `module and install it; checked module roots: ${checkedModuleRoots}; lockfile: pnpm-lock.yaml.`);
+}
+
 function getControllerFileName(module, type, beanName) {
   const controllerFile = path.join(module.root, `src/${type}/${beanName}/controller.ts`);
   if (fs.existsSync(controllerFile)) {
@@ -260,11 +467,13 @@ class CliBinBuildRest extends BeanCliBase {
     const modules = [];
     const bundleModules = [];
     const sideEffectImportModuleNames = [];
+    const moduleRoots = [];
     for (const module of modulesMeta.modulesArray) {
       const moduleName = module.info.fullName;
       modules.push(`import '${moduleName}';`);
       modules.push(`export * from '${moduleName}';`);
       const moduleRoot = module.root.replaceAll('\\', '/');
+      moduleRoots.push(moduleRoot);
       if (moduleRoot.includes('/src/module/') || moduleRoot.includes('/src/suite/')) {
         bundleModules.push(moduleName);
       } else {
@@ -273,6 +482,7 @@ class CliBinBuildRest extends BeanCliBase {
     }
     context.bundleModules = bundleModules;
     context.sideEffectImportModuleNames = sideEffectImportModuleNames;
+    context.moduleRoots = moduleRoots;
     argv.Modules = modules.join('\n');
     // Name/Version
     argv.Name = bundleName;
@@ -324,8 +534,7 @@ class CliBinBuildRest extends BeanCliBase {
       tsconfig: 'tsconfig.rest.json',
       clean: false,
       dts: {
-        // resolve: true,
-        resolver: 'tsc',
+        resolver: 'oxc',
         tsgo: true,
         eager: true,
         tsconfig: 'tsconfig.rest.json',
@@ -357,14 +566,15 @@ class CliBinBuildRest extends BeanCliBase {
       flavor,
       bundleNameCopy,
       outDir,
-      packageJson
+      packageJson,
+      moduleRoots
     } = buildContext;
     // build
     await this._buildTs(buildContext);
     await this._buildDts(buildContext);
     // deps
     const deps = await _extractDeps(path.join(outDir, 'index.d.mts'));
-    const depsVersion = await _extractDepsVersion(projectPath, deps);
+    const depsVersion = await extractRestDependencyVersions(projectPath, deps, moduleRoots);
     // package.json
     const pkgContent = {
       ...packageJson,
@@ -392,83 +602,8 @@ function _copyToTarget(outDir, target, bundleNameCopy, projectPath) {
   }
 }
 async function _extractDeps(filePath) {
-  let content = (await fse.readFile(filePath)).toString();
-  const pos = content.indexOf('//#region');
-  content = content.substring(0, pos);
-  const packageNames = new Set();
-  const re = /import\s+(?:[\s\S]*?\s+from\s+)?['"]([^'"]+)['"]/g;
-  let match;
-  while (true) {
-    match = re.exec(content);
-    if (!match) break;
-    let pkg = match[1];
-    if (pkg.startsWith('.') || pkg.startsWith('/')) continue;
-    if (pkg.startsWith('@')) {
-      if (pkg.split('/').length > 2) {
-        pkg = pkg.split('/').slice(0, 2).join('/');
-      }
-    } else {
-      if (pkg.split('/').length > 1) {
-        pkg = pkg.split('/').slice(0, 1).join('/');
-      }
-    }
-    packageNames.add(pkg);
-  }
-  return Array.from(packageNames).sort();
-}
-async function _extractDepsVersion(projectPath, deps) {
-  const lockfilePath = path.join(projectPath, 'pnpm-lock.yaml');
-  const lockfileContent = (await fse.readFile(lockfilePath)).toString();
-  const parsedLockfile = yaml.parse(lockfileContent);
-  const depsVersion = {};
-  for (const dep of deps) {
-    let dependencyRange = getPackageDependencyRangeFromLock(parsedLockfile, dep);
-    if (!dependencyRange) {
-      const version = await getPackageVersionFromNodeModules(projectPath, dep);
-      dependencyRange = version ? `^${version}` : null;
-    }
-    if (!dependencyRange) {
-      console.warn('dep version not found: ', dep);
-      continue;
-    }
-    depsVersion[dep] = dependencyRange;
-  }
-  return depsVersion;
-}
-function getPackageDependencyRangeFromLock(parsedLockfile, packageName) {
-  const importer = parsedLockfile.importers?.['.'];
-  const sections = ['dependencies', 'devDependencies', 'optionalDependencies'];
-  for (const section of sections) {
-    const dependencyRange = getImporterDependencyRange(importer?.[section]?.[packageName]);
-    if (dependencyRange) return dependencyRange;
-  }
-  return null;
-}
-function getImporterDependencyRange(importerDependency) {
-  if (!importerDependency) return null;
-  const specifier = importerDependency.specifier;
-  if (specifier?.startsWith('npm:')) return specifier;
-  const version = normalizeLockfileVersion(importerDependency.version);
-  if (!version) return null;
-  return `^${version}`;
-}
-function normalizeLockfileVersion(version) {
-  if (!version) return null;
-  if (version.startsWith('link:') || version.startsWith('file:')) return null;
-  const versionWithoutPeers = version.split('(')[0];
-  if (!versionWithoutPeers) return null;
-  if (/^\d/.test(versionWithoutPeers)) return versionWithoutPeers;
-  const aliasSeparator = versionWithoutPeers.lastIndexOf('@');
-  if (aliasSeparator === -1) return null;
-  const aliasedVersion = versionWithoutPeers.slice(aliasSeparator + 1);
-  if (!aliasedVersion || !/^\d/.test(aliasedVersion)) return null;
-  return aliasedVersion;
-}
-async function getPackageVersionFromNodeModules(projectPath, packageName) {
-  const pkgFile = path.join(projectPath, 'node_modules', packageName, 'package.json');
-  if (!fse.existsSync(pkgFile)) return null;
-  const pkgContent = await loadJSONFile(pkgFile);
-  return pkgContent.version;
+  const content = await fse.readFile(filePath, 'utf8');
+  return extractRestDependencies(content);
 }
 
 let __snippetsPathPrefix;

package/dist/lib/bean/cli.bin.buildRest.d.ts

@@ -23,6 +23,7 @@ interface IBinBuildRestContext {
     outDir: string;
     bundleModules?: string[];
     sideEffectImportModuleNames?: string[];
+    moduleRoots?: string[];
     packageJson?: IBinBuildRestPackageJson;
 }
 export declare class CliBinBuildRest extends BeanCliBase {

package/dist/lib/common/restDependencies.d.ts

@@ -0,0 +1 @@
+export declare function extractRestDependencies(content: string): string[];

package/dist/lib/common/restDependencyVersions.d.ts

@@ -0,0 +1 @@
+export declare function extractRestDependencyVersions(projectPath: string, deps: string[], moduleRoots?: string[]): Promise<Record<string, string>>;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "zova-cli-set-front",
-  "version": "1.2.113",
-  "gitHead": "3dddb11c81f79753b36a886b3462cb401308f530",
+  "version": "1.2.115",
+  "gitHead": "c4185c759d9e8933a078182614a83fd43031659f",
   "description": "zova cli-set-front",
   "keywords": [
     "framework",