@jointhedots/gear 1.1.17 → 1.1.18

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;
@@ -120,14 +120,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 +148,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) => {
@@ -191,6 +191,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";

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;

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 bundle of ws.bundles) {
+                selector.add(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',

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);

package/esm/utils/normalized-name.js

@@ -50,15 +50,9 @@ export function isNormalizedName(name, expectedStyle) {
     const style = expectedStyle ?? detectNormalizedNameStyle(name);
     return check_name_regexes[style].test(name);
 }
-export function makeNormalizedKey(key, targetStyle) {
-    const seps = NormalizedNameSeparators[targetStyle];
-    const parts = key.replace(/[^a-z0-9\s\t\n:._-]/g, "").split(/[\s\t\n:._-]/g);
-    return parts.filter(x => !!x).join(seps.key);
-}
-export function makeNormalizedName(name, targetStyle, fromStyle) {
+export function getNormalizedKeys(name, fromStyle) {
     if (!name || typeof name !== "string")
-        return name;
-    const seps = NormalizedNameSeparators[targetStyle];
+        return [];
     // Split into lowercase keys
     let keys;
     name = name.toLowerCase();
@@ -81,8 +75,16 @@ export function makeNormalizedName(name, targetStyle, fromStyle) {
     }
     // Normalize keys
     for (let i = 0; i < keys.length; i++) {
-        keys[i] = makeNormalizedKey(keys[i], targetStyle);
+        keys[i] = keys[i].replace(/[^a-z0-9\s\t\n:._-]/g, "");
     }
+    return keys;
+}
+export function makeNormalizedName(name, targetStyle, fromStyle) {
+    if (!name || typeof name !== "string")
+        return name;
+    const seps = NormalizedNameSeparators[targetStyle];
+    // Split into lowercase keys
+    const keys = getNormalizedKeys(name, fromStyle);
     // Reform name, filtering out empty keys
     return keys.filter(x => !!x).join(seps.namespace);
 }

package/esm/{model → workspace}/helpers/create-manifests.js

@@ -1,6 +1,7 @@
 import Path from "node:path";
 import { makeComponentPublication } from "../component.js";
 import { resolve_normalized_suffixed_path } from "../../utils/file.js";
+import { getNormalizedKeys } from "../../utils/normalized-name.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);
@@ -49,13 +50,18 @@ export function create_bundle_manifest(lib, bun) {
         return null;
     const entries = create_export_map(lib, bun);
     const bundle_manif = bun.manifest;
+    const namespaces = new Set();
     const components = [];
     for (const comp of bun.components.values()) {
+        const ns = getNormalizedKeys(comp.$id)[0];
+        if (ns)
+            namespaces.add(ns);
         components.push(makeComponentPublication(comp));
     }
     bundle_manif.data = {
         baseline: bun.id + "-v0",
         components: components,
+        namespaces: Array.from(namespaces),
         exports: {},
     };
     for (const id in entries) {

package/esm/{model → workspace}/helpers/discover-workspace.js

@@ -8,6 +8,8 @@ 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";
 import { read_lockfile } from "./lockfile.js";
+import { LoadLibraryPackager } from "../packager.js";
+import { BundledLibraryPackager, DefaultLibraryPackager } from "../packagers/packager-standard.js";
 const exclude_dirs = ["node_modules", ".git"];
 function is_ignored_dir(ws, path) {
     const normalized_path = make_normalized_path(path);
@@ -18,9 +20,9 @@ function is_ignored_dir(ws, path) {
     }
     return false;
 }
-function setup_library_bundle(lib, bundle_desc) {
+export function setup_library_bundle(lib) {
     const ws = lib.workspace;
-    const manif = make_library_bundle_manifest(lib, bundle_desc);
+    const manif = make_library_bundle_manifest(lib);
     let bun = ws.get_bundle(manif.$id);
     if (!bun) {
         bun = new Bundle(manif, lib.path, ws, lib);
@@ -33,7 +35,7 @@ function setup_library_bundle(lib, bundle_desc) {
         throw new Error(`Library '${lib.get_id()}' is associate to a bundle '${bun.id}' that is already associated`);
     }
 }
-async function discover_component(lib, fpath) {
+export async function discover_component(lib, fpath) {
     let bundle = lib.bundle;
     if (!bundle) {
         bundle = setup_library_bundle(lib);
@@ -90,7 +92,7 @@ async function discover_application(lib, fpath) {
         lib.log.error(`invalid application at ${fpath}: ${e?.message}`);
     }
 }
-async function discover_library_components(lib, path, subdir = false) {
+export async function discover_library_components(lib, path, subdir = false) {
     // List names from directory
     const fnames = await Fsp.readdir(path);
     if (subdir && fnames.includes("package.json")) {
@@ -136,50 +138,25 @@ export function collect_declarations_field(lib, key, value) {
     }
     return value;
 }
-function make_library_bundle_manifest(lib, file_desc) {
-    let $id = file_desc?.$id;
-    if ($id) {
-        $id = makeNormalizedName($id, NameStyle.OBJECT);
-        if ($id !== file_desc.$id) {
-            lib.log.warn(`Bundle '${file_desc.$id}' is normalized into '${$id}'`);
+function make_library_bundle_manifest(lib) {
+    return {
+        $id: makeNormalizedName(collect_declarations_field(lib, "$id", lib.name), NameStyle.OBJECT),
+        type: "bundle",
+        name: lib.name,
+        icon: collect_declarations_field(lib, "icon", ""),
+        title: collect_declarations_field(lib, "title", lib.name),
+        tags: collect_declarations_field(lib, "tags", lib.descriptor?.tags),
+        keywords: collect_declarations_field(lib, "keywords", lib.descriptor?.keywords),
+        description: collect_declarations_field(lib, "description", lib.descriptor?.description),
+        selectors: collect_declarations_field(lib, "selectors", undefined),
+        data: {
+            package: lib.get_id(),
+            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", {}),
         }
-    }
-    else {
-        $id = makeNormalizedName(lib.name, NameStyle.OBJECT);
-        lib.log.info(`Bundle '${$id}' named from library '${lib.name}'`);
-    }
-    const data = {
-        package: lib.get_id(),
-        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.distribueds) {
-            Object.assign(data.distribueds, file_desc.data.distribueds);
-        }
-        if (Array.isArray(file_desc.data.namespaces)) {
-            data.namespaces.push(...file_desc.data.namespaces);
-        }
-        if (Array.isArray(file_desc.data.dependencies)) {
-            data.dependencies.push(...file_desc.data.dependencies);
-        }
-    }
-    const manifest = {
-        $id,
-        type: file_desc?.type,
-        name: file_desc?.name ?? lib.name,
-        icon: file_desc?.icon,
-        title: file_desc?.title,
-        tags: file_desc?.tags,
-        keywords: file_desc?.keywords,
-        description: file_desc?.description ?? lib.descriptor?.description,
-        selectors: file_desc?.selectors,
-        data,
     };
-    return manifest;
 }
 var Discovered;
 (function (Discovered) {
@@ -192,8 +169,9 @@ async function discover_library(ws, location, installed) {
     if (is_ignored_dir(ws, lib_path))
         return Discovered.Ignored;
     const package_path = lib_path + "/package.json";
-    const manifest_path = findConfigFile(lib_path, "bundle.manifest");
-    if (!file.exists(package_path) && !file.exists(manifest_path))
+    const has_package_manifest = file.exists(package_path);
+    const has_bundle_manifest = file.exists(findConfigFile(lib_path, "bundle.manifest"));
+    if (!has_package_manifest && !has_bundle_manifest)
         return Discovered.None;
     const lib_not_exists = ws.libraries.reduce((r, lib) => r && lib.path !== lib_path, true);
     if (!lib_not_exists)
@@ -201,8 +179,7 @@ async function discover_library(ws, location, installed) {
     const lib_desc = await readJsonFile(package_path);
     if (!lib_desc?.name)
         return Discovered.Ignored;
-    const manifest_desc = await readConfigFile(manifest_path);
-    if (manifest_desc || !installed) {
+    if (has_bundle_manifest || !installed) {
         const other = ws.get_library(lib_desc.name);
         if (other) {
             if (lib_path.includes(other.path)) {
@@ -216,22 +193,28 @@ async function discover_library(ws, location, installed) {
         const lib = new Library(lib_desc.name, lib_path, lib_desc, ws, 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
-        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);
-            }
-        }
         // Setup node search directory
         const lib_search_path = lib_path + "/node_modules";
         if (Fs.existsSync(lib_search_path)) {
             lib.search_directories.push(lib_search_path);
         }
-        // Collect library declaration
-        await discover_library_components(lib, lib_path);
+        // Load library packager
+        let packager = null;
+        if (has_bundle_manifest) {
+            packager = new BundledLibraryPackager();
+        }
+        else {
+            const declaration_config = await readSingletonConfigFile(lib_path, "declaration");
+            const packager_ref = declaration_config && declaration_config.data?.packager;
+            if (packager_ref) {
+                packager = await LoadLibraryPackager(packager_ref);
+            }
+            else {
+                packager = new DefaultLibraryPackager();
+            }
+        }
+        // Discover library with packager
+        await packager.discover_library(lib);
         return Discovered.Registered;
     }
     return Discovered.None;

package/esm/workspace/packager.js

@@ -0,0 +1,53 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import ChildProcess from "child_process";
+function parseSpecifier(specifier) {
+    let raw = specifier.startsWith("npm:") ? specifier.slice(4) : specifier;
+    let exportName;
+    const hashIndex = raw.indexOf("#");
+    if (hashIndex >= 0) {
+        exportName = raw.slice(hashIndex + 1);
+        raw = raw.slice(0, hashIndex);
+    }
+    let packageName;
+    if (raw.startsWith("@")) {
+        const parts = raw.split("/");
+        packageName = parts.slice(0, 2).join("/");
+    }
+    else {
+        packageName = raw.split("/")[0];
+    }
+    return { importPath: raw, packageName, exportName };
+}
+const validPackageName = /^(@[a-z0-9\-~][a-z0-9\-._~]*\/)?[a-z0-9\-~][a-z0-9\-._~]*$/;
+function resolveExport(mod, exportName) {
+    if (exportName) {
+        if (!(exportName in mod)) {
+            throw new Error(`Export '${exportName}' not found in module`);
+        }
+        return mod[exportName];
+    }
+    return mod.default ?? mod;
+}
+export async function LoadLibraryPackager(specifier) {
+    const { importPath, packageName, exportName } = parseSpecifier(specifier);
+    try {
+        const mod = await import(__rewriteRelativeImportExtension(importPath));
+        return resolveExport(mod, exportName);
+    }
+    catch {
+        if (!validPackageName.test(packageName)) {
+            throw new Error(`Invalid package name: ${packageName}`);
+        }
+        ChildProcess.execSync(`npm install ${packageName}`, { stdio: "inherit" });
+        const mod = await import(__rewriteRelativeImportExtension(importPath));
+        return resolveExport(mod, exportName);
+    }
+}
+//# sourceMappingURL=packager.js.map

package/esm/workspace/packagers/packager-standard.js

@@ -0,0 +1,39 @@
+import {} from "../component.js";
+import { Bundle, Library } from "../workspace.js";
+import { readSingletonConfigFile } from "../helpers/config-loader.js";
+import {} from "../packager.js";
+import { discover_component, discover_library_components, setup_library_bundle } from "../helpers/discover-workspace.js";
+export class DefaultLibraryPackager {
+    async discover_library(lib) {
+        // Setup library infos from bundle manifest
+        setup_library_bundle(lib);
+        // Collect library declaration
+        await discover_library_components(lib, lib.path);
+        return lib.bundle;
+    }
+}
+export class BundledLibraryPackager {
+    async discover_library(lib) {
+        const { data: manif } = await readSingletonConfigFile(lib.path, "bundle.manifest");
+        const ws = lib.workspace;
+        let bun = ws.get_bundle(manif.$id);
+        if (!bun) {
+            bun = new Bundle(manif, lib.path, lib.workspace, lib);
+            lib.bundle = bun;
+            ws.bundles.push(bun);
+            lib.log.info(`+ 📦 bundle: ${bun.id}`);
+        }
+        else if (bun.source != lib) {
+            lib.log.warn(`Conflict between two prebuild library bundle`);
+        }
+        // Analyze library deployment manifest (supports json/yaml/yml/toml, singleton)
+        if (manif?.data?.components) {
+            for (const pub of manif.data.components) {
+                const fpath = lib.path + "/" + (pub.ref ?? pub.id);
+                await discover_component(lib, fpath);
+            }
+        }
+        return bun;
+    }
+}
+//# sourceMappingURL=packager-standard.js.map

package/package.json

@@ -1,10 +1,14 @@
 {
    "name": "@jointhedots/gear",
-   "version": "1.1.17",
+   "version": "1.1.18",
    "type": "module",
+   "packageManager": "pnpm@10.30.3",
    "bin": {
       "jointhedots-gear": "esm/cli.js"
    },
+   "exports": {
+      "./workspace": "./esm/workspace.js"
+   },
    "files": [
       "esm",
       "browser-modules",
@@ -23,7 +27,7 @@
       ":build:lib:ui": "node --enable-source-maps --watch-path=esm esm/cli make --libs @jointhedots/ui --devmode --ws ../jointhedots-core/packages/jointhedots-ui",
       ":build:app": "node --enable-source-maps --watch-path=esm esm/cli make --apps playground:ui --ws ../jointhedots-core",
       "serve:mono": "node --enable-source-maps --watch-path=esm esm/cli serve --app playground:ui --devmode --port 3002 --ws ../jointhedots-core",
-      "serve:host": "node --enable-source-maps --watch-path=esm esm/cli serve --app playground:ui:host  --port 3002 --ws ../jointhedots-core",
+      "serve:host": "node --enable-source-maps --watch-path=esm esm/cli serve --app playground:ui:host --devmode --port 3002 --ws ../jointhedots-core",
       "serve:sfe": "node --enable-source-maps --watch-path=esm esm/cli serve --app sfe-demo --devmode --ws ../sf-explorer-app",
       "serve:demo": "node --enable-source-maps --watch-path=esm esm/cli serve --app sfe-demo --devmode --ws ../sf-explorer-demo",
       "make:sfe": "node --enable-source-maps --watch-path=esm esm/cli make --libs @sf-explorer/app --devmode --ws ../sf-explorer-app",
@@ -60,4 +64,4 @@
    "bundleDependencies": [
       "@jspm/core"
    ]
-}
+}