@jointhedots/gear 1.1.13 → 1.1.14

package/esm/builder/build-target.js

@@ -66,7 +66,8 @@ export class BuildTarget {
         const start = Date.now();
         await task.execute();
         const elapsed = (Date.now() - start) / 1000;
-        this.log.info(`⏱ ${name} completed in ${elapsed.toFixed(2)}s`);
+        if (elapsed > 1.0)
+            this.log.info(`⏱ ${name} completed in ${elapsed.toFixed(2)}s`);
     }
     async build() {
         const buildStartTime = Date.now();

package/esm/builder/helpers/emit-esmodules.js

@@ -9,7 +9,7 @@ import { PackageRootDir, resolve_normalized_suffixed_path } from "../../utils/fi
 import { Library } from "../../model/workspace.js";
 import { computeNameHashID } from "../../utils/normalized-name.js";
 import { BuildTask } from "./task.js";
-const VirtualOutDir = Path.normalize('X:/');
+const VirtualOutDir = process.platform === 'win32' ? 'X:\\' : '/_/';
 function getEsbuildLogLevel(mode) {
     switch (mode) {
         case "verbose":

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

@@ -1,7 +1,8 @@
-import * as Glob from 'glob';
+import Fs from 'fs';
 import Os from 'os';
 import Path from 'path';
 import Ts from 'typescript';
+import { execFileSync } from 'child_process';
 import { BuildTask } from "./task.js";
 import { BuildTarget } from "../build-target.js";
 import { Library } from "../../model/workspace.js";
@@ -33,15 +34,6 @@ function getError(diagnostics) {
     error.name = 'EmitterError';
     return error;
 }
-function getFilenames(baseDir, files) {
-    return files.map(function (filename) {
-        const resolvedFilename = Path.resolve(filename);
-        if (resolvedFilename.indexOf(baseDir) === 0) {
-            return resolvedFilename;
-        }
-        return Path.resolve(baseDir, filename);
-    });
-}
 function processTree(sourceFile, replacer) {
     let code = '';
     let cursorPosition = 0;
@@ -67,19 +59,6 @@ function processTree(sourceFile, replacer) {
     code += sourceFile.text.slice(cursorPosition);
     return code;
 }
-function getTSConfig(baseDir, tsconfig) {
-    const { config, error } = Ts.parseConfigFileTextToJson("tsconfig.json", tsconfig);
-    if (error)
-        throw getError([error]);
-    const configParsed = Ts.parseJsonConfigFileContent(config, Ts.sys, baseDir);
-    if (configParsed.errors && configParsed.errors.length) {
-        throw getError(configParsed.errors);
-    }
-    return [
-        configParsed.fileNames,
-        configParsed.options
-    ];
-}
 function isNodeKindImportType(value) {
     return value && value.kind === Ts.SyntaxKind.ImportType;
 }
@@ -97,40 +76,68 @@ function isNodeKindExportDeclaration(value) {
 }
 class TypescriptProject {
     baseDir;
-    files;
     compilerOptions;
-    host;
-    program;
-    filenames;
+    dtsDir;
     constructor(baseDir, tsconfig, outDir) {
         this.baseDir = Path.resolve(baseDir);
-        const [files, compilerOptions] = getTSConfig(baseDir, tsconfig);
-        compilerOptions.declaration = true;
-        compilerOptions.emitDeclarationOnly = true;
-        compilerOptions.noEmit = false;
-        compilerOptions.target = compilerOptions.target || Ts.ScriptTarget.Latest;
-        compilerOptions.moduleResolution = compilerOptions.moduleResolution || Ts.ModuleResolutionKind.Bundler;
+        const { config, error } = Ts.parseConfigFileTextToJson("tsconfig.json", tsconfig);
+        if (error)
+            throw getError([error]);
+        const configParsed = Ts.parseJsonConfigFileContent(config, Ts.sys, baseDir);
+        if (configParsed.errors?.length)
+            throw getError(configParsed.errors);
+        const compilerOptions = configParsed.options;
         compilerOptions.outDir = compilerOptions.outDir || outDir;
-        this.files = files;
         this.compilerOptions = compilerOptions;
-        this.filenames = getFilenames(this.baseDir, files);
-        this.host = Ts.createCompilerHost(compilerOptions);
-        this.program = Ts.createProgram(this.filenames, compilerOptions, this.host);
+        // Create a temp directory for tsgo to emit .d.ts into
+        this.dtsDir = Fs.mkdtempSync(Path.join(Os.tmpdir(), 'gear-dts-'));
     }
-    getSourceFiles() {
-        return this.program.getSourceFiles();
-    }
-    emit(sourceFile, writeFile) {
-        return this.program.emit(sourceFile, writeFile);
-    }
-    getSemanticDiagnostics(sourceFile) {
-        return this.program.getSemanticDiagnostics(sourceFile);
+    /** Run tsgo to emit .d.ts files into dtsDir. Returns stderr output. */
+    emitWithTsgo() {
+        const tsgoPath = Path.resolve('node_modules/.bin/tsgo');
+        const args = [
+            '-p', Path.join(this.baseDir, 'tsconfig.json'),
+            '--declaration',
+            '--emitDeclarationOnly',
+            '--skipLibCheck',
+            '--outDir', this.dtsDir,
+        ];
+        try {
+            execFileSync(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 || '';
+        }
     }
-    getSyntacticDiagnostics(sourceFile) {
-        return this.program.getSyntacticDiagnostics(sourceFile);
+    /** Recursively collect all .d.ts files emitted by tsgo */
+    getEmittedDtsFiles() {
+        const results = [];
+        function walk(dir) {
+            for (const entry of Fs.readdirSync(dir, { withFileTypes: true })) {
+                const full = Path.join(dir, entry.name);
+                if (entry.isDirectory())
+                    walk(full);
+                else if (isDtsFilename(entry.name))
+                    results.push(full);
+            }
+        }
+        if (Fs.existsSync(this.dtsDir))
+            walk(this.dtsDir);
+        return results;
     }
-    getDeclarationDiagnostics(sourceFile) {
-        return this.program.getDeclarationDiagnostics(sourceFile);
+    /** Clean up temp directory */
+    cleanup() {
+        try {
+            Fs.rmSync(this.dtsDir, { recursive: true, force: true });
+        }
+        catch { }
     }
 }
 export function createTypescriptProject(baseDir, tsconfig, outDir) {
@@ -138,18 +145,14 @@ export function createTypescriptProject(baseDir, tsconfig, outDir) {
 }
 export function generateTypescriptDefinition(options) {
     const project = options.project;
-    const diagnostics = [];
     const baseDir = project.baseDir;
-    const outDir = project.compilerOptions.outDir;
-    const excludesMap = {};
-    options.exclude = options.exclude || ['node_modules/**/*'];
-    options.exclude.forEach(function (filename) {
-        Glob.sync(filename, { cwd: baseDir }).forEach(function (globFileName) {
-            excludesMap[normalizeFileName(Path.resolve(baseDir, globFileName))] = true;
-        });
-    });
+    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);
@@ -165,138 +168,97 @@ export function generateTypescriptDefinition(options) {
         }
         return modulePath;
     }
-    let outputContent = '';
+    const outputParts = [];
     if (options.externs) {
         options.externs.forEach(function (path) {
-            outputContent += `/// <reference path="${path}" />` + eol;
+            outputParts.push(`/// <reference path="${path}" />` + eol);
         });
     }
     if (options.types) {
         options.types.forEach(function (type) {
-            outputContent += `/// <reference types="${type}" />` + eol;
+            outputParts.push(`/// <reference types="${type}" />` + eol);
         });
     }
-    // Filter source files
-    const sourcesMap = {};
+    // Map source-relative paths to internal: module IDs for ALL emitted files
     const internalsMap = {};
-    project.getSourceFiles().some(function (sourceFile) {
-        const { fileName } = sourceFile;
-        if (fileName.indexOf(normalizedBaseDir) !== 0)
-            return;
-        if (excludesMap[fileName])
-            return;
-        const shortName = fileName.slice(normalizedBaseDir.length);
-        const shortNameNoExt = shortName.slice(0, -Path.extname(fileName).length);
-        const strippedShortName = stripBaseUrlPrefix(shortName);
-        const strippedShortNameNoExt = stripBaseUrlPrefix(shortNameNoExt);
-        const moduleId = `${options.prefix}/${strippedShortNameNoExt}`;
-        internalsMap[shortName] = moduleId;
-        internalsMap[shortNameNoExt] = moduleId;
-        internalsMap[strippedShortName] = moduleId;
-        internalsMap[strippedShortNameNoExt] = moduleId;
-        sourcesMap[fileName] = true;
-    });
-    // Build reverse map from internal paths to export names
-    // e.g., "src/Inputs" -> "./Inputs" means internal path "src/Inputs" exports as "prefix/Inputs"
-    // Store as [internalPrefix, exportName] pairs for prefix matching
+    const dtsFiles = project.getEmittedDtsFiles();
+    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 strippedSource = stripBaseUrlPrefix(relativeSource);
+        const moduleId = `${options.prefix}:${strippedSource}`;
+        internalsMap[relativeSource] = moduleId;
+        internalsMap[strippedSource] = moduleId;
+        if (strippedSource.endsWith('/index')) {
+            internalsMap[strippedSource.slice(0, -6)] = moduleId;
+        }
+    }
+    // Build public export map: maps export entry ID to internal module ID
+    const publicReexports = [];
     if (options.exports) {
         for (const entry of Object.values(options.exports)) {
             const fileName = entry.source;
-            if (fileName.indexOf(normalizedBaseDir) !== 0)
+            if (isExcludedPath(fileName))
                 continue;
-            if (excludesMap[fileName])
+            const normalizedSource = normalizeFileName(Path.resolve(fileName));
+            if (!normalizedSource.startsWith(normalizedBaseDir))
                 continue;
-            const shortName = fileName.slice(normalizedBaseDir.length);
-            const shortNameNoExt = shortName.slice(0, -Path.extname(fileName).length);
-            const strippedShortName = stripBaseUrlPrefix(shortName);
+            const shortName = normalizedSource.slice(normalizedBaseDir.length);
+            const shortNameNoExt = shortName.replace(/\.(ts|tsx|js|jsx)$/, '');
             const strippedShortNameNoExt = stripBaseUrlPrefix(shortNameNoExt);
-            const moduleId = entry.id;
-            internalsMap[shortName] = moduleId;
-            internalsMap[shortNameNoExt] = moduleId;
-            internalsMap[strippedShortName] = moduleId;
-            internalsMap[strippedShortNameNoExt] = moduleId;
-            sourcesMap[fileName] = true;
+            const internalId = internalsMap[shortNameNoExt] ||
+                internalsMap[strippedShortNameNoExt] ||
+                internalsMap[shortName];
+            if (internalId) {
+                publicReexports.push({ id: entry.id, internalId });
+            }
         }
     }
-    // Unified module ID normalization: strip extensions, baseUrl prefix, and remap to exports
+    // Unified module ID normalization
     function normalizeModuleId(moduleId) {
-        // Strip .ts, .tsx, .js, .jsx, .d.ts extensions
         moduleId = moduleId.replace(/\.(d\.ts|ts|tsx|js|jsx)$/, '');
-        // Strip baseUrl prefix
         moduleId = stripBaseUrlPrefix(moduleId);
-        // Apply resolved prefix
         const remapped = internalsMap[moduleId] ||
             internalsMap[moduleId + "/index"] ||
             internalsMap[moduleId + "/index.ts"];
         return remapped || moduleId;
     }
-    // Generate source files
-    project.getSourceFiles().some(function (sourceFile) {
-        if (!sourcesMap[sourceFile.fileName])
-            return;
-        // Source file is already a declaration file so should does not need to be pre-processed by the emitter
-        if (isDtsFilename(sourceFile.fileName)) {
-            writeDeclaration(sourceFile, sourceFile.fileName);
-            return;
-        }
-        const emitOutput = project.emit(sourceFile, (filename, data) => writeFile(filename, data, sourceFile.fileName));
-        if (emitOutput.emitSkipped || emitOutput.diagnostics.length > 0) {
-            diagnostics.push(...emitOutput.diagnostics);
-            diagnostics.push(...project.getSemanticDiagnostics(sourceFile));
-            diagnostics.push(...project.getSyntacticDiagnostics(sourceFile));
-            diagnostics.push(...project.getDeclarationDiagnostics(sourceFile));
-        }
-    });
     function isExternalModule(moduleId) {
-        if (!internalsMap[moduleId]) {
-            return true;
-        }
-        return false;
+        return !internalsMap[moduleId];
     }
-    function writeFile(filename, data, sourceFilePath) {
-        if (isDtsFilename(filename)) {
-            const declFile = Ts.createSourceFile(filename, data, project.compilerOptions.target, true);
-            writeDeclaration(declFile, sourceFilePath);
-        }
+    // 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 writeDeclaration(declarationFile, sourceFilePath) {
-        // Compute rawSourceModuleId based on the source file path that produced the declaration
-        const resolvedSourcePath = Path.resolve(sourceFilePath);
-        const sourceExt = Path.extname(resolvedSourcePath);
-        const rawSourceModuleId = normalizeFileName(resolvedSourcePath.slice(baseDir.length + 1, -sourceExt.length));
-        // Normalize and remap the module ID
+    function writeDeclaration(declarationFile, rawSourceModuleId) {
         const moduleDeclId = normalizeModuleId(rawSourceModuleId);
-        outputContent += `declare module '${moduleDeclId}' {${eol}${indent}`;
+        outputParts.push(`declare module '${moduleDeclId}' {${eol}${indent}`);
         function resolveModuleImport(moduleId) {
-            // Resolve module id
             let resolved;
             if (moduleId.charAt(0) === '.') {
                 resolved = normalizeFileName(Path.join(Path.dirname(rawSourceModuleId), moduleId));
             }
             else {
-                // Try to resolve using TypeScript's module resolution (handles tsconfig paths)
-                const resolveResult = Ts.resolveModuleName(moduleId, declarationFile.fileName, project.compilerOptions, project.host);
-                if (resolveResult.resolvedModule) {
-                    const resolvedFileName = normalizeFileName(resolveResult.resolvedModule.resolvedFileName);
-                    if (excludesMap[resolvedFileName])
-                        return moduleId;
-                    // Check if resolved file is within our project (internal module)
-                    if (resolvedFileName.startsWith(normalizedBaseDir)) {
-                        // Convert absolute path to relative module id
-                        resolved = resolvedFileName.slice(normalizedBaseDir.length);
-                    }
-                    else {
-                        // External module - return as-is
-                        return moduleId;
-                    }
-                }
-                else {
-                    resolved = moduleId;
-                    if (isExternalModule(resolved))
-                        return resolved;
-                }
+                resolved = moduleId;
+                if (isExternalModule(resolved))
+                    return resolved;
             }
-            // Normalize: strip extensions, baseUrl prefix, and remap to exports
             return normalizeModuleId(resolved);
         }
         const content = processTree(declarationFile, function (node) {
@@ -322,38 +284,13 @@ export function generateTypescriptDefinition(options) {
         const chunks = content.replaceAll("\r", "").split("\n").map(c => c.trimEnd());
         while (chunks.length > 0 && chunks[chunks.length - 1] === "")
             chunks.pop();
-        outputContent += chunks.join(eol + indent) + eol;
-        outputContent += '}' + eol + eol;
+        outputParts.push(chunks.join(eol + indent) + eol);
+        outputParts.push('}' + eol + eol);
     }
     return {
-        dts: outputContent,
-        diagnostics,
+        dts: outputParts.join(''),
     };
 }
-export function logDiagnostics(log, diagnostics) {
-    if (diagnostics && diagnostics.length > 0) {
-        for (const diagnostic of diagnostics) {
-            const text = typeof diagnostic.messageText === 'string'
-                ? diagnostic.messageText
-                : diagnostic.messageText.messageText;
-            const message = {
-                id: `TS${diagnostic.code}`,
-                text,
-                detail: diagnostic,
-            };
-            if (diagnostic.file && diagnostic.start !== undefined) {
-                const { line, character } = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start);
-                message.location = {
-                    file: diagnostic.file.fileName,
-                    line: line + 1,
-                    column: character,
-                    length: diagnostic.length ?? 0,
-                };
-            }
-            log.put('error', message);
-        }
-    }
-}
 export class TypescriptDefinitionTask extends BuildTask {
     library;
     constructor(target, library) {
@@ -367,14 +304,18 @@ 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 { dts, diagnostics } = generateTypescriptDefinition({
+            const stderr = project.emitWithTsgo();
+            if (stderr) {
+                this.log.warn(stderr);
+            }
+            const { dts } = generateTypescriptDefinition({
                 project,
                 prefix: lib.name,
                 exclude: ["node_modules/**/*"],
                 exports: create_export_map(lib, lib.bundle),
             });
             file.write.text(storage.getBaseDirFS() + "/types.d.ts", dts);
-            logDiagnostics(this.log, diagnostics);
+            project.cleanup();
         }
         catch (e) {
             this.log.error("no 'type.d.ts' will be generated for the package:" + e.message);

package/package.json

@@ -1,6 +1,6 @@
 {
    "name": "@jointhedots/gear",
-   "version": "1.1.13",
+   "version": "1.1.14",
    "type": "module",
    "bin": {
       "jointhedots-gear": "esm/cli.js"
@@ -33,19 +33,17 @@
       "@aws-sdk/client-s3": "^3.968.0",
       "@jspm/core": "^2.1.0",
       "@tailwindcss/postcss": "~4.1.3",
-      "@types/semver": "~7.7.1",
+      "@typescript/native-preview": "^7.0.0-dev.20260310.1",
       "dotenv": "~17.2.3",
       "esbuild": "~0.27.2",
       "esbuild-sass-plugin": "~3.6.0",
       "express": "~5.2.1",
-      "glob": "~13.0.0",
       "mime": "~4.1.0",
       "node-watch": "~0.7.4",
       "postcss": "~8.5.6",
       "sass": "~1.97.2",
       "semver": "~7.7.3",
       "sharp": "~0.34.5",
-      "source-map-support": "~0.5.21",
       "toml": "^3.0.0",
       "typescript": "~5.9.3",
       "yaml": "^2.8.2",
@@ -55,6 +53,7 @@
       "@polycuber/script.cli": "~1.0.5",
       "@types/chrome": "~0.1.33",
       "@types/node": "~22.7.4",
+      "@types/semver": "~7.7.1",
       "@types/web-app-manifest": "~1.0.9",
       "@types/yargs": "~17.0.35"
    },