@jointhedots/gear 1.2.0 → 1.2.3

package/esm/commands/init.js

@@ -54,4 +54,3 @@ export function command_init() {
         }
     };
 }
-//# sourceMappingURL=init.js.map

package/esm/commands/install.d.ts

@@ -0,0 +1,5 @@
+import { type CommandModule } from "yargs";
+export declare function command_install(): CommandModule<any, {
+    ws?: string;
+    dist?: string;
+}>;

package/esm/commands/install.js

@@ -1,5 +1,5 @@
-import Path from 'node:path';
-import Fs from 'node:fs';
+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";
@@ -29,7 +29,7 @@ export function command_install() {
             // Select all workspace bundles
             const selector = new BundleSelector(ws);
             for (const lib of ws.libraries) {
-                selector.add(lib.bundle);
+                selector.add(lib.master);
             }
             if (selector.missing.length > 0) {
                 ws.log.warn(`Missing bundle dependencies: ${selector.missing.join(", ")}`);
@@ -64,4 +64,3 @@ export function command_install() {
         }
     };
 }
-//# sourceMappingURL=install.js.map

package/esm/commands/make.d.ts

@@ -0,0 +1,17 @@
+import { type CommandModule } from "yargs";
+type MakeOptions = {
+    watch?: boolean;
+    pack?: boolean;
+    versioned?: string;
+    devmode?: boolean;
+    clean?: boolean;
+    dist?: string;
+    artifactDir?: string;
+};
+export declare function command_make(): CommandModule<any, MakeOptions & {
+    apps?: string;
+    libs?: string;
+    bundles?: string;
+    ws?: string;
+}>;
+export {};

package/esm/commands/make.js

@@ -1,11 +1,11 @@
-import Path from 'node:path';
+import Path from "node:path";
 import {} from "yargs";
 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 { makeNormalizedName, NameStyle } from "../utils/normalized-name.js";
 import { resolvePackageVersion } from "../workspace/helpers/package-npm.js";
 export function command_make() {
     return {
@@ -59,6 +59,10 @@ export function command_make() {
             .option("dist", {
             type: "string",
             default: "./dist",
+        })
+            .option("artifact-dir", {
+            type: "string",
+            describe: "Directory to write output artifacts (npm if package.json, zip otherwise)",
         }),
         handler: async (argv) => {
             const ws = await open_workspace({
@@ -89,8 +93,8 @@ export function command_make() {
             const bundles = [];
             if (argv.bundles === "*") {
                 for (const lib of ws.libraries) {
-                    if (lib.bundle)
-                        bundles.push(lib.bundle);
+                    if (lib.master)
+                        bundles.push(lib.master);
                 }
             }
             else if (argv.bundles) {
@@ -112,6 +116,7 @@ export function command_make() {
                         ws.log.error(`application not found: ${appname}`);
                 }
             }
+            const artifactDir = argv.artifactDir ? Path.resolve(argv.artifactDir) : undefined;
             const pendings = [];
             if (bundles.length > 0) {
                 const shelve = new StorageFiles("shelve", Path.resolve(argv.dist, "shelve"));
@@ -123,6 +128,7 @@ export function command_make() {
                         devmode: argv.devmode,
                         watch: argv.watch,
                         clean: argv.clean || !argv.devmode,
+                        artifactDir,
                     }));
                 }
             }
@@ -137,6 +143,7 @@ export function command_make() {
                     devmode: argv.devmode,
                     watch: argv.watch,
                     clean: argv.clean || !argv.devmode,
+                    artifactDir,
                 }));
             }
             for (const lib of libraries) {
@@ -149,10 +156,10 @@ export function command_make() {
                     devmode: argv.devmode,
                     watch: argv.watch,
                     clean: argv.clean || !argv.devmode,
+                    artifactDir,
                 }, argv.pack ? Path.resolve(argv.dist) : null));
             }
             await Promise.all(pendings);
         }
     };
 }
-//# sourceMappingURL=make.js.map

package/esm/commands/run.d.ts

@@ -0,0 +1,8 @@
+import { type CommandModule } from "yargs";
+export declare function command_run(): CommandModule<any, {
+    dir?: string;
+    entry?: string;
+    inspect?: number;
+    break?: boolean;
+    "--"?: string[];
+}>;

package/esm/commands/run.js

@@ -1,8 +1,8 @@
-import NodeWatch from "node-watch";
-import Process from 'process';
-import Path from 'path';
-import ChildProcess from 'child_process';
-import { createRequire } from "module";
+import Fs from "node:fs";
+import Process from "node:process";
+import Path from "node:path";
+import ChildProcess from "node:child_process";
+import { createRequire } from "node:module";
 import {} from "yargs";
 const restart_always_on_change = true;
 const require = createRequire(import.meta.url);
@@ -101,10 +101,9 @@ export function command_run() {
             Process.stdin.setRawMode(true);
             Process.stdin.resume();
             Process.stdin.on('data', onKeyPress);
-            const watcher = NodeWatch(argv.dir, { recursive: true });
+            const watcher = Fs.watch(argv.dir, { recursive: true });
             watcher.on('change', () => restart());
             start();
         }
     };
 }
-//# sourceMappingURL=run.js.map

package/esm/commands/serve.d.ts

@@ -0,0 +1,9 @@
+import { type CommandModule } from "yargs";
+export declare function command_serve(): CommandModule<any, {
+    app?: string;
+    port?: number;
+    versioned?: string;
+    devmode?: boolean;
+    ws?: string;
+    dist?: string;
+}>;

package/esm/commands/serve.js

@@ -1,10 +1,10 @@
-import Path from 'node:path';
+import Path from "node:path";
 import {} from "yargs";
 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 { makeNormalizedName, NameStyle } from "../utils/normalized-name.js";
+import Express from "express";
 import { resolvePackageVersion } from "../workspace/helpers/package-npm.js";
 export function command_serve() {
     return {
@@ -54,22 +54,21 @@ export function command_serve() {
             }
             const outputDir = Path.resolve(argv.dist, makeNormalizedName(argv.app, NameStyle.WEBC));
             const storage = new StorageFiles(ws.name, outputDir);
+            let serverStarted = false;
             const building = build_application({
                 app,
                 storage,
                 version,
                 devmode: argv.devmode,
                 devserver: argv.port && `http://localhost:${argv.port}`,
+                onNotification(event) {
+                    if (event.type === "build-complete" && !serverStarted && argv.port) {
+                        serverStarted = true;
+                        serve(ws, argv.port, storage);
+                    }
+                },
             });
-            if (argv.port) {
-                await Promise.all([
-                    building,
-                    serve(ws, argv.port, storage)
-                ]);
-            }
-            else {
-                await building;
-            }
+            await building;
         }
     };
 }
@@ -90,4 +89,3 @@ async function serve(ws, port, storage) {
         process.on('SIGQUIT', () => resolve(null));
     });
 }
-//# sourceMappingURL=serve.js.map

package/esm/core/commands/interface.d.ts

@@ -0,0 +1,26 @@
+export type Serializable = string | number | boolean | null | Serializable[] | {
+    [key: string]: Serializable;
+};
+export type Cmdlet<CmdPayload extends Serializable = Serializable, CmdResult extends Serializable = Serializable> = {
+    payload: CmdPayload;
+    result: CmdResult;
+};
+export type CmdPayload<C extends Cmdlet> = C extends {
+    payload: infer P;
+} ? P : void;
+export type CmdResult<C extends Cmdlet> = C extends {
+    result: infer P;
+} ? P : void;
+export interface Command<C extends Cmdlet = Cmdlet> {
+    target: string;
+    payload?: CmdPayload<C>;
+    icon?: string;
+    title?: string;
+    summary?: string;
+    identity?: string;
+    signature?: string;
+}
+export interface CommandsService {
+    execute<C extends Cmdlet>(cmd: string, data: CmdPayload<C>): Promise<CmdResult<C>>;
+}
+export declare function executeCommand(cmd: Command): Promise<void>;

package/esm/core/commands/interface.js

@@ -0,0 +1,21 @@
+import { URI } from "vscode-uri";
+import { acquireComponent } from "../components/manifold.js";
+import { Log } from "../logging/mod.js";
+export async function executeCommand(cmd) {
+    console.log("executeCommand:", cmd.target);
+    const uri = URI.parse(cmd.target);
+    const comp = acquireComponent(uri.authority);
+    if (uri.scheme === "command") {
+        try {
+            const svc = await comp.fetchResource("commands");
+            if (svc?.execute instanceof Function) {
+                svc.execute(uri.path, cmd.payload);
+            }
+            else
+                throw new Error(`Invalid commands service`);
+        }
+        catch (e) {
+            Log.error(e);
+        }
+    }
+}

package/esm/core/components/components.d.ts

@@ -0,0 +1,73 @@
+import type { DocumentationSchema, JSONSchema, ResourceEntry } from "../schema/schema.ts";
+import type { ComponentEntry } from "./manifold.ts";
+import { ServiceAccessor, type ServiceType } from "../services/service-accessor.ts";
+export type ComponentID = string;
+export interface ComponentPublication {
+    id: ComponentID;
+    ref?: string;
+    type?: string;
+    title: string;
+    icon?: string;
+    description?: string;
+    services?: string[];
+    keywords?: string[];
+    tags?: string[];
+}
+export type ComponentServiceID = string;
+export type ComponentManifest<Data extends any = unknown> = {
+    $id: string;
+    type?: string;
+    title?: string;
+    icon?: string;
+    description?: string;
+    keywords?: string[];
+    tags?: string[];
+    doc?: DocumentationSchema;
+    specs?: Record<ComponentServiceID, any>;
+    apis?: Record<ComponentServiceID, ResourceEntry>;
+    data?: Data;
+};
+/** Configuration for a distributed package */
+export interface DistributedConfig {
+    /** Version specifier (e.g., "*", "^18.0.0") */
+    version?: string;
+    /** Interop type: 'esm' | 'cjs-default' | 'cjs-named' */
+    interop?: 'esm' | 'cjs-default' | 'cjs-named';
+    /** List of named exports to re-export (required for cjs-named interop) */
+    exports?: string[];
+}
+export type BundleManifest = ComponentManifest<{
+    alias?: string;
+    package?: string;
+    baseline?: string;
+    namespaces?: string[];
+    dependencies?: string[];
+    distribueds?: {
+        [packageName: string]: string | DistributedConfig;
+    };
+    exports?: {
+        [id: string]: string;
+    };
+    components?: ComponentPublication[];
+}>;
+export type ComponentSchema = {
+    readonly name: ServiceType;
+    readonly title: string;
+    readonly icon: string;
+    readonly attributes: Record<string, JSONSchema>;
+};
+export interface ComponentManifestIssue {
+    level: "error" | "warn" | "info";
+    message: string;
+    fix?(descriptor: ComponentManifest): Promise<ComponentManifest>;
+}
+export interface ComponentChecking {
+    fixed?: ComponentManifest;
+    issues?: ComponentManifestIssue[];
+}
+export interface ComponentController {
+    createComponent(component: ComponentEntry, descriptor: ComponentManifest): Promise<void>;
+    updateComponent(component: ComponentEntry, descriptor: ComponentManifest): Promise<void>;
+    checkDescriptor(descriptor: ComponentManifest): Promise<ComponentChecking>;
+}
+export declare const ComponentControllerKey: ServiceAccessor<ComponentController, ComponentSchema>;

package/esm/core/components/components.js

@@ -0,0 +1,2 @@
+import { ServiceAccessor } from "../services/service-accessor.js";
+export const ComponentControllerKey = ServiceAccessor.About("component");

package/esm/core/components/helpers.d.ts

@@ -0,0 +1,7 @@
+import { URI } from "vscode-uri";
+import { type ComponentManifest, type ComponentPublication } from "./components.ts";
+import type { ResourceEntry, ResourceImport } from "../schema/schema.ts";
+export declare function parseComponentURI(ref: string): URI;
+export declare function getComponentServicesList(manif: ComponentManifest): Promise<string[]>;
+export declare function createComponentPublication(manif: ComponentManifest): Promise<ComponentPublication>;
+export declare function parseResourceEntry(entry: ResourceEntry): ResourceImport;

package/esm/core/components/helpers.js

@@ -0,0 +1,68 @@
+import { URI } from "vscode-uri";
+import {} from "./components.js";
+import { acquireComponent } from "./manifold.js";
+export function parseComponentURI(ref) {
+    if (ref.startsWith("./")) {
+        const base = URI.parse(window.location.href);
+        const parts = base.path.split("/");
+        parts[parts.length - 1] = ref.slice(2);
+        return base.with({ path: parts.join("/"), query: "", fragment: "" });
+    }
+    else if (ref.startsWith("/")) {
+        return URI.parse(window.location.href).with({ path: ref, query: "", fragment: "" });
+    }
+    else {
+        return URI.parse(ref);
+    }
+}
+export async function getComponentServicesList(manif) {
+    const services = manif.apis ? Object.keys(manif.apis) : [];
+    if (manif.type) {
+        const controller = await acquireComponent(manif.type)?.fetch();
+        if (controller) {
+            for (const key in controller?.apis) {
+                if (key.startsWith("component.")) {
+                    const name = key.slice(10);
+                    if (!services.includes(name))
+                        services.push(name);
+                }
+            }
+        }
+        else {
+            throw new Error("Cannot create publiction properly");
+        }
+    }
+    return services;
+}
+export async function createComponentPublication(manif) {
+    const { $id } = manif;
+    return {
+        id: $id,
+        type: manif.type,
+        icon: manif.icon,
+        title: manif.title || $id,
+        description: manif.description || "",
+        keywords: manif.keywords,
+        tags: manif.tags,
+        services: await getComponentServicesList(manif),
+    };
+}
+export function parseResourceEntry(entry) {
+    if (typeof entry === "string") {
+        let [location, fragment] = entry.split("#", 2);
+        // Make resource data
+        const result = { type: "module", location };
+        if (fragment) {
+            const [identifier, query] = fragment.split("?", 2);
+            result.identifier = identifier;
+            if (query) {
+                for (const kv of query.split("&")) {
+                    const [k, v] = kv.split("=");
+                    result[k] = v === undefined ? true : v;
+                }
+            }
+        }
+        return result;
+    }
+    return entry;
+}

package/esm/core/components/manifold.d.ts

@@ -0,0 +1,77 @@
+import { type ComponentManifest, type ComponentPublication } from "./components.ts";
+import { type QueryLogResult } from "../logging/mod.ts";
+import { type ComponentFilter, type IComponentProvider, type IContentProvider, type IResourceLoader } from "./provider.ts";
+export type ComponentErrorManifest = ComponentManifest & {
+    type: "<error>";
+    message: string;
+    stack?: string;
+};
+export type ComponentServiceGetter<Service = any> = (entry: ComponentEntry) => Service;
+export declare class ComponentEntry<Instance extends Object = any> {
+    readonly id: string;
+    protected __instance__?: Instance;
+    manifest?: ComponentManifest;
+    constructor(id: string);
+    get title(): string;
+    get namespace(): string;
+    get valid(): boolean;
+    get loaded(): boolean;
+    get installed(): boolean;
+    get instance(): Instance;
+    set instance(value: Instance);
+    get<Manifest extends ComponentManifest = ComponentManifest>(): Manifest;
+    set<Manifest extends ComponentManifest = ComponentManifest>(manifest: Manifest): this;
+    fetch<Manifest extends ComponentManifest = ComponentManifest>(): Promise<Manifest>;
+    install(): Promise<ComponentEntry>;
+    acquireResource(identifier: string): ComponentResource;
+    getResource(identifier: string): ComponentResource;
+    hasResource(identifier: string): boolean;
+    getResourceAsync(identifier: string): Promise<ComponentResource>;
+    fetchResource<T = any>(identifier: string): Promise<T>;
+    getLogStats(): import("../logging/mod.ts").LogInfos;
+    getLogs(count: number): QueryLogResult;
+}
+export declare class ComponentResource {
+    readonly component: ComponentEntry;
+    readonly resource: string;
+    entry: any;
+    identifier: string;
+    constructor(component: ComponentEntry, resource: string);
+    get valid(): boolean;
+    get loaded(): boolean;
+    fetch<T = any>(): Promise<T>;
+    get<T = any>(): T;
+    set(data: any): void;
+    get spec(): any;
+    get url(): string;
+}
+export type ComponentsListener = (target: ComponentEntry) => void;
+export declare class ComponentsManifold {
+    components: Map<string, ComponentEntry<any>>;
+    resources: Map<string, ComponentResource>;
+    datamap: WeakMap<any, ComponentEntry<any> | ComponentResource>;
+    loadings: Map<any, Promise<any>>;
+    installings: Map<any, Promise<ComponentEntry<any>>>;
+    listeners: Set<ComponentsListener>;
+    components_provider: IComponentProvider;
+    resources_loader: IResourceLoader;
+    content_provider: IContentProvider;
+    constructor();
+    listen(l: ComponentsListener): ComponentsListener;
+    unlisten(l: ComponentsListener): void;
+    notifyError(subject: ComponentEntry, error: Error): void;
+}
+export declare const ComponentsRegistry: ComponentsManifold;
+export declare function getDefaultComponent(): ComponentEntry<any>;
+export declare function getComponentFromData(data: any, is_static?: boolean): ComponentEntry;
+export declare function acquireComponent(id: string): ComponentEntry;
+export declare function acquireFutureComponent(manifest: ComponentManifest): ComponentEntry;
+export declare function acquireResource(ref: string): ComponentResource;
+export declare function resolveRelativeComponent(ref: string, from: ComponentEntry): ComponentEntry;
+export declare function saveComponentManifest(manifest: ComponentManifest): Promise<ComponentEntry<any>>;
+export declare function saveComponent(component: ComponentEntry): Promise<ComponentEntry<any>>;
+export declare function deleteComponent(id: string): Promise<void>;
+export declare function unregisterComponent(id: string): void;
+export declare function searchComponentsPublications(filter: ComponentFilter): Promise<ComponentPublication[]>;
+export declare function fetchComponentsPublications(components_ids: string[]): Promise<ComponentPublication[]>;
+export declare function failedComponentPublication(id: string, title?: string): ComponentPublication;