@jointhedots/gear 1.2.2 → 1.2.3

package/esm/builder/build-app-bundle.d.ts

@@ -8,6 +8,7 @@ export type BuildBundleOptions = {
     devmode: boolean;
     watch: boolean;
     clean: boolean;
+    artifactDir?: string;
 };
 export declare enum PathStatus {
     Unknown,

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

@@ -8,6 +8,7 @@ import { PathQualifier } from "./helpers/path-helpers.js";
 import { create_export_map } from "../workspace/helpers/create-manifests.js";
 import { DependencyDeduplicationPlugin, collectLibraryGraph } from "./helpers/emit-esmodules.js";
 import { BundleManifestTask } from "./helpers/emit-bundle-manifest.js";
+import { ArtifactNpmTask } from "./helpers/emit-artifact.js";
 export var PathStatus;
 (function (PathStatus) {
     PathStatus[PathStatus["Unknown"] = undefined] = "Unknown";
@@ -18,7 +19,7 @@ export var PathStatus;
 })(PathStatus || (PathStatus = {}));
 export function create_bundle_target(opts) {
     const { bundle, library: lib, storage } = opts;
-    const target = new BuildTarget(bundle.id, storage, lib.workspace, opts.devmode == true, opts.watch == true, opts.clean == true);
+    const target = new BuildTarget(bundle.id, storage, lib, opts.devmode == true, opts.watch == true, opts.clean == true);
     // Prepare esm setup
     target.esmodules.set_root(lib.path);
     // Add bundle package.json
@@ -26,7 +27,7 @@ export function create_bundle_target(opts) {
     // Add bundle types.d.ts
     target.tasks.push(new TypescriptDefinitionTask(target, lib));
     // Add bundle exporteds
-    const entries = create_export_map(lib, lib.bundle);
+    const entries = create_export_map(lib, lib.master);
     for (const exp_id in entries) {
         const exp = entries[exp_id];
         target.esmodules.add_entry(exp.basename, exp.source);
@@ -34,11 +35,11 @@ export function create_bundle_target(opts) {
     // Add bundle content
     if (bundle) {
         // Add bundle manifest
-        target.tasks.push(new BundleManifestTask(target, lib.bundle));
+        target.tasks.push(new BundleManifestTask(target, bundle));
         // Add bundle components
         for (const [path, desc] of bundle.components) {
             const baseDir = Path.dirname(path);
-            target.add_component(desc, baseDir, lib);
+            target.add_component(desc, baseDir, bundle);
         }
     }
     // Add declarations descriptors
@@ -158,7 +159,7 @@ export function create_bundle_target(opts) {
                 return {
                     contents,
                     loader: "js",
-                    resolveDir: target.workspace.path,
+                    resolveDir: lib.path,
                 };
             });
             // Handle imports from within the proxy modules - these should be truly external
@@ -187,6 +188,9 @@ export async function build_app_composable_bundle(opts) {
             watch: opts.watch,
             clean: opts.clean,
         });
+        if (opts.artifactDir) {
+            target.finalTasks.push(new ArtifactNpmTask(target, opts.artifactDir));
+        }
         target.log.info(`Build bundle: ${target.name}`);
         await target.build();
         return target;

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

@@ -7,6 +7,7 @@ import { PWAPackageTask, WebviewTask } from "./build-application.js";
 import { makeComponentPublication } from "../workspace/component.js";
 import { topologicalSort } from "../utils/graph-ordering.js";
 import { BuildTask } from "./helpers/task.js";
+import { ArtifactZipTask } from "./helpers/emit-artifact.js";
 export class ShelveManifestTask extends BuildTask {
     target;
     bundles;
@@ -45,11 +46,9 @@ export class ShelveManifestTask extends BuildTask {
 }
 function create_application_composable_target(opts) {
     const { app, bundles, version } = opts;
-    const { type, name, webviews, modules, assets, components } = app.descriptor;
-    const lib = app.library;
-    const bundle = lib.bundle;
-    const ws = lib.workspace;
-    const target = new BuildTarget(name, opts.storage, ws, opts.devmode == true, opts.watch == true, opts.clean == true);
+    const { name, webviews, modules, components } = app.descriptor;
+    const { library: lib } = app;
+    const target = new BuildTarget(name, opts.storage, lib, opts.devmode == true, opts.watch == true, opts.clean == true, opts.onNotification);
     // Prepare esm setup
     target.esmodules.set_root(lib.path);
     // Generate hotreload assets
@@ -70,7 +69,7 @@ function create_application_composable_target(opts) {
         const entry_name = lib.make_file_id("webview", name);
         const webview = {
             ...webviews[name],
-            entry: `./${bundle.id}/${entry_name}.js`,
+            entry: `./${lib.master.id}/${entry_name}.js`,
             favicon: favicon ? app.library.resolve_entry_path(favicon, Path.dirname(app.baseDir)) : null,
         };
         target.tasks.push(new WebviewTask(target, name, title || name, webview, html_injects));
@@ -82,7 +81,7 @@ function create_application_composable_target(opts) {
     for (const name in modules) {
         if (name.endsWith(".js")) {
             const entry_name = lib.make_file_id("module", name.slice(0, -3));
-            target.esmodules.add_entry_typescript(`export * from "./${bundle.id}/${entry_name}.js"`, name.slice(0, -3));
+            target.esmodules.add_entry_typescript(`export * from "./${lib.master.id}/${entry_name}.js"`, name.slice(0, -3));
             if (opts.devserver) {
                 target.log.info(`+ 🔌 module: ${name} : ${opts.devserver}/${name}`);
             }
@@ -107,14 +106,14 @@ function create_application_composable_target(opts) {
        }
     }*/
     // Add workspace assets
-    for (const lib of ws.libraries) {
-        for (const [path, desc] of lib.declarations) {
+    for (const slib of lib.workspace.libraries) {
+        for (const [path, desc] of slib.declarations) {
             if (!matchComponentSelection(components, desc.selectors))
                 continue;
             if (desc.assets) {
                 const baseDir = Path.dirname(path);
                 for (const entry of desc.assets) {
-                    target.assets.add_entry(entry, baseDir, lib);
+                    target.assets.add_entry(entry, baseDir, slib);
                 }
             }
         }
@@ -123,12 +122,11 @@ function create_application_composable_target(opts) {
 }
 export async function build_app_composable_host(opts) {
     const { app, storage } = opts;
-    const ws = app.library.workspace;
+    const { library: lib } = app;
     opts.storage.clean();
-    const shelveBundles = new BundleSelector(ws);
-    const { bundle } = app.library;
-    if (bundle)
-        shelveBundles.add(bundle);
+    const shelveBundles = new BundleSelector(lib.workspace);
+    if (lib.master)
+        shelveBundles.add(lib.master);
     const shelvePendings = [];
     for (const bundle of shelveBundles) {
         shelvePendings.push(build_app_composable_bundle({
@@ -141,7 +139,7 @@ export async function build_app_composable_host(opts) {
         }));
     }
     if (shelveBundles.missing.length > 0) {
-        ws.log.warn(`Missing bundle dependencies: ${shelveBundles.missing.join(", ")}`);
+        lib.log.warn(`Missing bundle dependencies: ${shelveBundles.missing.join(", ")}`);
     }
     const target = create_application_composable_target({
         app,
@@ -152,7 +150,11 @@ export async function build_app_composable_host(opts) {
         devserver: opts.devserver,
         watch: opts.devserver ? true : opts.watch,
         clean: opts.clean,
+        onNotification: opts.onNotification,
     });
+    if (opts.artifactDir) {
+        target.finalTasks.push(new ArtifactZipTask(target, opts.artifactDir, target.name));
+    }
     target.log.info(`Build app: ${target.name}`);
     return target.build();
 }
@@ -187,8 +189,8 @@ export class BundleSelector {
         if (bun.source) {
             for (const depId in bun.source.descriptor?.dependencies) {
                 const lib = this.workspace.get_library(depId);
-                if (lib?.bundle)
-                    this.add(lib.bundle);
+                if (lib?.master)
+                    this.add(lib.master);
             }
         }
         return this;

package/esm/builder/build-application.d.ts

@@ -4,6 +4,7 @@ import { StorageFiles } from "../workspace/storage.ts";
 import { BuildTarget } from "./build-target.ts";
 import type { WebAppManifest } from "web-app-manifest";
 import { BuildTask } from "./helpers/task.ts";
+import type { BuildNotification } from "./build-target.ts";
 export type BuildApplicationOptions = {
     app: AppEntry;
     storage: StorageFiles;
@@ -12,6 +13,8 @@ export type BuildApplicationOptions = {
     watch?: boolean;
     clean?: boolean;
     devserver?: string;
+    artifactDir?: string;
+    onNotification?: (event: BuildNotification) => void;
 };
 export declare function create_application_monolith_target(opts: {
     app: AppEntry;
@@ -21,6 +24,7 @@ export declare function create_application_monolith_target(opts: {
     devserver?: string;
     watch: boolean;
     clean: boolean;
+    onNotification?: BuildApplicationOptions["onNotification"];
 }): BuildTarget;
 export declare function build_app_monolith(opts: BuildApplicationOptions): Promise<void>;
 export declare function build_application(opts: BuildApplicationOptions): Promise<void>;

package/esm/builder/build-application.js

@@ -1,41 +1,20 @@
 import Path from "node:path";
 import Sharp from "sharp";
 import MIME from "mime";
-import { Library, matchComponentSelection } from "../workspace/workspace.js";
+import { Bundle, matchComponentSelection } from "../workspace/workspace.js";
 import { StorageFiles } from "../workspace/storage.js";
 import { BuildTarget } from "./build-target.js";
 import { build_app_composable_host } from "./build-app-host.js";
 import { DependencyDeduplicationPlugin } from "./helpers/emit-esmodules.js";
-import { BundleManifestTask } from "./helpers/emit-bundle-manifest.js";
+import { ApplicationManifestTask } 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) {
-        const ws = lib.workspace;
-        const deps = {
-            ...lib.descriptor.dependencies,
-            ...lib.descriptor.peerDependencies,
-            ...lib.descriptor.optionalDependencies,
-        };
-        for (const depId in deps) {
-            const lib = ws.get_library(depId);
-            if (lib && !libs.includes(lib)) {
-                libs.push(lib);
-            }
-        }
-    }
-    for (let i = 0; i < libs.length; i++) {
-        collect_library_deps(libs[i]);
-    }
-    return libs;
-}
+import { ArtifactZipTask } from "./helpers/emit-artifact.js";
 export function create_application_monolith_target(opts) {
     const { app, version } = opts;
     const { type, name, webviews, modules, assets, components } = app.descriptor;
-    const lib = app.library;
-    const target = new BuildTarget(name, opts.storage, lib.workspace, opts.devmode == true, opts.watch == true, opts.clean == true);
-    const libs = collect_app_libraries(app);
-    target.log.info(`+ 🧭 app-library-graph: ${libs.map(lib => `${lib.name}@${lib.descriptor.version}`).join(", ")}`);
+    const { library: lib } = app;
+    const target = new BuildTarget(name, opts.storage, lib, opts.devmode == true, opts.watch == true, opts.clean == true, opts.onNotification);
+    target.log.info(`+ 📚 shelve: ${lib.shelve.map(b => b.id).join(", ")}`);
     // Prepare esm setup
     target.esmodules.set_root(lib.path);
     // Generate hotreload assets
@@ -62,12 +41,12 @@ export function create_application_monolith_target(opts) {
     for (const name in webviews) {
         const { title, favicon, entry } = webviews[name];
         const entry_name = lib.make_file_id("webview", name);
-        const entry_path = app.library.resolve_entry_path(entry, app.baseDir);
+        const entry_path = lib.resolve_entry_path(entry, app.baseDir);
         target.esmodules.add_entry(entry_name, entry_path);
         const webview = {
             ...webviews[name],
             entry: `./${entry_name}.js`,
-            favicon: favicon ? app.library.resolve_entry_path(favicon, app.baseDir) : null,
+            favicon: favicon ? lib.resolve_entry_path(favicon, app.baseDir) : null,
         };
         target.tasks.push(new WebviewTask(target, name, title || name, webview, html_injects));
         if (opts.devserver) {
@@ -76,7 +55,7 @@ export function create_application_monolith_target(opts) {
     }
     // Add application modules
     for (const name in modules) {
-        const entry_path = app.library.resolve_entry_path(modules[name], app.baseDir);
+        const entry_path = lib.resolve_entry_path(modules[name], app.baseDir);
         if (!entry_path) {
             target.log.error(`Invalid module '${name}' path at ${entry_path}`);
         }
@@ -94,65 +73,62 @@ export function create_application_monolith_target(opts) {
     // Add application static assets
     if (Array.isArray(assets)) {
         for (const asset of assets) {
-            target.assets.add_entry(asset, app.baseDir, app.library);
+            target.assets.add_entry(asset, app.baseDir, lib);
         }
     }
-    // Add bundle content
-    const { bundle } = lib;
-    if (bundle) {
-        // Add bundle manifest
-        target.tasks.push(new BundleManifestTask(target, bundle));
-        // Add workspace components
-        const added_components = new Map();
-        for (const lib of libs) {
-            if (lib.bundle) {
-                for (const [path, desc] of lib.bundle.components) {
-                    if (!matchComponentSelection(components, desc.selectors))
-                        continue;
-                    const cid = desc.$id;
-                    const added = added_components.get(cid);
-                    if (added) {
-                        target.log.error({
-                            id: "duplicate-component-skip",
-                            text: `skip duplicate component '${cid}'`,
-                            notes: [
-                                {
-                                    title: "kept",
-                                    text: `${added.lib.name}@${added.lib.descriptor.version}`,
-                                    location: added.path,
-                                },
-                                {
-                                    title: "skipped",
-                                    text: `${lib.name}@${lib.descriptor.version}`,
-                                    location: path,
-                                },
-                            ],
-                        });
-                        continue;
-                    }
-                    const baseDir = Path.dirname(path);
-                    target.add_component(desc, baseDir, lib);
-                    added_components.set(cid, { lib, path });
-                }
+    // Add workspace components
+    const added_components = new Map();
+    for (const bundle of lib.shelve) {
+        for (const [path, desc] of bundle.components) {
+            if (!matchComponentSelection(components, desc.selectors))
+                continue;
+            const cid = desc.$id;
+            const added = added_components.get(cid);
+            if (added) {
+                target.log.error({
+                    id: "duplicate-component-skip",
+                    text: `skip duplicate component '${cid}'`,
+                    notes: [
+                        {
+                            title: "kept",
+                            text: `${added.bundle.id}`,
+                            location: added.path,
+                        },
+                        {
+                            title: "skipped",
+                            text: `${bundle.id}`,
+                            location: path,
+                        },
+                    ],
+                });
+                continue;
             }
+            const baseDir = Path.dirname(path);
+            target.add_component(desc, baseDir, bundle);
+            added_components.set(cid, { bundle, path });
         }
     }
+    // Add bundle manifest
+    target.tasks.push(new ApplicationManifestTask(target, app.descriptor));
     // Add workspace assets
-    for (const lib of libs) {
-        for (const [path, desc] of lib.declarations) {
+    for (const bundle of lib.shelve) {
+        if (!bundle.source)
+            continue;
+        for (const [path, desc] of bundle.source.declarations) {
             if (!matchComponentSelection(components, desc.selectors))
                 continue;
             if (desc.assets) {
                 const baseDir = Path.dirname(path);
                 for (const entry of desc.assets) {
-                    target.assets.add_entry(entry, baseDir, lib);
+                    target.assets.add_entry(entry, baseDir, bundle.source);
                 }
             }
         }
     }
     // Register esbuild plugin for dependency deduplication (graph-based + singleton)
+    const bundleLibs = lib.shelve.map(b => b.source).filter(Boolean);
     const rootNodeModules = lib.search_directories[0] || Path.join(lib.path, 'node_modules');
-    target.esmodules.plugins.push(DependencyDeduplicationPlugin(libs, rootNodeModules, target.log));
+    target.esmodules.plugins.push(DependencyDeduplicationPlugin(bundleLibs, rootNodeModules, target.log));
     return target;
 }
 export async function build_app_monolith(opts) {
@@ -166,7 +142,11 @@ export async function build_app_monolith(opts) {
         devserver: opts.devserver,
         watch: opts.devserver ? true : opts.watch,
         clean: opts.clean,
+        onNotification: opts.onNotification,
     });
+    if (opts.artifactDir) {
+        target.finalTasks.push(new ArtifactZipTask(target, opts.artifactDir, target.name));
+    }
     target.log.info(`Build app: ${target.name}`);
     return target.build();
 }

package/esm/builder/build-library.d.ts

@@ -8,6 +8,7 @@ export type BuildLibraryOptions = {
     devmode: boolean;
     watch: boolean;
     clean: boolean;
+    artifactDir?: string;
 };
 export declare function create_library_target(opts: {
     library: Library;

package/esm/builder/build-library.js

@@ -8,13 +8,14 @@ import { PackageManifestTask } from "./helpers/emit-package-manifest.js";
 import { create_export_map } from "../workspace/helpers/create-manifests.js";
 import { BundleManifestTask } from "./helpers/emit-bundle-manifest.js";
 import { ComponentsDtsTask } from "./helpers/emit-components-dts.js";
+import { ArtifactNpmTask } from "./helpers/emit-artifact.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 target = new BuildTarget(lib.name, opts.storage, lib, opts.devmode == true, opts.watch == true, opts.clean == true);
     // Prepare esm setup
     target.esmodules.set_root(lib.path);
     // Add bundle exporteds
-    const entries = create_export_map(lib, lib.bundle);
+    const entries = create_export_map(lib, lib.master);
     for (const exp_id in entries) {
         const exp = entries[exp_id];
         target.esmodules.add_entry(exp.basename, exp.source);
@@ -23,16 +24,16 @@ export function create_library_target(opts) {
     target.tasks.push(new TypescriptDefinitionTask(target, lib));
     // Add library package.json
     target.tasks.push(new PackageManifestTask(target, lib, opts.version));
-    target.tasks.push(new ComponentsDtsTask(target, lib.bundle));
+    target.tasks.push(new ComponentsDtsTask(target, lib.master));
     // Add bundle content
-    const { bundle } = lib;
-    if (bundle) {
+    const { master } = lib;
+    if (master) {
         // Add bundle catalog
-        target.tasks.push(new BundleManifestTask(target, bundle));
+        target.tasks.push(new BundleManifestTask(target, master));
         // Add library components
-        for (const [path, desc] of bundle.components) {
+        for (const [path, desc] of master.components) {
             const baseDir = Path.dirname(path);
-            target.add_component(desc, baseDir, lib);
+            target.add_component(desc, baseDir, master);
         }
     }
     // Add declarations descriptors
@@ -70,6 +71,9 @@ export async function build_library(opts, packageDir) {
         watch: opts.watch,
         clean: opts.clean,
     });
+    if (opts.artifactDir) {
+        target.finalTasks.push(new ArtifactNpmTask(target, opts.artifactDir));
+    }
     target.log.info(`Build library: ${target.name}`);
     await target.build();
     if (!target.watch && packageDir) {

package/esm/builder/build-target.d.ts

@@ -1,27 +1,36 @@
 import { type ComponentManifest } from "../workspace/component.ts";
-import { Library, Workspace } from "../workspace/workspace.ts";
+import { Bundle, Library } from "../workspace/workspace.ts";
 import type { Log } from "../workspace/helpers/logger.ts";
 import { ESModulesTask } from "./helpers/emit-esmodules.ts";
 import { type IStorageTransaction, type IStorageZone } from "../workspace/storage.ts";
 import { AssetsTask } from "./helpers/emit-static-assets.ts";
 import type { BuildTask } from "./helpers/task.ts";
+export type BuildNotification = {
+    target?: string;
+    task?: string;
+} & ({
+    type: "build-complete";
+    elapsed: number;
+});
 export declare class BuildTarget {
     readonly name: string;
     readonly storage: IStorageZone;
-    readonly workspace: Workspace;
+    readonly library: Library;
     readonly devmode: boolean;
     readonly watch: boolean;
     readonly clean: boolean;
+    readonly onNotification?: (event: BuildNotification) => void;
     components: Map<string, ComponentManifest>;
     esmodules: ESModulesTask;
     assets: AssetsTask;
     tasks: BuildTask[];
+    finalTasks: BuildTask[];
     transaction: IStorageTransaction;
     readonly log: Log;
-    constructor(name: string, storage: IStorageZone, workspace: Workspace, devmode: boolean, watch: boolean, clean: boolean);
+    constructor(name: string, storage: IStorageZone, library: Library, devmode: boolean, watch: boolean, clean: boolean, onNotification?: (event: BuildNotification) => void);
     edit(): IStorageTransaction;
     store(): Promise<void>;
-    add_component(descriptor: ComponentManifest, baseDir: string, library: Library): void;
+    add_component(descriptor: ComponentManifest, baseDir: string, origin: Bundle): boolean;
     private chrona;
     build(): Promise<void>;
 }

package/esm/builder/build-target.js

@@ -1,29 +1,32 @@
 import {} from "../workspace/component.js";
-import { Library, Workspace } from "../workspace/workspace.js";
+import { Bundle, Library } from "../workspace/workspace.js";
 import { ESModulesTask } from "./helpers/emit-esmodules.js";
 import {} from "../workspace/storage.js";
 import { AssetsTask } from "./helpers/emit-static-assets.js";
 export class BuildTarget {
     name;
     storage;
-    workspace;
+    library;
     devmode;
     watch;
     clean;
+    onNotification;
     components = new Map();
     esmodules = new ESModulesTask(this);
     assets = new AssetsTask(this);
     tasks = [];
+    finalTasks = [];
     transaction = null;
     log;
-    constructor(name, storage, workspace, devmode, watch, clean) {
+    constructor(name, storage, library, devmode, watch, clean, onNotification) {
         this.name = name;
         this.storage = storage;
-        this.workspace = workspace;
+        this.library = library;
         this.devmode = devmode;
         this.watch = watch;
         this.clean = clean;
-        this.log = workspace.logger.get(`build:${name}`);
+        this.onNotification = onNotification;
+        this.log = library.log.logger.get(`build:${name}`);
     }
     edit() {
         if (!this.transaction)
@@ -36,10 +39,11 @@ export class BuildTarget {
             this.transaction = null;
         }
     }
-    add_component(descriptor, baseDir, library) {
+    add_component(descriptor, baseDir, origin) {
         const id = descriptor.$id;
         if (this.components.has(id)) {
-            throw new Error(createComponentDuplicateMessage(id, library));
+            this.log.error(createComponentDuplicateMessage(id, origin));
+            return false;
         }
         const manifest = {
             ...descriptor,
@@ -50,16 +54,17 @@ export class BuildTarget {
         if (descriptor.apis) {
             manifest.apis = {};
             for (const name in descriptor.apis) {
-                manifest.apis[name] = this.esmodules.add_resource_entry(descriptor.apis[name], baseDir, library);
+                manifest.apis[name] = this.esmodules.add_resource_entry(descriptor.apis[name], baseDir, origin);
             }
         }
         if (descriptor.resources) {
             manifest.resources = {};
             for (const name in descriptor.resources) {
-                manifest.resources[name] = this.esmodules.add_resource_entry(descriptor.resources[name], baseDir, library);
+                manifest.resources[name] = this.esmodules.add_resource_entry(descriptor.resources[name], baseDir, origin);
             }
         }
         this.components.set(id, manifest);
+        return true;
     }
     async chrona(task) {
         const name = task.constructor.name;
@@ -84,6 +89,7 @@ export class BuildTarget {
         // Trace time
         const buildTime = (Date.now() - buildStartTime) / 1000;
         this.log.info(`Build completed in ${buildTime.toFixed(2)}s`);
+        this.onNotification?.({ type: "build-complete", target: this.name, elapsed: buildTime });
         if (this.watch) {
             await new Promise((resolve) => {
                 process.on('SIGQUIT', () => resolve(null));
@@ -91,13 +97,16 @@ export class BuildTarget {
         }
         else {
             await this.store();
+            for (const task of this.finalTasks) {
+                await this.chrona(task);
+            }
         }
     }
 }
-function createComponentDuplicateMessage(id, library) {
+function createComponentDuplicateMessage(id, origin) {
     const duplicates = [];
     const libs = [];
-    for (const bun of library.shelve) {
+    for (const bun of origin.library.shelve) {
         for (const [cpath, cmanifest] of bun.components.entries()) {
             if (cmanifest.$id === id) {
                 duplicates.push(`\n - ${cpath}`);

package/esm/builder/helpers/emit-artifact.d.ts

@@ -0,0 +1,13 @@
+import { BuildTask } from "./task.ts";
+import type { BuildTarget } from "../build-target.ts";
+export declare class ArtifactNpmTask extends BuildTask {
+    readonly outputDir: string;
+    constructor(target: BuildTarget, outputDir: string);
+    execute(): Promise<void>;
+}
+export declare class ArtifactZipTask extends BuildTask {
+    readonly outputDir: string;
+    readonly name: string;
+    constructor(target: BuildTarget, outputDir: string, name: string);
+    execute(): Promise<void>;
+}

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

@@ -0,0 +1,40 @@
+import Path from "node:path";
+import FS from "node:fs";
+import ChildProcess from "node:child_process";
+import { BuildTask } from "./task.js";
+export class ArtifactNpmTask extends BuildTask {
+    outputDir;
+    constructor(target, outputDir) {
+        super(target);
+        this.outputDir = outputDir;
+    }
+    async execute() {
+        const sourceDir = this.target.storage.getBaseDirFS();
+        FS.mkdirSync(this.outputDir, { recursive: true });
+        this.log.info(`📦 npm pack → ${this.outputDir}`);
+        ChildProcess.execSync("npm pack --pack-destination " + JSON.stringify(this.outputDir), { cwd: sourceDir });
+    }
+}
+export class ArtifactZipTask extends BuildTask {
+    outputDir;
+    name;
+    constructor(target, outputDir, name) {
+        super(target);
+        this.outputDir = outputDir;
+        this.name = name;
+    }
+    async execute() {
+        const sourceDir = this.target.storage.getBaseDirFS();
+        FS.mkdirSync(this.outputDir, { recursive: true });
+        const outPath = Path.join(this.outputDir, `${this.name}.zip`);
+        this.log.info(`📦 zip → ${outPath}`);
+        const parent = Path.dirname(sourceDir);
+        const base = Path.basename(sourceDir);
+        if (process.platform === 'win32') {
+            ChildProcess.execSync(`powershell -NoProfile -Command "Compress-Archive -Path '${base}\\*' -DestinationPath '${outPath}' -Force"`, { cwd: parent });
+        }
+        else {
+            ChildProcess.execSync(`zip -r ${JSON.stringify(outPath)} ${JSON.stringify(base)}`, { cwd: parent });
+        }
+    }
+}