@pie-element/cli 0.1.1 → 0.1.2-next.0

package/dist/utils/conversion.js.map

@@ -1 +1 @@
-{"version":3,"file":"conversion.js","sourceRoot":"","sources":["../../src/utils/conversion.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"conversion.js","sourceRoot":"","sources":["../../src/utils/conversion.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * JavaScript to TypeScript conversion utilities\n */\n\nexport interface ConversionMetadata {\n  sourcePath: string;\n  commit: string;\n}\n\nexport interface ConversionResult {\n  code: string;\n  hasDefaultObjectExport: boolean;\n}\n\n/**\n * Convert JavaScript to TypeScript\n */\nexport function convertJsToTs(jsCode: string, metadata: ConversionMetadata): ConversionResult {\n  // We intentionally do NOT transform the JavaScript syntax.\n  // Goal: keep upstream source as-is, while letting the monorepo's TS/Vite pipeline build it.\n  // TypeScript diagnostics are suppressed for synced files.\n  let tsCode = jsCode;\n  const hasDefaultObjectExport = false;\n\n  // Convert CommonJS module.exports to ES modules\n  tsCode = convertModuleExportsToEsm(tsCode);\n\n  // Must be at the very top of the file to reliably suppress TypeScript diagnostics.\n  // We keep synced files buildable even when upstream JS has type issues.\n  const tsNoCheck = `// @ts-nocheck\\n`;\n\n  // Add sync metadata header\n  const header = `/**\n * @synced-from ${metadata.sourcePath}\n * @auto-generated\n *\n * This file is automatically synced from pie-elements and converted to TypeScript.\n * Manual edits will be overwritten on next sync.\n * To make changes, edit the upstream JavaScript file and run sync again.\n */\n\n`;\n  return { code: tsNoCheck + header + tsCode, hasDefaultObjectExport };\n}\n\n/**\n * Convert CommonJS module.exports to ES module exports\n */\nfunction convertModuleExportsToEsm(content: string): string {\n  // Match: module.exports = { key: value, key2: value2, ... };\n  const moduleExportsPattern = /module\\.exports\\s*=\\s*\\{([\\s\\S]*?)\\};?/;\n  const match = content.match(moduleExportsPattern);\n\n  if (!match) {\n    return content;\n  }\n\n  const [fullMatch, objectContent] = match;\n\n  // Parse the object content into key-value pairs\n  const exports: string[] = [];\n  const lines = objectContent.split('\\n');\n\n  let currentKey: string | null = null;\n  let currentValue: string[] = [];\n\n  for (const line of lines) {\n    const trimmed = line.trim();\n    if (!trimmed || trimmed === '{' || trimmed === '}') continue;\n\n    // Check if this line starts a new key\n    const keyMatch = trimmed.match(/^(\\w+):\\s*(.*)/);\n    if (keyMatch) {\n      // Save previous export if any\n      if (currentKey) {\n        const value = currentValue.join('\\n').replace(/,\\s*$/, ''); // Remove trailing comma\n        exports.push(`export const ${currentKey} =\\n${value};`);\n      }\n\n      // Start new export\n      currentKey = keyMatch[1];\n      currentValue = [keyMatch[2]];\n    } else {\n      // Continuation of current value\n      currentValue.push(line);\n    }\n  }\n\n  // Save last export\n  if (currentKey) {\n    const value = currentValue.join('\\n').replace(/,\\s*$/, '');\n    exports.push(`export const ${currentKey} =\\n${value};`);\n  }\n\n  // Replace the module.exports block with ES module exports\n  const esmExports = exports.join('\\n\\n');\n  return content.replace(fullMatch, esmExports);\n}\n\n/**\n * Convert JSX to TSX\n */\nexport function convertJsxToTsx(jsxCode: string, metadata: ConversionMetadata): ConversionResult {\n  // We intentionally do NOT transform the JavaScript/JSX syntax.\n  // Goal: keep upstream source as-is, while letting the monorepo's TS/Vite pipeline build it.\n  // TypeScript diagnostics are suppressed for synced files.\n  const tsxCode = jsxCode;\n  const hasDefaultObjectExport = false;\n\n  // Must be at the very top of the file to reliably suppress TypeScript diagnostics.\n  // We keep synced files buildable even when upstream JSX has type issues.\n  const tsNoCheck = `// @ts-nocheck\\n`;\n\n  // Add sync metadata header\n  const header = `/**\n * @synced-from ${metadata.sourcePath}\n * @auto-generated\n *\n * This file is automatically synced from pie-elements and converted to TypeScript.\n * Manual edits will be overwritten on next sync.\n * To make changes, edit the upstream JavaScript file and run sync again.\n */\n\n`;\n  return { code: tsNoCheck + header + tsxCode, hasDefaultObjectExport };\n}\n\n/**\n * Fix imports from default export files\n * Some files export default objects but are imported with named imports\n */\nexport function fixImports(content: string, hasDefaultObjectExport: boolean): string {\n  if (!hasDefaultObjectExport) {\n    return content;\n  }\n\n  // Convert: import { something } from './file'\n  // To: import * as file from './file'\n  // This is needed when the imported file has export default {}\n  return content.replace(\n    /import\\s+{\\s*([^}]+)\\s*}\\s+from\\s+(['\"]\\.\\/[^'\"]+['\"])/g,\n    (_match, _imports, path) => {\n      // Extract filename from path\n      const filename =\n        path\n          .replace(/['\"]/g, '')\n          .split('/')\n          .pop()\n          ?.replace(/\\.\\w+$/, '') || 'module';\n      return `import * as ${filename} from ${path}`;\n    }\n  );\n}\n"]}

package/dist/utils/dependency-integrity.d.ts

@@ -0,0 +1,37 @@
+export type ImportIntegrityStatus = 'direct' | 'transitive' | 'hoist' | 'broken' | 'peer';
+export interface ImportIntegrityIssue {
+    dependency: string;
+    status: ImportIntegrityStatus;
+    declaredDirect: boolean;
+    resolvedPath?: string;
+    requiredBy?: string;
+}
+export interface PackageIntegrityResult {
+    packageName: string;
+    packagePath: string;
+    issues: ImportIntegrityIssue[];
+}
+interface CollectWorkspaceOptions {
+    includeNonPackageWorkspaces?: boolean;
+}
+interface AnalyzeIntegrityOptions {
+    includePeerGaps?: boolean;
+}
+export interface AutoFixDependencyOptions extends CollectWorkspaceOptions {
+    packageName?: string;
+    includeTransitive?: boolean;
+    includePeerGaps?: boolean;
+}
+export interface AutoFixDependencyResult {
+    packagesScanned: number;
+    packagesUpdated: number;
+    dependenciesAdded: number;
+    unresolved: Array<{
+        packageName: string;
+        dependency: string;
+    }>;
+}
+export declare function analyzePackageDependencyIntegrity(packagePath: string, options?: AnalyzeIntegrityOptions): Promise<PackageIntegrityResult | null>;
+export declare function collectWorkspacePackageDirs(root: string, options?: CollectWorkspaceOptions): Promise<string[]>;
+export declare function autoFixWorkspaceDependencyDeclarations(root: string, options?: AutoFixDependencyOptions): Promise<AutoFixDependencyResult>;
+export {};

package/dist/utils/dependency-integrity.js

@@ -0,0 +1,557 @@
+import { createRequire, builtinModules } from 'node:module';
+import { existsSync } from 'node:fs';
+import { readFile, readdir, writeFile } from 'node:fs/promises';
+import { dirname, join, resolve } from 'node:path';
+import { init, parse } from 'es-module-lexer';
+import { loadPackageJson } from './package-json.js';
+const BUILTIN_SET = new Set([...builtinModules, ...builtinModules.map((m) => `node:${m}`)]);
+const VALID_BARE_SPECIFIER = /^(@[a-z0-9._-]+\/[a-z0-9._-]+|[a-z0-9._-]+)(\/[a-z0-9._-]+)*$/i;
+const WORKSPACE_SCAN_PREFIXES = ['packages/', 'apps/', 'tools/'];
+const PLACEHOLDER_IMPORT_SPECIFIERS = new Set(['package', 'x']);
+const IGNORED_PEER_DEPENDENCIES = new Set([
+    'react',
+    'react-dom',
+    '@emotion/react',
+    '@emotion/styled',
+    '@emotion/core',
+]);
+const FALLBACK_DEPENDENCY_VERSIONS = {
+    'js-combinatorics': '^2.1.2',
+    'nested-property': '^4.0.0',
+    'prosemirror-state': '^1.4.4',
+    '@testing-library/react': '^16.3.2',
+    '@testing-library/dom': '^10.4.1',
+    '@tiptap/extensions': '^3.20.0',
+    '@tiptap/extension-list': '^3.20.0',
+    '@tiptap/extension-code-block': '^3.20.0',
+    'react-is': '^19.2.0',
+    pluralize: '^8.0.0',
+};
+export async function analyzePackageDependencyIntegrity(packagePath, options = {}) {
+    const absPackagePath = resolve(packagePath);
+    const pkgJsonPath = join(absPackagePath, 'package.json');
+    if (!existsSync(pkgJsonPath)) {
+        return null;
+    }
+    const pkgJson = (await loadPackageJson(pkgJsonPath));
+    if (!pkgJson?.name) {
+        return null;
+    }
+    const sourceDir = join(absPackagePath, 'src');
+    if (!existsSync(sourceDir)) {
+        return {
+            packageName: pkgJson.name,
+            packagePath: absPackagePath,
+            issues: [],
+        };
+    }
+    const importedPackages = await collectImportedPackages(sourceDir);
+    const declaredDirect = new Set([
+        ...Object.keys(pkgJson.dependencies || {}),
+        ...Object.keys(pkgJson.devDependencies || {}),
+        ...Object.keys(pkgJson.peerDependencies || {}),
+        ...Object.keys(pkgJson.optionalDependencies || {}),
+    ]);
+    const resolveFromPackage = createRequire(pkgJsonPath);
+    const transitiveNames = await collectTransitiveDependencyNames(resolveFromPackage, declaredDirect);
+    const issues = [];
+    for (const dep of Array.from(importedPackages.keys()).sort()) {
+        if (dep === pkgJson.name) {
+            continue;
+        }
+        const direct = declaredDirect.has(dep);
+        const specifiers = importedPackages.get(dep) || new Set([dep]);
+        const resolvedPath = resolveDependencyFromPackage(resolveFromPackage, dep, specifiers);
+        if (!resolvedPath) {
+            if (direct) {
+                const declaredManifest = resolveDeclaredPackageManifest(resolveFromPackage, dep);
+                if (declaredManifest) {
+                    continue;
+                }
+            }
+            issues.push({
+                dependency: dep,
+                status: 'broken',
+                declaredDirect: direct,
+            });
+            continue;
+        }
+        if (direct) {
+            continue;
+        }
+        if (transitiveNames.has(dep)) {
+            issues.push({
+                dependency: dep,
+                status: 'transitive',
+                declaredDirect: false,
+                resolvedPath,
+            });
+        }
+        else {
+            issues.push({
+                dependency: dep,
+                status: 'hoist',
+                declaredDirect: false,
+                resolvedPath,
+            });
+        }
+    }
+    if (options.includePeerGaps) {
+        const peerIssues = await collectMissingPeerDependencyIssues(pkgJson, declaredDirect, resolveFromPackage);
+        for (const peerIssue of peerIssues) {
+            const alreadyReported = issues.some((issue) => issue.dependency === peerIssue.dependency);
+            if (!alreadyReported) {
+                issues.push(peerIssue);
+            }
+        }
+    }
+    return {
+        packageName: pkgJson.name,
+        packagePath: absPackagePath,
+        issues,
+    };
+}
+export async function collectWorkspacePackageDirs(root, options = {}) {
+    const absRoot = resolve(root);
+    const out = new Set();
+    const rootPkgPath = join(absRoot, 'package.json');
+    const rootPkg = (await loadPackageJson(rootPkgPath));
+    const workspaces = rootPkg?.workspaces || [];
+    for (const pattern of workspaces) {
+        if (!WORKSPACE_SCAN_PREFIXES.some((prefix) => pattern.startsWith(prefix))) {
+            continue;
+        }
+        const isPackagesWorkspace = pattern.startsWith('packages/');
+        if (!isPackagesWorkspace && !options.includeNonPackageWorkspaces) {
+            continue;
+        }
+        const matches = await expandWorkspacePattern(absRoot, pattern);
+        for (const match of matches) {
+            if (existsSync(join(match, 'package.json'))) {
+                out.add(match);
+            }
+        }
+    }
+    return Array.from(out).sort();
+}
+async function expandWorkspacePattern(root, pattern) {
+    const normalized = pattern.replace(/\\/g, '/').replace(/\/$/, '');
+    if (!normalized.includes('*')) {
+        return [join(root, normalized)];
+    }
+    const [prefix, suffix = ''] = normalized.split('*');
+    const prefixPath = join(root, prefix);
+    if (!existsSync(prefixPath)) {
+        return [];
+    }
+    const dirEntries = await readdir(prefixPath, { withFileTypes: true });
+    const matches = [];
+    for (const entry of dirEntries) {
+        if (!entry.isDirectory()) {
+            continue;
+        }
+        const candidate = join(prefixPath, entry.name, suffix);
+        if (existsSync(candidate)) {
+            matches.push(candidate);
+        }
+    }
+    return matches;
+}
+function resolveDependencyFromPackage(resolveFromPackage, dep, specifiers) {
+    const candidates = new Set([...specifiers, dep]);
+    for (const candidate of candidates) {
+        try {
+            return resolveFromPackage.resolve(candidate);
+        }
+        catch {
+            // try next candidate
+        }
+    }
+    return null;
+}
+function resolveDeclaredPackageManifest(resolveFromPackage, dep) {
+    const searchPaths = resolveFromPackage.resolve.paths(dep) || [];
+    for (const basePath of searchPaths) {
+        const manifestPath = join(basePath, dep, 'package.json');
+        if (existsSync(manifestPath)) {
+            return manifestPath;
+        }
+    }
+    return null;
+}
+async function collectMissingPeerDependencyIssues(pkgJson, declaredDirect, resolveFromPackage) {
+    const issues = [];
+    const checkedPeers = new Set();
+    for (const directDep of Array.from(declaredDirect)) {
+        if (!directDep || directDep === pkgJson.name)
+            continue;
+        const depRoot = await resolvePackageRoot(resolveFromPackage, directDep);
+        const depPkgPath = depRoot && existsSync(join(depRoot, 'package.json'))
+            ? join(depRoot, 'package.json')
+            : resolveDeclaredPackageManifest(resolveFromPackage, directDep);
+        if (!depPkgPath || !existsSync(depPkgPath)) {
+            continue;
+        }
+        const depPkg = (await loadPackageJson(depPkgPath).catch(() => null));
+        if (!depPkg?.peerDependencies || typeof depPkg.peerDependencies !== 'object') {
+            continue;
+        }
+        const optionalPeers = new Set(Object.entries(depPkg.peerDependenciesMeta || {})
+            .filter(([, meta]) => meta?.optional)
+            .map(([name]) => name));
+        for (const peerDep of Object.keys(depPkg.peerDependencies)) {
+            if (!peerDep || peerDep === pkgJson.name || optionalPeers.has(peerDep))
+                continue;
+            if (IGNORED_PEER_DEPENDENCIES.has(peerDep))
+                continue;
+            if (declaredDirect.has(peerDep) || checkedPeers.has(peerDep))
+                continue;
+            checkedPeers.add(peerDep);
+            const resolvedPath = resolveDependencyFromPackage(resolveFromPackage, peerDep, new Set([peerDep]));
+            issues.push({
+                dependency: peerDep,
+                status: 'peer',
+                declaredDirect: false,
+                resolvedPath: resolvedPath || undefined,
+                requiredBy: directDep,
+            });
+        }
+    }
+    return issues;
+}
+async function collectImportedPackages(sourceDir) {
+    const files = await listSourceFiles(sourceDir);
+    const imported = new Map();
+    for (const file of files) {
+        const content = await readFile(file, 'utf-8');
+        if (file.includes('/src/lib/element-imports.') ||
+            content.includes('AUTO-GENERATED') ||
+            content.includes('DO NOT EDIT MANUALLY')) {
+            continue;
+        }
+        for (const importedSpec of await extractBareImports(content)) {
+            if (!imported.has(importedSpec.packageName)) {
+                imported.set(importedSpec.packageName, new Set());
+            }
+            imported.get(importedSpec.packageName)?.add(importedSpec.rawSpecifier);
+        }
+    }
+    return imported;
+}
+async function listSourceFiles(dir) {
+    const entries = await readdir(dir, { withFileTypes: true });
+    const files = [];
+    for (const entry of entries) {
+        const fullPath = join(dir, entry.name);
+        if (entry.isDirectory()) {
+            files.push(...(await listSourceFiles(fullPath)));
+            continue;
+        }
+        if (/\.(ts|tsx|js|jsx|mjs|cjs)$/.test(entry.name)) {
+            files.push(fullPath);
+        }
+    }
+    return files;
+}
+async function extractBareImports(content) {
+    const imports = new Map();
+    try {
+        await init;
+        const [parsedImports] = parse(content);
+        for (const parsed of parsedImports) {
+            const rawSpecifier = parsed.n;
+            if (!rawSpecifier)
+                continue;
+            const dep = normalizeBarePackageSpecifier(rawSpecifier);
+            if (!dep)
+                continue;
+            if (!imports.has(dep)) {
+                imports.set(dep, new Set());
+            }
+            imports.get(dep)?.add(rawSpecifier);
+        }
+    }
+    catch {
+        const staticPatterns = [
+            /^\s*import\s+[^'"]*?\s+from\s+['"]([^'"]+)['"]/gm,
+            /^\s*import\s*['"]([^'"]+)['"]/gm,
+            /^\s*export\s+[^'"]*?\s+from\s+['"]([^'"]+)['"]/gm,
+            /(?:^|[^\w$"'`])import\(\s*['"]([^'"]+)['"]\s*\)/gm,
+        ];
+        for (const pattern of staticPatterns) {
+            let match = pattern.exec(content);
+            while (match !== null) {
+                const rawSpecifier = match[1];
+                const dep = normalizeBarePackageSpecifier(rawSpecifier);
+                if (dep) {
+                    if (!imports.has(dep)) {
+                        imports.set(dep, new Set());
+                    }
+                    imports.get(dep)?.add(rawSpecifier);
+                }
+                match = pattern.exec(content);
+            }
+        }
+    }
+    const requireContent = stripComments(content);
+    const requirePattern = /^\s*(?:const|let|var)?[\w${}\s,*=:.[\]-]*\brequire\(\s*['"]([^'"]+)['"]\s*\)/gm;
+    let requireMatch = requirePattern.exec(requireContent);
+    while (requireMatch !== null) {
+        const rawSpecifier = requireMatch[1];
+        const dep = normalizeBarePackageSpecifier(rawSpecifier);
+        if (dep) {
+            if (!imports.has(dep)) {
+                imports.set(dep, new Set());
+            }
+            imports.get(dep)?.add(rawSpecifier);
+        }
+        requireMatch = requirePattern.exec(requireContent);
+    }
+    const out = [];
+    for (const [packageName, specifiers] of imports) {
+        for (const rawSpecifier of specifiers) {
+            out.push({ packageName, rawSpecifier });
+        }
+    }
+    return out;
+}
+function stripComments(content) {
+    return content.replace(/\/\*[\s\S]*?\*\//g, '').replace(/(^|[^\\:])\/\/.*$/gm, '$1');
+}
+function normalizeBarePackageSpecifier(specifier) {
+    if (!specifier ||
+        specifier.startsWith('.') ||
+        specifier.startsWith('/') ||
+        specifier.startsWith('node:') ||
+        specifier.startsWith('$')) {
+        return null;
+    }
+    if (BUILTIN_SET.has(specifier)) {
+        return null;
+    }
+    // Ignore virtual modules and URL/protocol specifiers.
+    if (specifier.includes(':')) {
+        return null;
+    }
+    if (!VALID_BARE_SPECIFIER.test(specifier)) {
+        return null;
+    }
+    if (PLACEHOLDER_IMPORT_SPECIFIERS.has(specifier)) {
+        return null;
+    }
+    if (specifier.startsWith('@')) {
+        const parts = specifier.split('/');
+        return parts.length >= 2 ? `${parts[0]}/${parts[1]}` : null;
+    }
+    return specifier.split('/')[0] || null;
+}
+async function collectTransitiveDependencyNames(resolveFromPackage, roots) {
+    const seen = new Set();
+    const queue = Array.from(roots);
+    const transitive = new Set();
+    while (queue.length > 0) {
+        const dep = queue.shift();
+        if (!dep || seen.has(dep))
+            continue;
+        seen.add(dep);
+        transitive.add(dep);
+        const root = await resolvePackageRoot(resolveFromPackage, dep);
+        if (!root)
+            continue;
+        const pkgJsonPath = join(root, 'package.json');
+        if (!existsSync(pkgJsonPath))
+            continue;
+        let pkg = null;
+        try {
+            pkg = (await loadPackageJson(pkgJsonPath));
+        }
+        catch {
+            pkg = null;
+        }
+        if (!pkg)
+            continue;
+        const childDeps = Object.keys(pkg.dependencies || {});
+        for (const child of childDeps) {
+            if (!seen.has(child))
+                queue.push(child);
+        }
+    }
+    return transitive;
+}
+export async function autoFixWorkspaceDependencyDeclarations(root, options = {}) {
+    const absRoot = resolve(root);
+    const packageDirs = await collectWorkspacePackageDirs(absRoot, {
+        includeNonPackageWorkspaces: options.includeNonPackageWorkspaces,
+    });
+    const catalog = await buildDependencyVersionCatalog(absRoot, packageDirs);
+    const workspacePackages = await buildWorkspacePackageNameMap(packageDirs);
+    let packagesScanned = 0;
+    let packagesUpdated = 0;
+    let dependenciesAdded = 0;
+    const unresolved = [];
+    for (const packageDir of packageDirs) {
+        const analysis = await analyzePackageDependencyIntegrity(packageDir, {
+            includePeerGaps: options.includePeerGaps,
+        });
+        if (!analysis)
+            continue;
+        if (options.packageName && analysis.packageName !== options.packageName) {
+            continue;
+        }
+        packagesScanned++;
+        const pkgJsonPath = join(packageDir, 'package.json');
+        const pkgJson = (await loadPackageJson(pkgJsonPath));
+        if (!pkgJson)
+            continue;
+        const needs = analysis.issues.filter((issue) => {
+            if (issue.declaredDirect) {
+                return false;
+            }
+            if (issue.status === 'hoist' || issue.status === 'broken' || issue.status === 'peer') {
+                return true;
+            }
+            return options.includeTransitive === true && issue.status === 'transitive';
+        });
+        if (needs.length === 0) {
+            continue;
+        }
+        if (!pkgJson.dependencies || typeof pkgJson.dependencies !== 'object') {
+            pkgJson.dependencies = {};
+        }
+        const deps = pkgJson.dependencies;
+        let modified = false;
+        for (const issue of needs) {
+            if (deps[issue.dependency]) {
+                continue;
+            }
+            const version = await resolveDependencyVersionForPackage(issue.dependency, pkgJsonPath, absRoot, catalog, workspacePackages);
+            if (!version) {
+                unresolved.push({ packageName: analysis.packageName, dependency: issue.dependency });
+                continue;
+            }
+            deps[issue.dependency] = version;
+            modified = true;
+            dependenciesAdded++;
+        }
+        if (modified) {
+            await writeFile(pkgJsonPath, `${JSON.stringify(pkgJson, null, 2)}\n`, 'utf-8');
+            packagesUpdated++;
+        }
+    }
+    return {
+        packagesScanned,
+        packagesUpdated,
+        dependenciesAdded,
+        unresolved,
+    };
+}
+async function buildWorkspacePackageNameMap(packageDirs) {
+    const map = new Map();
+    for (const packageDir of packageDirs) {
+        const pkgPath = join(packageDir, 'package.json');
+        if (!existsSync(pkgPath))
+            continue;
+        const pkg = (await loadPackageJson(pkgPath));
+        if (pkg?.name) {
+            map.set(pkg.name, packageDir);
+        }
+    }
+    return map;
+}
+async function buildDependencyVersionCatalog(rootDir, packageDirs) {
+    const catalog = new Map();
+    const addVersions = (record) => {
+        if (!record)
+            return;
+        for (const [name, version] of Object.entries(record)) {
+            if (!catalog.has(name)) {
+                catalog.set(name, version);
+            }
+        }
+    };
+    const rootPkgPath = join(rootDir, 'package.json');
+    if (existsSync(rootPkgPath)) {
+        const rootPkg = (await loadPackageJson(rootPkgPath));
+        if (rootPkg) {
+            addVersions(rootPkg.dependencies);
+            addVersions(rootPkg.devDependencies);
+            addVersions(rootPkg.peerDependencies);
+            addVersions(rootPkg.optionalDependencies);
+        }
+    }
+    for (const packageDir of packageDirs) {
+        const pkgPath = join(packageDir, 'package.json');
+        if (!existsSync(pkgPath))
+            continue;
+        const pkg = (await loadPackageJson(pkgPath));
+        if (!pkg)
+            continue;
+        addVersions(pkg.dependencies);
+        addVersions(pkg.devDependencies);
+        addVersions(pkg.peerDependencies);
+        addVersions(pkg.optionalDependencies);
+    }
+    return catalog;
+}
+async function resolveDependencyVersionForPackage(dep, pkgJsonPath, rootDir, catalog, workspacePackages) {
+    if (workspacePackages.has(dep)) {
+        return 'workspace:*';
+    }
+    const catalogVersion = catalog.get(dep);
+    if (catalogVersion) {
+        return catalogVersion;
+    }
+    if (FALLBACK_DEPENDENCY_VERSIONS[dep]) {
+        return FALLBACK_DEPENDENCY_VERSIONS[dep];
+    }
+    const requireFromPackage = createRequire(pkgJsonPath);
+    const packageRoot = await resolvePackageRoot(requireFromPackage, dep);
+    if (!packageRoot) {
+        return null;
+    }
+    const depPkgPath = join(packageRoot, 'package.json');
+    if (!existsSync(depPkgPath)) {
+        return null;
+    }
+    const depPkg = (await loadPackageJson(depPkgPath));
+    if (!depPkg?.version) {
+        return null;
+    }
+    // Keep workspace references if dependency resolves to local workspace package path.
+    if (packageRoot.startsWith(join(rootDir, 'packages')) ||
+        packageRoot.startsWith(join(rootDir, 'apps'))) {
+        return 'workspace:*';
+    }
+    return `^${depPkg.version}`;
+}
+async function resolvePackageRoot(resolveFromPackage, dep) {
+    let resolvedFile;
+    try {
+        resolvedFile = resolveFromPackage.resolve(dep);
+    }
+    catch {
+        return null;
+    }
+    let current = dirname(resolvedFile);
+    const floor = dirname(current);
+    while (current !== floor) {
+        const pkgJsonPath = join(current, 'package.json');
+        if (existsSync(pkgJsonPath)) {
+            try {
+                const pkg = (await loadPackageJson(pkgJsonPath));
+                if (pkg.name === dep) {
+                    return current;
+                }
+            }
+            catch {
+                // ignore parse/load errors and keep walking
+            }
+        }
+        const parent = dirname(current);
+        if (parent === current)
+            break;
+        current = parent;
+    }
+    return null;
+}
+//# sourceMappingURL=dependency-integrity.js.map