@jointhedots/gear 1.1.12 → 1.1.14

package/esm/builder/build-app-bundle.js

@@ -1,11 +1,13 @@
+import Path from "node:path";
 import { Bundle, Library } from "../model/workspace.js";
 import { StorageFiles } from "../model/storage.js";
-import { BuildTarget, BundleManifestTask } from "./build-target.js";
-import { TypescriptDefinitionTask } from "./emit-dts.js";
-import Path from "node:path";
+import { BuildTarget } from "./build-target.js";
+import { TypescriptDefinitionTask } from "./helpers/emit-typescript-definition.js";
+import { PackageManifestTask } from "./helpers/emit-package-manifest.js";
 import { PathQualifier } from "./helpers/path-helpers.js";
-import { create_manifests } from "../model/helpers/create-manifests.js";
-import { DependencyDeduplicationPlugin, collectLibraryGraph } from "./esbuild-plugins.js";
+import { create_export_map } from "../model/helpers/create-manifests.js";
+import { DependencyDeduplicationPlugin, collectLibraryGraph } from "./helpers/emit-esmodules.js";
+import { BundleManifestTask } from "./helpers/emit-bundle-manifest.js";
 export var PathStatus;
 (function (PathStatus) {
     PathStatus[PathStatus["Unknown"] = undefined] = "Unknown";
@@ -18,16 +20,16 @@ export function create_bundle_target(opts) {
     const { bundle, library, storage } = opts;
     const lib = library;
     const target = new BuildTarget(bundle.id, storage, lib.workspace, opts.devmode == true, opts.watch == true, opts.clean == true);
-    const manifs = create_manifests(lib, bundle, opts.version);
     // Prepare esm setup
     target.esmodules.set_root(lib.path);
     // Add bundle package.json
-    target.assets.add_static_json("package.json", manifs.package);
+    target.tasks.push(new PackageManifestTask(target, lib, opts.version));
     // Add bundle types.d.ts
     target.tasks.push(new TypescriptDefinitionTask(target, lib));
     // Add bundle exporteds
-    for (const exp_id in manifs.entries) {
-        const exp = manifs.entries[exp_id];
+    const entries = create_export_map(lib, lib.bundle);
+    for (const exp_id in entries) {
+        const exp = entries[exp_id];
         target.esmodules.add_entry(exp.basename, exp.source);
     }
     // Add bundle content

package/esm/builder/build-application.js

@@ -1,12 +1,13 @@
-import { Library, matchComponentSelection } from "../model/workspace.js";
-import { StorageFiles } from "../model/storage.js";
-import { BuildTarget, BuildTask, BundleManifestTask } from "./build-target.js";
 import Path from "node:path";
-import Fs from "node:fs";
 import Sharp from "sharp";
 import MIME from 'mime';
+import { Library, matchComponentSelection } from "../model/workspace.js";
+import { StorageFiles } from "../model/storage.js";
+import { BuildTarget } from "./build-target.js";
 import { build_app_composable_host } from "./build-app-host.js";
-import { DependencyDeduplicationPlugin } from "./esbuild-plugins.js";
+import { DependencyDeduplicationPlugin } from "./helpers/emit-esmodules.js";
+import { BundleManifestTask } from "./helpers/emit-bundle-manifest.js";
+import { BuildTask } from "./helpers/task.js";
 function collect_app_libraries(app) {
     const libs = [app.library];
     function collect_library_deps(lib) {

package/esm/builder/build-library.js

@@ -1,25 +1,27 @@
+import Path from "node:path";
+import ChildProcess from "child_process";
 import { Library } from "../model/workspace.js";
 import { StorageFiles } from "../model/storage.js";
-import ChildProcess from "child_process";
-import { BuildTarget, BundleManifestTask } from "./build-target.js";
-import { TypescriptDefinitionTask } from "./emit-dts.js";
-import Path from "node:path";
-import { create_manifests } from "../model/helpers/create-manifests.js";
+import { BuildTarget } from "./build-target.js";
+import { TypescriptDefinitionTask } from "./helpers/emit-typescript-definition.js";
+import { PackageManifestTask } from "./helpers/emit-package-manifest.js";
+import { create_export_map } from "../model/helpers/create-manifests.js";
+import { BundleManifestTask } from "./helpers/emit-bundle-manifest.js";
 export function create_library_target(opts) {
     const lib = opts.library;
     const target = new BuildTarget(lib.name, opts.storage, lib.workspace, opts.devmode == true, opts.watch == true, opts.clean == true);
-    const manifs = create_manifests(lib, lib.bundle, opts.version);
     // Prepare esm setup
     target.esmodules.set_root(lib.path);
     // Add bundle exporteds
-    for (const exp_id in manifs.entries) {
-        const exp = manifs.entries[exp_id];
+    const entries = create_export_map(lib, lib.bundle);
+    for (const exp_id in entries) {
+        const exp = entries[exp_id];
         target.esmodules.add_entry(exp.basename, exp.source);
     }
     // Add library types.d.ts
     target.tasks.push(new TypescriptDefinitionTask(target, lib));
     // Add library package.json
-    target.assets.add_static_json("package.json", manifs.package);
+    target.tasks.push(new PackageManifestTask(target, lib, opts.version));
     // Add bundle content
     const { bundle } = lib;
     if (bundle) {

package/esm/builder/build-target.js

@@ -1,145 +1,8 @@
-import Path from "node:path";
-import MIME from 'mime';
-import { makeComponentPublication } from "../model/component.js";
-import { Bundle, Library, Workspace } from "../model/workspace.js";
-import { create_esbuild_context } from "../builder/esbuild-plugins.js";
-import { copyToStorageStream } from "../model/storage.js";
-import * as esbuild from 'esbuild';
-import { computeNameHashID } from "../utils/normalized-name.js";
-export class BuildTask {
-    target;
-    constructor(target) {
-        this.target = target;
-    }
-    get log() { return this.target.log; }
-    async init() { }
-}
-export class BundleManifestTask extends BuildTask {
-    target;
-    bundle;
-    constructor(target, bundle) {
-        super(target);
-        this.target = target;
-        this.bundle = bundle;
-    }
-    async execute() {
-        const { target, bundle } = this;
-        const { manifest } = bundle;
-        const tx = this.target.edit();
-        // Emit static components manifest
-        const components = [];
-        for (const manif of target.components.values()) {
-            const pub = makeComponentPublication(manif);
-            pub.ref = await tx.commitContent(JSON.stringify(manif, null, 2), MIME.getType(".json"));
-            components.push(pub);
-        }
-        manifest.data.components = components;
-        // Emit bundle manifest
-        await tx.commitFile(`bundle.manifest.json`, JSON.stringify(manifest, null, 2));
-    }
-}
-export class AssetsTask extends BuildTask {
-    assets = [];
-    statics = {};
-    add_entry(entry, baseDir, library) {
-        let asset = null;
-        if (typeof entry === "string") {
-            const from = library.resolve_entry_path(entry, baseDir);
-            if (!from)
-                throw new Error(`In '${baseDir}', cannot found asset from: '${entry}'`);
-            asset = { from, to: Path.basename(entry) };
-        }
-        else {
-            const from = library.resolve_entry_path(entry.from, baseDir);
-            if (!from)
-                throw new Error(`In '${baseDir}', cannot found asset from: '${entry.from}'`);
-            asset = { from, to: entry.to };
-        }
-        this.log.info(`+ 📎 assets '${library.name}': ${asset.from} -> ${asset.to}`);
-        this.assets.push(asset);
-    }
-    add_static_text(name, data) {
-        this.statics[name] = data;
-    }
-    add_static_json(name, data) {
-        this.statics[name] = JSON.stringify(data, null, 2);
-    }
-    async execute() {
-        const tx = this.target.edit();
-        for (const key in this.statics) {
-            tx.commitFile(key, this.statics[key], MIME.getType(key));
-        }
-        for (const asset of this.assets) {
-            if (typeof asset === "string") {
-                copyToStorageStream(tx, asset, asset);
-            }
-            else {
-                copyToStorageStream(tx, asset.to, asset.from);
-            }
-        }
-    }
-}
-export class ESModulesTask extends BuildTask {
-    entries = {};
-    imports = {};
-    internals = new Map();
-    plugins = [];
-    context = null;
-    transaction = null;
-    polyfilled = true;
-    rootPath = null;
-    set_root(path) {
-        this.rootPath = path;
-    }
-    add_entry(name, path) {
-        this.entries[name] = path;
-        this.imports[path] = name;
-    }
-    add_entry_typescript(code, name) {
-        const id = computeNameHashID(code);
-        if (!name)
-            name = id;
-        this.internals.set(id, code);
-        this.add_entry(name, id);
-        return name;
-    }
-    add_resource_entry(resource, baseDir, library) {
-        if (typeof resource === "string") {
-            const parts = resource.split("#");
-            const file = library.resolve_entry_path(parts[0], baseDir);
-            if (file) {
-                let named = this.imports[file];
-                if (!named) {
-                    named = library.make_file_id("lambda", file);
-                    this.add_entry(named, file);
-                }
-                return `./${named}.js#${parts[1] || "default"}`;
-            }
-            else {
-                throw new Error(`${library.name}: Cannot resolve file: ${parts[0]}`);
-            }
-        }
-        else {
-            return resource;
-        }
-    }
-    async execute() {
-        if (this.context) {
-            const prev_ctx = this.context;
-            this.context = null;
-            await prev_ctx.dispose();
-        }
-        const { target } = this;
-        this.context = await create_esbuild_context(this, target.devmode);
-        if (target.watch) {
-            await this.context.watch();
-        }
-        else {
-            await this.context.rebuild();
-            await this.context.dispose();
-        }
-    }
-}
+import {} from "../model/component.js";
+import { Library, Workspace } from "../model/workspace.js";
+import { ESModulesTask } from "./helpers/emit-esmodules.js";
+import {} from "../model/storage.js";
+import { AssetsTask } from "./helpers/emit-static-assets.js";
 export class BuildTarget {
     name;
     storage;
@@ -203,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-bundle-manifest.js

@@ -0,0 +1,29 @@
+import { makeComponentPublication } from "../../model/component.js";
+import { BuildTarget } from "../build-target.js";
+import { BuildTask } from "./task.js";
+import MIME from 'mime';
+export class BundleManifestTask extends BuildTask {
+    target;
+    bundle;
+    constructor(target, bundle) {
+        super(target);
+        this.target = target;
+        this.bundle = bundle;
+    }
+    async execute() {
+        const { target, bundle } = this;
+        const { manifest } = bundle;
+        const tx = this.target.edit();
+        // Emit static components manifest
+        const components = [];
+        for (const manif of target.components.values()) {
+            const pub = makeComponentPublication(manif);
+            pub.ref = await tx.commitContent(JSON.stringify(manif, null, 2), MIME.getType(".json"));
+            components.push(pub);
+        }
+        manifest.data.components = components;
+        // Emit bundle manifest
+        await tx.commitFile(`bundle.manifest.json`, JSON.stringify(manifest, null, 2));
+    }
+}
+//# sourceMappingURL=emit-bundle-manifest.js.map

package/esm/builder/{esbuild-plugins.js → helpers/emit-esmodules.js}

@@ -5,10 +5,11 @@ import MIME from 'mime';
 import postcss from 'postcss';
 import * as esbuild from 'esbuild';
 import { sassPlugin } from 'esbuild-sass-plugin';
-import { ESModulesTask } from "./build-target.js";
-import { PackageRootDir } from "../utils/file.js";
-import { Library } from "../model/workspace.js";
-const VirtualOutDir = Path.normalize('X:/');
+import { PackageRootDir, resolve_normalized_suffixed_path } from "../../utils/file.js";
+import { Library } from "../../model/workspace.js";
+import { computeNameHashID } from "../../utils/normalized-name.js";
+import { BuildTask } from "./task.js";
+const VirtualOutDir = process.platform === 'win32' ? 'X:\\' : '/_/';
 function getEsbuildLogLevel(mode) {
     switch (mode) {
         case "verbose":
@@ -486,30 +487,6 @@ export function ESModuleResolverPlugin(opts, tsconfigPaths) {
         ".ts": "ts", ".tsx": "tsx", ".js": "js", ".jsx": "jsx",
         ".json": "json", ".txt": "text", ".md": "text", ".css": "css",
     };
-    const FILE_EXTENSIONS = ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.json'];
-    /** Resolve a file path with extension probing */
-    function resolveFilePath(importPath, baseDir) {
-        const resolved = Path.resolve(baseDir, importPath);
-        // Check if exact path exists
-        if (Fs.existsSync(resolved) && Fs.statSync(resolved).isFile()) {
-            return resolved;
-        }
-        // Try with common extensions
-        for (const ext of FILE_EXTENSIONS) {
-            const withExt = resolved + ext;
-            if (Fs.existsSync(withExt))
-                return withExt;
-        }
-        // Try index files in directory
-        if (Fs.existsSync(resolved) && Fs.statSync(resolved).isDirectory()) {
-            for (const ext of FILE_EXTENSIONS) {
-                const indexPath = Path.join(resolved, `index${ext}`);
-                if (Fs.existsSync(indexPath))
-                    return indexPath;
-            }
-        }
-        return null;
-    }
     return {
         name: 'esm-resolver',
         setup(build) {
@@ -546,14 +523,16 @@ export function ESModuleResolverPlugin(opts, tsconfigPaths) {
                 // 3. Handle relative/absolute file paths (entry points and local imports)
                 if (args.path.startsWith(".") || args.path.startsWith("/") || Path.isAbsolute(args.path)) {
                     const baseDir = args.resolveDir || workspaceRoot;
-                    const resolved = resolveFilePath(args.path, baseDir);
+                    const resolved = resolve_normalized_suffixed_path(baseDir, args.path);
                     if (resolved) {
                         return { path: resolved, namespace: "file" };
                     }
                 }
                 // 4. Resolve tsconfig path aliases (e.g. @app/* -> ./src/*)
                 if (tsconfigPaths?.hasAliases) {
-                    const resolved = tsconfigPaths.resolve(args.path, resolveFilePath);
+                    const resolved = tsconfigPaths.resolve(args.path, (importPath, baseDir) => {
+                        return resolve_normalized_suffixed_path(baseDir, importPath);
+                    });
                     if (resolved) {
                         return { path: resolved, namespace: "file" };
                     }
@@ -572,4 +551,65 @@ export function ESModuleResolverPlugin(opts, tsconfigPaths) {
         },
     };
 }
-//# sourceMappingURL=esbuild-plugins.js.map
+export class ESModulesTask extends BuildTask {
+    entries = {};
+    imports = {};
+    internals = new Map();
+    plugins = [];
+    context = null;
+    transaction = null;
+    polyfilled = true;
+    rootPath = null;
+    set_root(path) {
+        this.rootPath = path;
+    }
+    add_entry(name, path) {
+        this.entries[name] = path;
+        this.imports[path] = name;
+    }
+    add_entry_typescript(code, name) {
+        const id = computeNameHashID(code);
+        if (!name)
+            name = id;
+        this.internals.set(id, code);
+        this.add_entry(name, id);
+        return name;
+    }
+    add_resource_entry(resource, baseDir, library) {
+        if (typeof resource === "string") {
+            const parts = resource.split("#");
+            const file = library.resolve_entry_path(parts[0], baseDir);
+            if (file) {
+                let named = this.imports[file];
+                if (!named) {
+                    named = library.make_file_id("lambda", file);
+                    this.add_entry(named, file);
+                }
+                return `./${named}.js#${parts[1] || "default"}`;
+            }
+            else {
+                throw new Error(`${library.name}: Cannot resolve file: ${parts[0]}`);
+            }
+        }
+        else {
+            return resource;
+        }
+    }
+    async execute() {
+        if (this.context) {
+            const prev_ctx = this.context;
+            this.context = null;
+            await prev_ctx.dispose();
+        }
+        const { target } = this;
+        this.context = await create_esbuild_context(this, target.devmode);
+        if (target.watch) {
+            await this.context.watch();
+        }
+        else {
+            await this.context.rebuild();
+            await this.context.dispose();
+        }
+    }
+}
+//# sourceMappingURL=emit-esmodules.js.map

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

@@ -0,0 +1,19 @@
+import { BuildTask } from "./task.js";
+import { create_export_map, create_package_manifest } from "../../model/helpers/create-manifests.js";
+import { console } from "node:inspector";
+export class PackageManifestTask extends BuildTask {
+    library;
+    version;
+    constructor(target, library, version) {
+        super(target);
+        this.library = library;
+        this.version = version;
+    }
+    async execute() {
+        const { library, version } = this;
+        const pkg = create_package_manifest(library, library.bundle, version);
+        const tx = this.target.edit();
+        tx.commitFile("package.json", JSON.stringify(pkg, null, 2));
+    }
+}
+//# sourceMappingURL=emit-package-manifest.js.map

package/esm/builder/helpers/emit-static-assets.js

@@ -0,0 +1,47 @@
+import Path from "node:path";
+import MIME from 'mime';
+import { Library } from "../../model/workspace.js";
+import { copyToStorageStream } from "../../model/storage.js";
+import { BuildTask } from "./task.js";
+export class AssetsTask extends BuildTask {
+    assets = [];
+    statics = {};
+    add_entry(entry, baseDir, library) {
+        let asset = null;
+        if (typeof entry === "string") {
+            const from = library.resolve_entry_path(entry, baseDir);
+            if (!from)
+                throw new Error(`In '${baseDir}', cannot found asset from: '${entry}'`);
+            asset = { from, to: Path.basename(entry) };
+        }
+        else {
+            const from = library.resolve_entry_path(entry.from, baseDir);
+            if (!from)
+                throw new Error(`In '${baseDir}', cannot found asset from: '${entry.from}'`);
+            asset = { from, to: entry.to };
+        }
+        this.log.info(`+ 📎 assets '${library.name}': ${asset.from} -> ${asset.to}`);
+        this.assets.push(asset);
+    }
+    add_static_text(name, data) {
+        this.statics[name] = data;
+    }
+    add_static_json(name, data) {
+        this.statics[name] = JSON.stringify(data, null, 2);
+    }
+    async execute() {
+        const tx = this.target.edit();
+        for (const key in this.statics) {
+            tx.commitFile(key, this.statics[key], MIME.getType(key));
+        }
+        for (const asset of this.assets) {
+            if (typeof asset === "string") {
+                copyToStorageStream(tx, asset, asset);
+            }
+            else {
+                copyToStorageStream(tx, asset.to, asset.from);
+            }
+        }
+    }
+}
+//# sourceMappingURL=emit-static-assets.js.map