@jointhedots/gear 1.1.12 → 1.1.14

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

@@ -0,0 +1,325 @@
+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";
+import { file } from "../../utils/file.js";
+import { create_export_map } from "../../model/helpers/create-manifests.js";
+const eol = Os.EOL;
+const indent = "    ";
+const DTSLEN = '.d.ts'.length;
+function normalizeFileName(filename) {
+    return filename.replaceAll(Path.sep, "/");
+}
+function isDtsFilename(filename) {
+    return filename.slice(-DTSLEN) === '.d.ts';
+}
+function getError(diagnostics) {
+    let message = 'Declaration generation failed';
+    diagnostics.forEach(function (diagnostic) {
+        if (diagnostic.file) {
+            const position = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start);
+            message +=
+                `\n${diagnostic.file.fileName}(${position.line + 1},${position.character + 1}): ` +
+                    `error TS${diagnostic.code}: ${diagnostic.messageText}`;
+        }
+        else {
+            message += `\nerror TS${diagnostic.code}: ${diagnostic.messageText}`;
+        }
+    });
+    const error = new Error(message);
+    error.name = 'EmitterError';
+    return error;
+}
+function processTree(sourceFile, replacer) {
+    let code = '';
+    let cursorPosition = 0;
+    function skip(node) {
+        cursorPosition = node.end;
+    }
+    function readThrough(node) {
+        code += sourceFile.text.slice(cursorPosition, node.pos);
+        cursorPosition = node.pos;
+    }
+    function visit(node) {
+        readThrough(node);
+        const replacement = replacer(node);
+        if (replacement != null) {
+            code += replacement;
+            skip(node);
+        }
+        else {
+            Ts.forEachChild(node, visit);
+        }
+    }
+    visit(sourceFile);
+    code += sourceFile.text.slice(cursorPosition);
+    return code;
+}
+function isNodeKindImportType(value) {
+    return value && value.kind === Ts.SyntaxKind.ImportType;
+}
+function isNodeKindImportDeclaration(value) {
+    return value && value.kind === Ts.SyntaxKind.ImportDeclaration;
+}
+function isNodeKindExternalModuleReference(value) {
+    return value && value.kind === Ts.SyntaxKind.ExternalModuleReference;
+}
+function isNodeKindStringLiteral(value) {
+    return value && value.kind === Ts.SyntaxKind.StringLiteral;
+}
+function isNodeKindExportDeclaration(value) {
+    return value && value.kind === Ts.SyntaxKind.ExportDeclaration;
+}
+class TypescriptProject {
+    baseDir;
+    compilerOptions;
+    dtsDir;
+    constructor(baseDir, tsconfig, outDir) {
+        this.baseDir = Path.resolve(baseDir);
+        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.compilerOptions = compilerOptions;
+        // Create a temp directory for tsgo to emit .d.ts into
+        this.dtsDir = Fs.mkdtempSync(Path.join(Os.tmpdir(), 'gear-dts-'));
+    }
+    /** 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 || '';
+        }
+    }
+    /** 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;
+    }
+    /** Clean up temp directory */
+    cleanup() {
+        try {
+            Fs.rmSync(this.dtsDir, { recursive: true, force: true });
+        }
+        catch { }
+    }
+}
+export function createTypescriptProject(baseDir, tsconfig, outDir) {
+    return new TypescriptProject(baseDir, tsconfig, outDir);
+}
+export function generateTypescriptDefinition(options) {
+    const project = options.project;
+    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 outputParts = [];
+    if (options.externs) {
+        options.externs.forEach(function (path) {
+            outputParts.push(`/// <reference path="${path}" />` + eol);
+        });
+    }
+    if (options.types) {
+        options.types.forEach(function (type) {
+            outputParts.push(`/// <reference types="${type}" />` + eol);
+        });
+    }
+    // Map source-relative paths to internal: module IDs for ALL emitted files
+    const internalsMap = {};
+    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 (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];
+            if (internalId) {
+                publicReexports.push({ id: entry.id, internalId });
+            }
+        }
+    }
+    // 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 writeDeclaration(declarationFile, rawSourceModuleId) {
+        const moduleDeclId = normalizeModuleId(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);
+                return ` require('${resolved}')`;
+            }
+            else if (isNodeKindImportDeclaration(node) && !node.importClause) {
+                return '';
+            }
+            else if (node.kind === Ts.SyntaxKind.DeclareKeyword) {
+                return '';
+            }
+            else if (isNodeKindStringLiteral(node) && node.parent &&
+                (isNodeKindExportDeclaration(node.parent) || isNodeKindImportDeclaration(node.parent) || isNodeKindImportType(node.parent?.parent))) {
+                const resolved = resolveModuleImport(node.text);
+                if (resolved) {
+                    return ` '${resolved}'`;
+                }
+            }
+        });
+        const chunks = content.replaceAll("\r", "").split("\n").map(c => c.trimEnd());
+        while (chunks.length > 0 && chunks[chunks.length - 1] === "")
+            chunks.pop();
+        outputParts.push(chunks.join(eol + indent) + eol);
+        outputParts.push('}' + eol + eol);
+    }
+    return {
+        dts: outputParts.join(''),
+    };
+}
+export class TypescriptDefinitionTask extends BuildTask {
+    library;
+    constructor(target, library) {
+        super(target);
+        this.library = library;
+    }
+    async execute() {
+        const lib = this.library;
+        const { storage } = this.target;
+        try {
+            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);
+            }
+            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);
+            project.cleanup();
+        }
+        catch (e) {
+            this.log.error("no 'type.d.ts' will be generated for the package:" + e.message);
+        }
+    }
+}
+//# sourceMappingURL=emit-typescript-definition.js.map

package/esm/builder/helpers/task.js

@@ -0,0 +1,9 @@
+export class BuildTask {
+    target;
+    constructor(target) {
+        this.target = target;
+    }
+    get log() { return this.target.log; }
+    async init() { }
+}
+//# sourceMappingURL=task.js.map

package/esm/model/helpers/create-manifests.js

@@ -1,10 +1,11 @@
 import Path from "node:path";
 import { makeComponentPublication } from "../component.js";
+import { resolve_normalized_suffixed_path } from "../../utils/file.js";
 function add_export_entry(exports, lib, key, value, baseDir) {
     const basename = key.startsWith("./") ? key.slice(2) : key;
     const filename = lib.make_file_id("export", basename);
     const source_ref = typeof value === "string" ? value : value?.import ?? value?.default ?? value?.require;
-    const entry = source_ref ? lib.resolve_entry_path(source_ref, baseDir) : null;
+    const entry = source_ref ? resolve_normalized_suffixed_path(lib.resolve_entry_path(source_ref, baseDir), ".") : null;
     const id = `${lib.name}${basename === "." ? "" : "/" + basename}`;
     exports[id] = {
         id,
@@ -14,7 +15,7 @@ function add_export_entry(exports, lib, key, value, baseDir) {
         source: entry,
     };
 }
-function create_export_map(lib, bun) {
+export function create_export_map(lib, bun) {
     const exports = {};
     if (bun) {
         for (const id in bun.distribueds) {
@@ -43,26 +44,28 @@ function create_export_map(lib, bun) {
     }
     return exports;
 }
-export function create_manifests(lib, bun, build_version) {
+export function create_bundle_manifest(lib, bun) {
+    if (!bun)
+        return null;
     const entries = create_export_map(lib, bun);
-    let bundle_manif = null;
-    if (bun) {
-        bundle_manif = bun.manifest;
-        const components = [];
-        for (const comp of bun.components.values()) {
-            components.push(makeComponentPublication(comp));
-        }
-        bundle_manif.data = {
-            baseline: bun.id + "-v0",
-            components: components,
-            exports: {},
-        };
-        for (const id in entries) {
-            const exp = entries[id];
-            bundle_manif.data.exports[id] = exp.filename;
-        }
+    const bundle_manif = bun.manifest;
+    const components = [];
+    for (const comp of bun.components.values()) {
+        components.push(makeComponentPublication(comp));
+    }
+    bundle_manif.data = {
+        baseline: bun.id + "-v0",
+        components: components,
+        exports: {},
+    };
+    for (const id in entries) {
+        const exp = entries[id];
+        bundle_manif.data.exports[id] = exp.filename;
     }
-    // Add bundle package.json 
+    return bundle_manif;
+}
+export function create_package_manifest(lib, bun, build_version) {
+    const entries = create_export_map(lib, bun);
     const pkg_manif = {
         ...lib.descriptor,
         name: lib.name,
@@ -74,14 +77,32 @@ export function create_manifests(lib, bun, build_version) {
         devDependencies: undefined,
         optionalDependencies: undefined,
     };
+    if (pkg_manif.dependencies) {
+        const resolved = lib.workspace.resolved_versions;
+        for (const dep in pkg_manif.dependencies) {
+            if (pkg_manif.dependencies[dep] === "*") {
+                const dep_resolved = resolved[dep];
+                if (dep_resolved) {
+                    const [major, minor] = dep_resolved.split(".");
+                    pkg_manif.dependencies[dep] = `^${major}.${minor}.0`;
+                }
+                else {
+                    lib.log.warn(`Library dependency '${dep}' is versioned as * but not updatable to locked version`);
+                }
+            }
+        }
+    }
     for (const id in entries) {
         const exp = entries[id];
         if (exp.exported) {
             if (!pkg_manif.exports)
                 pkg_manif.exports = {};
-            pkg_manif.exports[exp.exported] = { import: `./${exp.filename}`, types: "./types.d.ts" };
+            pkg_manif.exports[exp.exported] = {
+                import: `./${exp.filename}`,
+                types: "./types.d.ts",
+            };
         }
     }
-    return { package: pkg_manif, bundle: bundle_manif, entries };
+    return pkg_manif;
 }
 //# sourceMappingURL=create-manifests.js.map

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

@@ -3,7 +3,7 @@ import Fsp from "node:fs/promises";
 import { readJsonFile } from "../storage.js";
 import { checkComponentManifest } from "../component.js";
 import { makeNormalizedName, NameStyle } from "../../utils/normalized-name.js";
-import { create_manifests } from "./create-manifests.js";
+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";
@@ -18,8 +18,8 @@ function is_ignored_dir(ws, path) {
     return false;
 }
 function setup_library_bundle(lib, bundle_desc) {
-    const manif = make_library_bundle_manifest(lib, bundle_desc);
     const ws = lib.workspace;
+    const manif = make_library_bundle_manifest(lib, bundle_desc);
     let bun = ws.get_bundle(manif.$id);
     if (!bun) {
         bun = new Bundle(manif, lib.path, ws, lib);
@@ -118,6 +118,19 @@ async function discover_library_components(lib, path, subdir = false) {
         }
     }
 }
+export function collect_declarations_field(lib, key, value) {
+    for (const decl of lib.declarations.values()) {
+        if (typeof decl[key] === typeof value) {
+            if (Array.isArray(value))
+                value.push(...decl[key]);
+            else if (typeof value === "object")
+                Object.assign(value, decl[key]);
+            else
+                value = decl[key];
+        }
+    }
+    return value;
+}
 function make_library_bundle_manifest(lib, file_desc) {
     let $id = file_desc?.$id;
     if ($id) {
@@ -131,26 +144,22 @@ function make_library_bundle_manifest(lib, file_desc) {
         lib.log.info(`Bundle '${$id}' named from library '${lib.name}'`);
     }
     const data = {
-        alias: lib.name,
         package: lib.get_id(),
-        namespaces: [],
-        dependencies: [],
-        redistribueds: {},
+        alias: collect_declarations_field(lib, "alias", lib.name),
+        namespaces: collect_declarations_field(lib, "namespaces", []),
+        dependencies: collect_declarations_field(lib, "dependencies", []),
+        distribueds: collect_declarations_field(lib, "distribueds", {}),
     };
     if (file_desc?.data) {
         data.alias = file_desc.data.alias ?? data.alias;
-        if (file_desc.data.redistribueds) {
-            const distribueds = file_desc.data.redistribueds;
-            if (Array.isArray(distribueds))
-                distribueds.forEach(dist => data.redistribueds[dist] = "*");
-            else
-                Object.assign(data.redistribueds, distribueds);
+        if (file_desc.data.distribueds) {
+            Object.assign(data.distribueds, file_desc.data.distribueds);
         }
-        if (file_desc.data.namespaces) {
-            data.namespaces = file_desc.data.namespaces;
+        if (Array.isArray(file_desc.data.namespaces)) {
+            data.namespaces.push(...file_desc.data.namespaces);
         }
-        if (file_desc.data.dependencies) {
-            data.dependencies = file_desc.data.dependencies;
+        if (Array.isArray(file_desc.data.dependencies)) {
+            data.dependencies.push(...file_desc.data.dependencies);
         }
     }
     const manifest = {
@@ -203,9 +212,9 @@ async function discover_library(ws, location, installed) {
         ws.libraries.push(lib);
         ws.log.info(`+ 📚 library: ${installed ? "⏬" : "🐣"} ${lib.get_id()} (${make_relative_path(ws.path, location)})`);
         // Setup library infos from bundle manifest
-        if (manifest_desc) {
-            setup_library_bundle(lib, manifest_desc);
-            // Analyze library deployment manifest (supports json/yaml/yml/toml, singleton)
+        setup_library_bundle(lib, manifest_desc);
+        // Analyze library deployment manifest (supports json/yaml/yml/toml, singleton)
+        if (manifest_desc?.data?.components) {
             for (const pub of manifest_desc.data.components) {
                 const fpath = lib_path + "/" + (pub.ref ?? pub.id);
                 await discover_component(lib, fpath);
@@ -270,14 +279,23 @@ export async function discover_workspace(ws) {
     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;
+        }
+    }
     await discover_workspace_libraries(ws);
     for (const location in package_lock.packages) {
         await discover_library(ws, location, true);
     }
     for (const bun of ws.bundles) {
         if (bun.source) {
-            const manifs = create_manifests(bun.source, bun);
-            bun.manifest = manifs.bundle;
+            bun.manifest = create_bundle_manifest(bun.source, bun);
         }
     }
     show_constants(ws);

package/esm/model/workspace.js

@@ -1,16 +1,14 @@
 import Fs from "node:fs";
-import Fsp from "node:fs/promises";
 import Path from "node:path";
 import Process from "node:process";
+import DotEnv from "dotenv";
 import { readJsonFile } from "./storage.js";
 import {} from "./component.js";
-import { topologicalSort } from "../utils/graph-ordering.js";
-import DotEnv from "dotenv";
 import { computeNameHashID, makeNormalizedName, NameStyle } from "../utils/normalized-name.js";
-import { make_relative_path } from "../utils/file.js";
+import { make_normalized_path } from "../utils/file.js";
 import { Logger, Log } from "./helpers/logger.js";
 import { discover_workspace } from "./helpers/discover-workspace.js";
-import { create_manifests } from "./helpers/create-manifests.js";
+import { create_bundle_manifest } from "./helpers/create-manifests.js";
 export class WorkspaceItem {
     workspace;
     log;
@@ -51,13 +49,13 @@ export class Library extends WorkspaceItem {
         return base ? prefix + "." + base : prefix;
     }
     resolve_entry_path(entryId, baseDir) {
-        const fpath = make_relative_path(Process.cwd(), Path.resolve(baseDir, entryId));
+        const fpath = make_normalized_path(Path.resolve(baseDir, entryId));
         if (entryId.startsWith("."))
             return fpath;
         const parts = entryId.split("/");
         for (const search_path of this.search_directories) {
             if (Fs.existsSync(search_path + "/" + parts[0])) {
-                return make_relative_path(Process.cwd(), search_path + "/" + entryId);
+                return make_normalized_path(search_path + "/" + entryId);
             }
         }
         if (Fs.existsSync(fpath))
@@ -94,8 +92,7 @@ export class Bundle extends WorkspaceItem {
     }
     resolve_export(ref) {
         if (!this.manifest) {
-            const manifs = create_manifests(this.source, this);
-            this.manifest = manifs.bundle;
+            this.manifest = create_bundle_manifest(this.source, this);
             this.configured = true;
         }
         return this.exports?.[ref];
@@ -110,6 +107,7 @@ export class Workspace {
     bundles = [];
     libraries = [];
     constants = {};
+    resolved_versions = {};
     search_directories = [];
     ignored_directories = new Set();
     logger = new Logger();