@jointhedots/gear 1.1.14 → 1.1.15

package/esm/builder/helpers/emit-typescript-definition.js

@@ -2,7 +2,8 @@ import Fs from 'fs';
 import Os from 'os';
 import Path from 'path';
 import Ts from 'typescript';
-import { execFileSync } from 'child_process';
+import { execFile } from 'child_process';
+import { promisify } from 'util';
 import { BuildTask } from "./task.js";
 import { BuildTarget } from "../build-target.js";
 import { Library } from "../../model/workspace.js";
@@ -93,7 +94,7 @@ class TypescriptProject {
         this.dtsDir = Fs.mkdtempSync(Path.join(Os.tmpdir(), 'gear-dts-'));
     }
     /** Run tsgo to emit .d.ts files into dtsDir. Returns stderr output. */
-    emitWithTsgo() {
+    async emitWithTsgo() {
         const tsgoPath = Path.resolve('node_modules/.bin/tsgo');
         const args = [
             '-p', Path.join(this.baseDir, 'tsconfig.json'),
@@ -103,17 +104,14 @@ class TypescriptProject {
             '--outDir', this.dtsDir,
         ];
         try {
-            execFileSync(tsgoPath, args, {
+            await promisify(execFile)(tsgoPath, args, {
                 cwd: this.baseDir,
-                stdio: ['pipe', 'pipe', 'pipe'],
                 timeout: 120_000,
                 shell: true,
             });
-            return '';
         }
         catch (e) {
             // tsgo may exit non-zero on type errors but still emit .d.ts files
-            return e.stderr?.toString() || e.message || '';
         }
     }
     /** Recursively collect all .d.ts files emitted by tsgo */
@@ -144,30 +142,11 @@ export function createTypescriptProject(baseDir, tsconfig, outDir) {
     return new TypescriptProject(baseDir, tsconfig, outDir);
 }
 export function generateTypescriptDefinition(options) {
-    const project = options.project;
+    const { project, prefix } = options;
     const baseDir = project.baseDir;
-    const dtsDir = project.dtsDir;
-    function isExcludedPath(fileName) {
-        return fileName.includes('/node_modules/') || fileName.includes('\\node_modules\\');
-    }
-    // Compute baseUrl prefix to strip from module paths
     const normalizedBaseDir = normalizeFileName(Path.resolve(baseDir)) + "/";
-    const normalizedDtsDir = normalizeFileName(Path.resolve(dtsDir)) + "/";
-    let baseUrlPrefix = '';
-    if (project.compilerOptions.baseUrl) {
-        const absoluteBaseUrl = Path.resolve(baseDir, project.compilerOptions.baseUrl);
-        const normalizedBaseUrl = normalizeFileName(absoluteBaseUrl);
-        baseUrlPrefix = normalizedBaseUrl.slice(normalizedBaseDir.length);
-        if (baseUrlPrefix && !baseUrlPrefix.endsWith('/')) {
-            baseUrlPrefix += '/';
-        }
-    }
-    function stripBaseUrlPrefix(modulePath) {
-        if (baseUrlPrefix && modulePath.startsWith(baseUrlPrefix)) {
-            return modulePath.slice(baseUrlPrefix.length);
-        }
-        return modulePath;
-    }
+    const normalizedDtsDir = normalizeFileName(Path.resolve(project.dtsDir)) + "/";
+    const resolveCache = new Map();
     const outputParts = [];
     if (options.externs) {
         options.externs.forEach(function (path) {
@@ -179,8 +158,7 @@ export function generateTypescriptDefinition(options) {
             outputParts.push(`/// <reference types="${type}" />` + eol);
         });
     }
-    // Map source-relative paths to internal: module IDs for ALL emitted files
-    const internalsMap = {};
+    // Process each emitted .d.ts file as internal: module
     const dtsFiles = project.getEmittedDtsFiles();
     for (const dtsPath of dtsFiles) {
         const normalizedDts = normalizeFileName(Path.resolve(dtsPath));
@@ -188,83 +166,55 @@ export function generateTypescriptDefinition(options) {
             continue;
         const relativeDts = normalizedDts.slice(normalizedDtsDir.length);
         const relativeSource = relativeDts.replace(/\.d\.ts$/, '');
-        const strippedSource = stripBaseUrlPrefix(relativeSource);
-        const moduleId = `${options.prefix}:${strippedSource}`;
-        internalsMap[relativeSource] = moduleId;
-        internalsMap[strippedSource] = moduleId;
-        if (strippedSource.endsWith('/index')) {
-            internalsMap[strippedSource.slice(0, -6)] = moduleId;
-        }
+        const data = Fs.readFileSync(dtsPath, 'utf-8');
+        const declFile = Ts.createSourceFile(dtsPath, data, Ts.ScriptTarget.Latest, true);
+        writeDeclaration(declFile, relativeSource);
     }
-    // Build public export map: maps export entry ID to internal module ID
-    const publicReexports = [];
+    // Emit public re-export modules
     if (options.exports) {
         for (const entry of Object.values(options.exports)) {
-            const fileName = entry.source;
-            if (isExcludedPath(fileName))
-                continue;
-            const normalizedSource = normalizeFileName(Path.resolve(fileName));
-            if (!normalizedSource.startsWith(normalizedBaseDir))
-                continue;
-            const shortName = normalizedSource.slice(normalizedBaseDir.length);
-            const shortNameNoExt = shortName.replace(/\.(ts|tsx|js|jsx)$/, '');
-            const strippedShortNameNoExt = stripBaseUrlPrefix(shortNameNoExt);
-            const internalId = internalsMap[shortNameNoExt] ||
-                internalsMap[strippedShortNameNoExt] ||
-                internalsMap[shortName];
+            const internalId = resolveInternalModuleImport(entry.source);
             if (internalId) {
-                publicReexports.push({ id: entry.id, internalId });
+                outputParts.push(`declare module '${entry.id}' {${eol}`);
+                outputParts.push(`${indent}export * from '${internalId}';${eol}`);
+                outputParts.push(`}${eol}${eol}`);
             }
         }
     }
-    // Unified module ID normalization
-    function normalizeModuleId(moduleId) {
-        moduleId = moduleId.replace(/\.(d\.ts|ts|tsx|js|jsx)$/, '');
-        moduleId = stripBaseUrlPrefix(moduleId);
-        const remapped = internalsMap[moduleId] ||
-            internalsMap[moduleId + "/index"] ||
-            internalsMap[moduleId + "/index.ts"];
-        return remapped || moduleId;
-    }
-    function isExternalModule(moduleId) {
-        return !internalsMap[moduleId];
-    }
-    // Process each emitted .d.ts file as internal: module
-    for (const dtsPath of dtsFiles) {
-        const normalizedDts = normalizeFileName(Path.resolve(dtsPath));
-        if (!normalizedDts.startsWith(normalizedDtsDir))
-            continue;
-        const relativeDts = normalizedDts.slice(normalizedDtsDir.length);
-        const relativeSource = relativeDts.replace(/\.d\.ts$/, '');
-        const data = Fs.readFileSync(dtsPath, 'utf-8');
-        const declFile = Ts.createSourceFile(dtsPath, data, Ts.ScriptTarget.Latest, true);
-        writeDeclaration(declFile, relativeSource);
-    }
-    // Emit public re-export modules
-    for (const { id, internalId } of publicReexports) {
-        outputParts.push(`declare module '${id}' {${eol}`);
-        outputParts.push(`${indent}export * from '${internalId}';${eol}`);
-        outputParts.push(`}${eol}${eol}`);
+    function resolveInternalModuleImport(moduleId, importDir = "") {
+        if (moduleId.charAt(0) === '.') {
+            return prefix + normalizeFileName(Path.join(importDir, moduleId));
+        }
+        if (resolveCache.has(moduleId))
+            return resolveCache.get(moduleId);
+        const containingFile = Path.resolve(baseDir, importDir, '__resolve.ts');
+        const result = Ts.resolveModuleName(moduleId, containingFile, project.compilerOptions, Ts.sys);
+        if (result.resolvedModule && !result.resolvedModule.isExternalLibraryImport) {
+            const resolved = normalizeFileName(result.resolvedModule.resolvedFileName);
+            if (resolved.startsWith(normalizedBaseDir)) {
+                const value = prefix + resolved.slice(normalizedBaseDir.length).replace(/\.(d\.ts|tsx?|jsx?)$/, '');
+                resolveCache.set(moduleId, value);
+                return value;
+            }
+        }
+        // Check if moduleId is already an internal path relative to baseDir
+        const absolute = normalizeFileName(Path.resolve(baseDir, importDir, moduleId));
+        if (absolute.startsWith(normalizedBaseDir)) {
+            const value = prefix + absolute.slice(normalizedBaseDir.length);
+            resolveCache.set(moduleId, value);
+            return value;
+        }
+        resolveCache.set(moduleId, null);
+        return null;
     }
     function writeDeclaration(declarationFile, rawSourceModuleId) {
-        const moduleDeclId = normalizeModuleId(rawSourceModuleId);
+        const moduleDeclId = resolveInternalModuleImport(rawSourceModuleId);
+        const moduleDir = Path.dirname(rawSourceModuleId);
         outputParts.push(`declare module '${moduleDeclId}' {${eol}${indent}`);
-        function resolveModuleImport(moduleId) {
-            let resolved;
-            if (moduleId.charAt(0) === '.') {
-                resolved = normalizeFileName(Path.join(Path.dirname(rawSourceModuleId), moduleId));
-            }
-            else {
-                resolved = moduleId;
-                if (isExternalModule(resolved))
-                    return resolved;
-            }
-            return normalizeModuleId(resolved);
-        }
         const content = processTree(declarationFile, function (node) {
             if (isNodeKindExternalModuleReference(node)) {
                 const expression = node.expression;
-                const resolved = resolveModuleImport(expression.text);
+                const resolved = resolveInternalModuleImport(expression.text, moduleDir) ?? expression.text;
                 return ` require('${resolved}')`;
             }
             else if (isNodeKindImportDeclaration(node) && !node.importClause) {
@@ -275,8 +225,8 @@ export function generateTypescriptDefinition(options) {
             }
             else if (isNodeKindStringLiteral(node) && node.parent &&
                 (isNodeKindExportDeclaration(node.parent) || isNodeKindImportDeclaration(node.parent) || isNodeKindImportType(node.parent?.parent))) {
-                const resolved = resolveModuleImport(node.text);
-                if (resolved) {
+                const resolved = resolveInternalModuleImport(node.text, moduleDir);
+                if (resolved != null) {
                     return ` '${resolved}'`;
                 }
             }
@@ -304,13 +254,10 @@ export class TypescriptDefinitionTask extends BuildTask {
             const configText = file.read.text(Path.join(lib.path, "./tsconfig.json"))
                 || file.read.text("./tsconfig.json");
             const project = createTypescriptProject(lib.path, configText, storage.getBaseDirFS());
-            const stderr = project.emitWithTsgo();
-            if (stderr) {
-                this.log.warn(stderr);
-            }
+            await project.emitWithTsgo();
             const { dts } = generateTypescriptDefinition({
                 project,
-                prefix: lib.name,
+                prefix: lib.name + ":",
                 exclude: ["node_modules/**/*"],
                 exports: create_export_map(lib, lib.bundle),
             });

package/esm/model/helpers/discover-workspace.js

@@ -7,6 +7,7 @@ import { create_bundle_manifest } from "./create-manifests.js";
 import { Bundle, Library, Workspace } from "../workspace.js";
 import { file, make_canonical_path, make_normalized_dirname, make_normalized_path, make_relative_path } from "../../utils/file.js";
 import { findConfigFile, is_config_filename, readConfigFile, readSingletonConfigFile } from "./config-loader.js";
+import { read_lockfile } from "./lockfile.js";
 const exclude_dirs = ["node_modules", ".git"];
 function is_ignored_dir(ws, path) {
     const normalized_path = make_normalized_path(path);
@@ -252,7 +253,7 @@ function show_constants(ws) {
     }
 }
 export async function discover_workspace(ws) {
-    let package_lock = null;
+    let lockfile = null;
     for (let path = ws.path;;) {
         const package_json = await readJsonFile(path + "/package.json");
         if (package_json) {
@@ -267,30 +268,20 @@ export async function discover_workspace(ws) {
                 };
             }
         }
-        const package_lock_path = path + "/package-lock.json";
-        if (!package_lock && Fs.existsSync(package_lock_path)) {
-            package_lock = await readJsonFile(package_lock_path);
+        if (!lockfile) {
+            lockfile = await read_lockfile(path);
         }
         const next_path = make_normalized_dirname(path);
         if (next_path === path)
             break;
         path = next_path;
     }
-    if (!package_lock) {
-        throw new Error(`Package lock not found for '${ws.name}'`);
-    }
-    for (const location in package_lock.packages) {
-        let pkg = package_lock.packages[location];
-        if (location.startsWith("node_modules/")) {
-            if (pkg.link) {
-                pkg = package_lock.packages[pkg.resolved];
-            }
-            const name = location.replace(/^.*node_modules\//, "");
-            ws.resolved_versions[name] = pkg.version;
-        }
+    if (!lockfile) {
+        throw new Error(`Lock file not found for '${ws.name}'`);
     }
+    ws.resolved_versions = lockfile.resolved_versions;
     await discover_workspace_libraries(ws);
-    for (const location in package_lock.packages) {
+    for (const location of lockfile.installed_locations) {
         await discover_library(ws, location, true);
     }
     for (const bun of ws.bundles) {

package/esm/model/helpers/lockfile.js

@@ -0,0 +1,108 @@
+import Fs from "node:fs";
+import Fsp from "node:fs/promises";
+import YAML from "yaml";
+import { readJsonFile } from "../storage.js";
+export async function read_lockfile(dir) {
+    const npm_path = dir + "/package-lock.json";
+    if (Fs.existsSync(npm_path)) {
+        return parse_npm_lockfile(await readJsonFile(npm_path));
+    }
+    const pnpm_path = dir + "/pnpm-lock.yaml";
+    if (Fs.existsSync(pnpm_path)) {
+        return parse_pnpm_lockfile(YAML.parse(await Fsp.readFile(pnpm_path, "utf-8")));
+    }
+    const yarn_path = dir + "/yarn.lock";
+    if (Fs.existsSync(yarn_path)) {
+        return parse_yarn_lockfile(await Fsp.readFile(yarn_path, "utf-8"));
+    }
+    return null;
+}
+function parse_npm_lockfile(lock) {
+    const resolved_versions = {};
+    const installed_locations = [];
+    for (const location in lock.packages) {
+        if (!location)
+            continue;
+        installed_locations.push(location);
+        if (location.startsWith("node_modules/")) {
+            let pkg = lock.packages[location];
+            if (pkg.link) {
+                pkg = lock.packages[pkg.resolved];
+            }
+            const name = location.replace(/^.*node_modules\//, "");
+            if (pkg?.version) {
+                resolved_versions[name] = pkg.version;
+            }
+        }
+    }
+    return { resolved_versions, installed_locations };
+}
+function parse_pnpm_lockfile(lock) {
+    const resolved_versions = {};
+    const locations = new Set();
+    if (lock.packages) {
+        for (const key in lock.packages) {
+            const clean = key.startsWith("/") ? key.slice(1) : key;
+            const atIdx = clean.lastIndexOf("@");
+            if (atIdx > 0) {
+                const name = clean.slice(0, atIdx);
+                const version = clean.slice(atIdx + 1).split("(")[0];
+                if (name && version) {
+                    resolved_versions[name] = version;
+                    locations.add("node_modules/" + name);
+                }
+            }
+        }
+    }
+    if (lock.importers) {
+        for (const key in lock.importers) {
+            if (key !== ".")
+                locations.add(key);
+        }
+    }
+    return { resolved_versions, installed_locations: [...locations] };
+}
+function parse_yarn_lockfile(text) {
+    const resolved_versions = {};
+    const locations = new Set();
+    if (text.includes("__metadata:")) {
+        const lock = YAML.parse(text);
+        for (const key in lock) {
+            if (key === "__metadata")
+                continue;
+            if (lock[key]?.version) {
+                const name = extract_package_name(key.split(",")[0].trim());
+                if (name) {
+                    resolved_versions[name] = lock[key].version;
+                    locations.add("node_modules/" + name);
+                }
+            }
+        }
+    }
+    else {
+        parse_yarn_classic(text, resolved_versions, locations);
+    }
+    return { resolved_versions, installed_locations: [...locations] };
+}
+function extract_package_name(entry) {
+    entry = entry.replace(/^"|"$/g, "");
+    // @scope/name@version or name@version
+    const at = entry.startsWith("@") ? entry.indexOf("@", 1) : entry.indexOf("@");
+    return at > 0 ? entry.slice(0, at) : null;
+}
+function parse_yarn_classic(text, resolved_versions, locations) {
+    let current_name = null;
+    for (const line of text.split("\n")) {
+        const trimmed = line.trim();
+        if (!line.startsWith(" ") && !line.startsWith("#") && trimmed.endsWith(":")) {
+            current_name = extract_package_name(trimmed.slice(0, -1).split(",")[0].trim());
+        }
+        else if (current_name && trimmed.startsWith("version ")) {
+            const version = trimmed.slice(8).replace(/^"|"$/g, "");
+            resolved_versions[current_name] = version;
+            locations.add("node_modules/" + current_name);
+            current_name = null;
+        }
+    }
+}
+//# sourceMappingURL=lockfile.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
    "name": "@jointhedots/gear",
-   "version": "1.1.14",
+   "version": "1.1.15",
    "type": "module",
    "bin": {
       "jointhedots-gear": "esm/cli.js"