@jointhedots/gear 1.1.17 → 1.2.0

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

@@ -1,11 +1,11 @@
 import Path from "node:path";
-import { Bundle, Library } from "../model/workspace.js";
-import { StorageFiles } from "../model/storage.js";
+import { Bundle, Library } from "../workspace/workspace.js";
+import { StorageFiles } from "../workspace/storage.js";
 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_export_map } from "../model/helpers/create-manifests.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";
 export var PathStatus;
@@ -17,8 +17,7 @@ export var PathStatus;
     PathStatus[PathStatus["ExternalBundle"] = 4] = "ExternalBundle";
 })(PathStatus || (PathStatus = {}));
 export function create_bundle_target(opts) {
-    const { bundle, library, storage } = opts;
-    const lib = library;
+    const { bundle, library: lib, storage } = opts;
     const target = new BuildTarget(bundle.id, storage, lib.workspace, opts.devmode == true, opts.watch == true, opts.clean == true);
     // Prepare esm setup
     target.esmodules.set_root(lib.path);
@@ -84,7 +83,7 @@ export function create_bundle_target(opts) {
             paths_qualifier.set(dep, PathStatus.ExternalBundle);
         }
     }
-    for (const xbun of lib.workspace.bundles) {
+    for (const xbun of lib.shelve) {
         if (xbun !== bundle) {
             paths_qualifier.set(xbun.id, xbun);
             paths_qualifier.set(xbun.alias, xbun);
@@ -120,14 +119,14 @@ export function create_bundle_target(opts) {
                 }
                 let state = paths_qualifier.check(path);
                 if (state === PathStatus.Dependency || state === PathStatus.External) {
-                    //target.log.info(`External: ${path} <- ${importer}`)
+                    //target.log.warn(`External: ${path} <- ${importer}`)
                     return { external: true };
                 }
                 if (state === PathStatus.ExternalBundle) {
                     throw new Error(`ExternalBundle: ${path} <- ${importer}`);
                 }
                 if (state instanceof Bundle) {
-                    //target.log.info(`Bundle: ${state.id} <- ${importer}`)
+                    //target.log.warn(`Bundle: ${state.id} <- ${importer}`)
                     const entry_id = state.resolve_export(path);
                     if (!entry_id) {
                         return { errors: [{ text: `Bundle '${state.id}' do not distribute expected entry: ${path}` }] };
@@ -148,7 +147,7 @@ export function create_bundle_target(opts) {
                         namespace: "external-bundle-proxy",
                     };
                 }
-                //target.log.trace(`Internal: ${path} <- ${importer}`)
+                //target.log.warn(`Internal: ${path} <- ${importer}`)
             });
             // Load virtual proxy modules for external bundle references
             build.onLoad({ filter: /.*/, namespace: "external-bundle-proxy" }, (args) => {
@@ -169,9 +168,8 @@ export function create_bundle_target(opts) {
         }
     });
     // Register esbuild plugin for dependency deduplication (graph-based + singleton)
-    const ws = library.workspace;
-    const rootNodeModules = ws.search_directories[0] || Path.join(ws.path, 'node_modules');
-    const libGraph = collectLibraryGraph(library);
+    const rootNodeModules = lib.search_directories[0] || Path.join(lib.path, 'node_modules');
+    const libGraph = collectLibraryGraph(lib);
     target.esmodules.plugins.push(DependencyDeduplicationPlugin(libGraph, rootNodeModules, target.log));
     return target;
 }
@@ -191,6 +189,7 @@ export async function build_app_composable_bundle(opts) {
         });
         target.log.info(`Build bundle: ${target.name}`);
         await target.build();
+        return target;
     }
     else {
         bundle.log.info(`Prebuild bundle: ${opts.bundle.id}`);

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

@@ -1,12 +1,50 @@
-import { Bundle, matchComponentSelection, Workspace, } from "../model/workspace.js";
-import { StorageFiles } from "../model/storage.js";
+import { Bundle, matchComponentSelection, Workspace, } from "../workspace/workspace.js";
+import { StorageFiles } from "../workspace/storage.js";
 import { BuildTarget } from "./build-target.js";
 import { build_app_composable_bundle } from "./build-app-bundle.js";
 import Path from "node:path";
 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";
+export class ShelveManifestTask extends BuildTask {
+    target;
+    bundles;
+    constructor(target, bundles) {
+        super(target);
+        this.target = target;
+        this.bundles = bundles;
+    }
+    async execute() {
+        const { bundles } = this;
+        // Emit static components manifest
+        const namespaces = new Set();
+        const components = [];
+        for (const bundle of bundles) {
+            const pub = makeComponentPublication(bundle.manifest);
+            const nss = bundle.manifest.type === "bundle" && bundle.manifest.data?.["namespaces"];
+            if (Array.isArray(nss)) {
+                for (const ns of nss) {
+                    namespaces.add(ns);
+                }
+            }
+            components.push(pub);
+        }
+        // Emit bundle manifest
+        const tx = this.target.edit();
+        const manifest = {
+            $id: ".",
+            type: "bundle",
+            data: {
+                namespaces: Array.from(namespaces),
+                components,
+            }
+        };
+        await tx.commitFile(`bundle.manifest.json`, JSON.stringify(manifest, null, 2));
+    }
+}
 function create_application_composable_target(opts) {
-    const { app, version } = opts;
+    const { app, bundles, version } = opts;
     const { type, name, webviews, modules, assets, components } = app.descriptor;
     const lib = app.library;
     const bundle = lib.bundle;
@@ -24,6 +62,8 @@ function create_application_composable_target(opts) {
     html_injects.push(`<link rel="manifest" href="/manifest.json">`);
     html_injects.push(`<link rel="icon" type="image/webp" href="favicon.webp" />`);
     target.tasks.push(new PWAPackageTask(target, app));
+    // Generate shelve manifest
+    target.tasks.push(new ShelveManifestTask(target, bundles));
     // Add application webviews
     for (const name in webviews) {
         const { title, favicon } = webviews[name];
@@ -103,9 +143,9 @@ export async function build_app_composable_host(opts) {
     if (shelveBundles.missing.length > 0) {
         ws.log.warn(`Missing bundle dependencies: ${shelveBundles.missing.join(", ")}`);
     }
-    await Promise.all(shelvePendings);
     const target = create_application_composable_target({
         app,
+        bundles: await Promise.all(shelveBundles),
         storage: opts.storage,
         version: opts.version,
         devmode: opts.devmode,
@@ -139,8 +179,10 @@ export class BundleSelector {
         this.selected.set(bun.id, bun);
         // Recursively add dependencies
         const deps = bun.dependencies;
-        for (const depId of deps) {
-            this.add(depId);
+        if (deps) {
+            for (const depId of deps) {
+                this.add(depId);
+            }
         }
         if (bun.source) {
             for (const depId in bun.source.descriptor?.dependencies) {

package/esm/builder/build-application.js

@@ -1,8 +1,8 @@
 import Path from "node:path";
 import Sharp from "sharp";
 import MIME from 'mime';
-import { Library, matchComponentSelection } from "../model/workspace.js";
-import { StorageFiles } from "../model/storage.js";
+import { Library, 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";
@@ -33,8 +33,7 @@ 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 ws = lib.workspace;
-    const target = new BuildTarget(name, opts.storage, ws, opts.devmode == true, opts.watch == true, opts.clean == true);
+    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(", ")}`);
     // Prepare esm setup
@@ -152,7 +151,7 @@ export function create_application_monolith_target(opts) {
         }
     }
     // Register esbuild plugin for dependency deduplication (graph-based + singleton)
-    const rootNodeModules = ws.search_directories[0] || Path.join(ws.path, 'node_modules');
+    const rootNodeModules = lib.search_directories[0] || Path.join(lib.path, 'node_modules');
     target.esmodules.plugins.push(DependencyDeduplicationPlugin(libs, rootNodeModules, target.log));
     return target;
 }

package/esm/builder/build-library.js

@@ -1,12 +1,13 @@
 import Path from "node:path";
 import ChildProcess from "child_process";
-import { Library } from "../model/workspace.js";
-import { StorageFiles } from "../model/storage.js";
+import { Library } from "../workspace/workspace.js";
+import { StorageFiles } from "../workspace/storage.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 { 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";
 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);
@@ -22,6 +23,7 @@ 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));
     // Add bundle content
     const { bundle } = lib;
     if (bundle) {

package/esm/builder/build-target.js

@@ -1,7 +1,7 @@
-import {} from "../model/component.js";
-import { Library, Workspace } from "../model/workspace.js";
+import {} from "../workspace/component.js";
+import { Library, Workspace } from "../workspace/workspace.js";
 import { ESModulesTask } from "./helpers/emit-esmodules.js";
-import {} from "../model/storage.js";
+import {} from "../workspace/storage.js";
 import { AssetsTask } from "./helpers/emit-static-assets.js";
 export class BuildTarget {
     name;
@@ -39,7 +39,7 @@ export class BuildTarget {
     add_component(descriptor, baseDir, library) {
         const id = descriptor.$id;
         if (this.components.has(id)) {
-            throw new Error(createComponentDuplicateMessage(id, this.workspace));
+            throw new Error(createComponentDuplicateMessage(id, library));
         }
         const manifest = {
             ...descriptor,
@@ -94,10 +94,10 @@ export class BuildTarget {
         }
     }
 }
-function createComponentDuplicateMessage(id, workspace) {
+function createComponentDuplicateMessage(id, library) {
     const duplicates = [];
     const libs = [];
-    for (const bun of workspace.bundles) {
+    for (const bun of library.shelve) {
         for (const [cpath, cmanifest] of bun.components.entries()) {
             if (cmanifest.$id === id) {
                 duplicates.push(`\n - ${cpath}`);

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

@@ -1,4 +1,4 @@
-import { makeComponentPublication } from "../../model/component.js";
+import { makeComponentPublication } from "../../workspace/component.js";
 import { BuildTarget } from "../build-target.js";
 import { BuildTask } from "./task.js";
 import MIME from 'mime';

package/esm/builder/helpers/emit-components-dts.js

@@ -0,0 +1,66 @@
+import { join } from "node:path";
+import { makeComponentPublication } from "../../workspace/component.js";
+import { BuildTarget } from "../build-target.js";
+import { BuildTask } from "./task.js";
+import MIME from 'mime';
+export class ComponentsDtsTask extends BuildTask {
+    target;
+    bundle;
+    constructor(target, bundle) {
+        super(target);
+        this.target = target;
+        this.bundle = bundle;
+    }
+    async execute() {
+        const { target, bundle } = this;
+        const tx = this.target.edit();
+        const chunks = [];
+        // Emit static components manifest
+        for (const manif of target.components.values()) {
+            chunks.push("\n");
+            generate_component_apis(manif, chunks);
+            chunks.push("\n");
+        }
+        // Emit bundle manifest
+        const dts = chunks.join("");
+        await tx.commitFile(`components.d.ts`, dts);
+        //console.log(dts)
+    }
+}
+function generate_component_apis(manif, chunks) {
+    for (const service in manif.apis) {
+        const generator = components_dts_generators[service];
+        if (generator) {
+            generator(manif, chunks);
+        }
+    }
+}
+function generate_view_react(manif, chunks) {
+    const props = manif.specs?.view?.properties;
+    chunks.push(`declare module 'view.react:${manif.$id}' {\n`);
+    chunks.push(`  import type { ReactComponentType, ReactComponentDescriptor } from "@jointhedots/core/interfaces/react"\n`);
+    if (props && Object.keys(props).length > 0) {
+        chunks.push(`  export type Props = {\n`);
+        for (const key of Object.keys(props)) {
+            chunks.push(`    ${key}?: any\n`);
+        }
+        chunks.push(`  }\n`);
+        chunks.push(`  export type Component = ReactComponentType<Props>\n`);
+    }
+    else {
+        chunks.push(`  export type Component = ReactComponentType\n`);
+    }
+    chunks.push(`  export type Descriptor = ReactComponentDescriptor\n`);
+    chunks.push(`}\n`);
+}
+function generate_commands(manif, chunks) {
+    chunks.push(`declare module 'commands:${manif.$id}' {\n`);
+    chunks.push(`  import type { CommandsService, Cmdlet } from "@jointhedots/core/interfaces/commands"\n`);
+    chunks.push(`  export type Service = CommandsService\n`);
+    chunks.push(`}\n`);
+}
+const components_dts_generators = {
+    "view.react": generate_view_react,
+    "commands": generate_commands,
+};
+//# sourceMappingURL=emit-components-dts.js.map

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

@@ -6,7 +6,7 @@ import postcss from 'postcss';
 import * as esbuild from 'esbuild';
 import { sassPlugin } from 'esbuild-sass-plugin';
 import { PackageRootDir, resolve_normalized_suffixed_path } from "../../utils/file.js";
-import { Library } from "../../model/workspace.js";
+import { Library } from "../../workspace/workspace.js";
 import { computeNameHashID } from "../../utils/normalized-name.js";
 import { BuildTask } from "./task.js";
 const VirtualOutDir = process.platform === 'win32' ? 'X:\\' : '/_/';

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

@@ -1,5 +1,5 @@
 import { BuildTask } from "./task.js";
-import { create_export_map, create_package_manifest } from "../../model/helpers/create-manifests.js";
+import { create_export_map, create_package_manifest } from "../../workspace/helpers/create-manifests.js";
 import { console } from "node:inspector";
 export class PackageManifestTask extends BuildTask {
     library;

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

@@ -1,7 +1,7 @@
 import Path from "node:path";
 import MIME from 'mime';
-import { Library } from "../../model/workspace.js";
-import { copyToStorageStream } from "../../model/storage.js";
+import { Library } from "../../workspace/workspace.js";
+import { copyToStorageStream } from "../../workspace/storage.js";
 import { BuildTask } from "./task.js";
 export class AssetsTask extends BuildTask {
     assets = [];

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

@@ -6,12 +6,16 @@ import { execFile } from 'child_process';
 import { promisify } from 'util';
 import { BuildTask } from "./task.js";
 import { BuildTarget } from "../build-target.js";
-import { Library } from "../../model/workspace.js";
+import { Library } from "../../workspace/workspace.js";
 import { file } from "../../utils/file.js";
-import { create_export_map } from "../../model/helpers/create-manifests.js";
+import { create_export_map } from "../../workspace/helpers/create-manifests.js";
 const eol = Os.EOL;
 const indent = "    ";
 const DTSLEN = '.d.ts'.length;
+const EXT_RE = /\.(d\.ts|tsx?|jsx?|mjs|json)$/;
+function normalizeModuleId(id) {
+    return id.replace(EXT_RE, '').replace(/\/index$/, '');
+}
 function normalizeFileName(filename) {
     return filename.replaceAll(Path.sep, "/");
 }
@@ -75,6 +79,19 @@ function isNodeKindStringLiteral(value) {
 function isNodeKindExportDeclaration(value) {
     return value && value.kind === Ts.SyntaxKind.ExportDeclaration;
 }
+function hasDefaultExport(sourceFile) {
+    return sourceFile.statements.some(stmt => {
+        if (stmt.kind === Ts.SyntaxKind.ExportAssignment)
+            return !stmt.isExportEquals;
+        const mods = Ts.canHaveModifiers(stmt) ? Ts.getModifiers(stmt) : undefined;
+        if (mods?.some(m => m.kind === Ts.SyntaxKind.ExportKeyword) && mods?.some(m => m.kind === Ts.SyntaxKind.DefaultKeyword))
+            return true;
+        if (isNodeKindExportDeclaration(stmt) && stmt.exportClause && Ts.isNamedExports(stmt.exportClause)) {
+            return stmt.exportClause.elements.some(e => e.name.text === 'default');
+        }
+        return false;
+    });
+}
 class TypescriptProject {
     baseDir;
     compilerOptions;
@@ -147,6 +164,7 @@ export function generateTypescriptDefinition(options) {
     const normalizedBaseDir = normalizeFileName(Path.resolve(baseDir)) + "/";
     const normalizedDtsDir = normalizeFileName(Path.resolve(project.dtsDir)) + "/";
     const resolveCache = new Map();
+    const modulesWithDefault = new Set();
     const outputParts = [];
     if (options.externs) {
         options.externs.forEach(function (path) {
@@ -173,17 +191,22 @@ export function generateTypescriptDefinition(options) {
     // Emit public re-export modules
     if (options.exports) {
         for (const entry of Object.values(options.exports)) {
+            if (!entry.source)
+                continue;
             const internalId = resolveInternalModuleImport(entry.source);
-            if (internalId) {
+            if (internalId.startsWith(prefix)) {
                 outputParts.push(`declare module '${entry.id}' {${eol}`);
                 outputParts.push(`${indent}export * from '${internalId}';${eol}`);
+                if (modulesWithDefault.has(internalId)) {
+                    outputParts.push(`${indent}export { default } from '${internalId}';${eol}`);
+                }
                 outputParts.push(`}${eol}${eol}`);
             }
         }
     }
     function resolveInternalModuleImport(moduleId, importDir = "") {
         if (moduleId.charAt(0) === '.') {
-            return prefix + normalizeFileName(Path.join(importDir, moduleId));
+            return prefix + normalizeModuleId(normalizeFileName(Path.join(importDir, moduleId)));
         }
         if (resolveCache.has(moduleId))
             return resolveCache.get(moduleId);
@@ -192,29 +215,25 @@ export function generateTypescriptDefinition(options) {
         if (result.resolvedModule && !result.resolvedModule.isExternalLibraryImport) {
             const resolved = normalizeFileName(result.resolvedModule.resolvedFileName);
             if (resolved.startsWith(normalizedBaseDir)) {
-                const value = prefix + resolved.slice(normalizedBaseDir.length).replace(/\.(d\.ts|tsx?|jsx?)$/, '');
+                const value = prefix + normalizeModuleId(resolved.slice(normalizedBaseDir.length));
                 resolveCache.set(moduleId, value);
                 return value;
             }
         }
-        // Check if moduleId is already an internal path relative to baseDir
-        const absolute = normalizeFileName(Path.resolve(baseDir, importDir, moduleId));
-        if (absolute.startsWith(normalizedBaseDir)) {
-            const value = prefix + absolute.slice(normalizedBaseDir.length);
-            resolveCache.set(moduleId, value);
-            return value;
-        }
-        resolveCache.set(moduleId, null);
-        return null;
+        // Not resolved as internal — keep the original module specifier
+        resolveCache.set(moduleId, moduleId);
+        return moduleId;
     }
     function writeDeclaration(declarationFile, rawSourceModuleId) {
-        const moduleDeclId = resolveInternalModuleImport(rawSourceModuleId);
+        const moduleDeclId = prefix + normalizeModuleId(rawSourceModuleId);
         const moduleDir = Path.dirname(rawSourceModuleId);
+        if (hasDefaultExport(declarationFile))
+            modulesWithDefault.add(moduleDeclId);
         outputParts.push(`declare module '${moduleDeclId}' {${eol}${indent}`);
         const content = processTree(declarationFile, function (node) {
             if (isNodeKindExternalModuleReference(node)) {
                 const expression = node.expression;
-                const resolved = resolveInternalModuleImport(expression.text, moduleDir) ?? expression.text;
+                const resolved = resolveInternalModuleImport(expression.text, moduleDir);
                 return ` require('${resolved}')`;
             }
             else if (isNodeKindImportDeclaration(node) && !node.importClause) {
@@ -226,7 +245,7 @@ export function generateTypescriptDefinition(options) {
             else if (isNodeKindStringLiteral(node) && node.parent &&
                 (isNodeKindExportDeclaration(node.parent) || isNodeKindImportDeclaration(node.parent) || isNodeKindImportType(node.parent?.parent))) {
                 const resolved = resolveInternalModuleImport(node.text, moduleDir);
-                if (resolved != null) {
+                if (resolved !== node.text) {
                     return ` '${resolved}'`;
                 }
             }

package/esm/cli.js

@@ -4,6 +4,7 @@ import Yargs from "yargs";
 import { hideBin } from 'yargs/helpers';
 import { command_run } from "./commands/run.js";
 import { command_init } from "./commands/init.js";
+import { command_install } from "./commands/install.js";
 import { command_make } from "./commands/make.js";
 import { command_serve } from "./commands/serve.js";
 import { command_publish } from "./commands/publish.js";
@@ -17,6 +18,7 @@ function command_fail() {
 }
 Yargs(hideBin(Process.argv)).scriptName("jointhedots-gear")
     .command(command_init())
+    .command(command_install())
     .command(command_make())
     .command(command_serve())
     .command(command_publish())

package/esm/commands/install.js

@@ -0,0 +1,67 @@
+import Path from 'node:path';
+import Fs from 'node:fs';
+import {} from "yargs";
+import { open_workspace } from "../workspace/workspace.js";
+import { makeComponentPublication } from "../workspace/component.js";
+import { BundleSelector } from "../builder/build-app-host.js";
+export function command_install() {
+    return {
+        command: 'install',
+        describe: 'Install workspace bundles and emit a shelve manifest',
+        builder: (yargs) => yargs
+            .strict()
+            .option("ws", {
+            type: "string",
+            default: ".",
+            describe: "Workspace directory"
+        })
+            .option("dist", {
+            type: "string",
+            default: ".",
+            describe: "Output directory"
+        }),
+        handler: async (argv) => {
+            const ws = await open_workspace({
+                workspace_path: argv.ws,
+                devmode: false,
+                ignored_directory: Path.resolve(argv.dist),
+            });
+            // Select all workspace bundles
+            const selector = new BundleSelector(ws);
+            for (const lib of ws.libraries) {
+                selector.add(lib.bundle);
+            }
+            if (selector.missing.length > 0) {
+                ws.log.warn(`Missing bundle dependencies: ${selector.missing.join(", ")}`);
+            }
+            // Build shelve manifest indexing all bundles
+            const namespaces = new Set();
+            const components = [];
+            for (const bundle of selector) {
+                const pub = makeComponentPublication(bundle.manifest);
+                const nss = bundle.manifest.type === "bundle" && bundle.manifest.data?.["namespaces"];
+                if (Array.isArray(nss)) {
+                    for (const ns of nss) {
+                        namespaces.add(ns);
+                    }
+                }
+                components.push(pub);
+            }
+            const manifest = {
+                $id: ".",
+                type: "bundle",
+                data: {
+                    namespaces: Array.from(namespaces),
+                    components,
+                }
+            };
+            // Write bundle.manifest.json to dist
+            const distDir = Path.resolve(argv.dist);
+            Fs.mkdirSync(distDir, { recursive: true });
+            const manifestPath = Path.join(distDir, "bundle.manifest.json");
+            Fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+            ws.log.success(`Shelve manifest written to ${manifestPath}`);
+        }
+    };
+}
+//# sourceMappingURL=install.js.map

package/esm/commands/make.js

@@ -1,12 +1,12 @@
 import Path from 'node:path';
 import {} from "yargs";
-import { StorageFiles } from "../model/storage.js";
-import { Bundle, Library, open_workspace } from "../model/workspace.js";
+import { StorageFiles } from "../workspace/storage.js";
+import { Bundle, Library, open_workspace } from "../workspace/workspace.js";
 import { build_application } from "../builder/build-application.js";
 import { build_app_composable_bundle } from "../builder/build-app-bundle.js";
 import { build_library } from "../builder/build-library.js";
 import { makeNormalizedName, NameStyle } from '../utils/normalized-name.js';
-import { resolvePackageVersion } from "../model/helpers/package-npm.js";
+import { resolvePackageVersion } from "../workspace/helpers/package-npm.js";
 export function command_make() {
     return {
         command: 'make',
@@ -88,8 +88,9 @@ export function command_make() {
             }
             const bundles = [];
             if (argv.bundles === "*") {
-                for (const bundle of ws.bundles) {
-                    bundles.push(bundle);
+                for (const lib of ws.libraries) {
+                    if (lib.bundle)
+                        bundles.push(lib.bundle);
                 }
             }
             else if (argv.bundles) {

package/esm/commands/publish.js

@@ -1,7 +1,7 @@
 import Path from 'node:path';
 import {} from "yargs";
 import { publish_aws_s3 } from '../publish/publish_aws_s3.js';
-import { open_workspace } from "../model/workspace.js";
+import { open_workspace } from "../workspace/workspace.js";
 export function command_publish() {
     return {
         command: 'publish',

package/esm/commands/serve.js

@@ -1,11 +1,11 @@
 import Path from 'node:path';
 import {} from "yargs";
-import { StorageFiles } from "../model/storage.js";
-import { open_workspace, Workspace } from "../model/workspace.js";
+import { StorageFiles } from "../workspace/storage.js";
+import { open_workspace, Workspace } from "../workspace/workspace.js";
 import { build_application } from "../builder/build-application.js";
 import { makeNormalizedName, NameStyle } from '../utils/normalized-name.js';
 import Express from 'express';
-import { resolvePackageVersion } from "../model/helpers/package-npm.js";
+import { resolvePackageVersion } from "../workspace/helpers/package-npm.js";
 export function command_serve() {
     return {
         command: 'serve',

package/esm/publish/publish_aws_s3.js

@@ -2,9 +2,9 @@ import Fs from "node:fs";
 import Path from "node:path";
 import * as AWS from "@aws-sdk/client-s3";
 import MIME from "mime";
-import { StorageFiles } from "../model/storage.js";
+import { StorageFiles } from "../workspace/storage.js";
 import { build_application } from "../builder/build-application.js";
-import { Workspace } from "../model/workspace.js";
+import { Workspace } from "../workspace/workspace.js";
 export async function publish_aws_s3(appname, ws, bucket, region, outputDir) {
     const storage = new StorageFiles(ws.name, outputDir);
     const app = ws.get_application(appname);