@jointhedots/gear 1.2.0 → 1.2.3

package/esm/core/services/settings.js

@@ -0,0 +1,123 @@
+export var WriteMode;
+(function (WriteMode) {
+    WriteMode[WriteMode["Default"] = 0] = "Default";
+    WriteMode[WriteMode["Reset"] = 1] = "Reset";
+    WriteMode[WriteMode["Temporary"] = 2] = "Temporary";
+})(WriteMode || (WriteMode = {}));
+export class AccountSettings {
+    name;
+    key = null;
+    stores = createSettingStores();
+    temporaries = createSettingStores();
+    settings = createSettingStores();
+    constructor(name) {
+        this.name = name;
+        this.key = `settings://${this.name}`;
+        try {
+            const bytes = localStorage.getItem(this.key);
+            this.restore(JSON.parse(bytes).stores);
+        }
+        catch (_) { }
+        try {
+            window.addEventListener("storage", (evt) => {
+                const { key, newValue } = evt;
+                if (key === this.key) {
+                    try {
+                        this.restore(JSON.parse(newValue).stores);
+                    }
+                    catch (_) { }
+                }
+            });
+        }
+        catch (e) {
+            console.error(e.message);
+        }
+    }
+    get(group, key) {
+        let data = this.settings[group][key];
+        if (!data) {
+            const bytes = this.temporaries[group][key] || this.stores[group][key];
+            if (bytes) {
+                data = JSON.parse(bytes);
+                this.settings[group][key] = data;
+            }
+        }
+        return data;
+    }
+    set(group, key, descriptor, mode = WriteMode.Default) {
+        const data = JSON.stringify(descriptor);
+        if (this.write(group, key, data, mode)) {
+            this.settings[group][key] = descriptor;
+            notifySettingsChange(this, group, key);
+            return true;
+        }
+        return false;
+    }
+    list(group) {
+        if (Object.keys(this.temporaries[group]).length > 0) {
+            return Object.keys(Object.assign({}, this.stores[group], this.temporaries[group]));
+        }
+        else {
+            return Object.keys(this.stores[group]);
+        }
+    }
+    read(key) {
+        return this.stores[key];
+    }
+    write(group, key, data, mode) {
+        if (mode !== WriteMode.Reset && this.temporaries[group][key] !== undefined) {
+            mode = WriteMode.Temporary;
+        }
+        if (mode === WriteMode.Temporary) {
+            if (this.temporaries[group][key] !== data) {
+                this.temporaries[group][key] = data;
+                this.settings[group][key] = null;
+                return true;
+            }
+        }
+        else if (this.stores[group][key] !== data) {
+            this.stores[group][key] = data;
+            this.settings[group][key] = null;
+            if (mode === WriteMode.Default) {
+                localStorage.setItem(this.key, JSON.stringify({ stores: this.stores }));
+            }
+            return true;
+        }
+        return false;
+    }
+    restore(stores) {
+        for (const group in stores) {
+            for (const key in stores[group]) {
+                if (this.write(group, key, stores[group][key], WriteMode.Reset)) {
+                    notifySettingsChange(this, group, key);
+                }
+            }
+        }
+    }
+}
+const Settings_ChangeHandlers = new Set();
+const Settings = new AccountSettings("default");
+export function getSettings() {
+    return Settings;
+}
+export function listenSettings(handler) {
+    Settings_ChangeHandlers.add(handler);
+    return handler;
+}
+export function unlistenSettings(handler) {
+    Settings_ChangeHandlers.delete(handler);
+}
+function notifySettingsChange(settings, group, key) {
+    if (settings === Settings && settings.settings[group][key] !== undefined) {
+        for (const handler of Settings_ChangeHandlers) {
+            handler(group, key);
+        }
+    }
+}
+function createSettingStores() {
+    return {
+        service_points: {},
+        components: {},
+        shareds: {},
+    };
+}

package/esm/utils/file.d.ts

@@ -0,0 +1,39 @@
+import Fs from "node:fs";
+export declare const PackageRootDir: string;
+export declare const file: {
+    exists(path: string): boolean;
+    copy: {
+        toFile(src: string, dest: string): string;
+        toDir(src: string, dest: string): string;
+    };
+    move: {
+        toFile(src: string, dest: string): string;
+        toDir(src: string, dest: string): string;
+    };
+    read: {
+        json(path: string): any;
+        text(path: string): string;
+    };
+    write: {
+        json(path: string, data: any): void;
+        text(path: string, data: string): void;
+    };
+    find: {
+        upperDir(base: string, subpath: string): string;
+    };
+    remove(path: string): void;
+};
+export declare const directory: {
+    exists(path: string): boolean;
+    filenames(path: string, recursive?: Boolean): string[];
+    copy(src: string, dest: string, filter?: (name: string, path: string, stats: Fs.Stats) => boolean): void;
+    make(path: string): void;
+    remove(path: string, onlyInner?: boolean): void;
+    clean(path: string): void;
+};
+export declare function make_relative_path(baseDir: string, ...path: string[]): string;
+export declare function make_normalized_path(baseDir: string, ...path: string[]): string;
+export declare function make_normalized_dirname(baseDir: string, ...path: string[]): string;
+export declare function make_canonical_path(baseDir: string, ...path: string[]): string;
+/** Resolve a file path with extension probing */
+export declare function resolve_normalized_suffixed_path(baseDir: string, path: string, exts?: string[]): string | null;

package/esm/utils/file.js

@@ -1,6 +1,6 @@
-import Path from "path";
-import Fs from "fs";
-import { fileURLToPath } from "url";
+import Path from "node:path";
+import Fs from "node:fs";
+import { fileURLToPath } from "node:url";
 export const PackageRootDir = Path.resolve(fileURLToPath(import.meta.url), "../../..");
 export const file = {
     exists(path) {
@@ -212,4 +212,3 @@ export function resolve_normalized_suffixed_path(baseDir, path, exts = FILE_EXTE
     }
     return null;
 }
-//# sourceMappingURL=file.js.map

package/esm/utils/graph-ordering.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Topological sort using Tarjan's algorithm.
+ * Returns nodes in dependency order (dependencies come first).
+ * Throws if a cycle is detected.
+ *
+ * @param nodes - Array of node identifiers
+ * @param edges - Function that returns outgoing edges (dependencies) for a node
+ * @returns Nodes in topological order
+ */
+export declare function topologicalSort<T>(nodes: Iterable<T>, edges: (node: T) => Iterable<T>): T[];
+/**
+ * Get topological order with cycle detection that returns cycle info instead of throwing.
+ *
+ * @param nodes - Array of node identifiers
+ * @param edges - Function that returns outgoing edges for a node
+ * @returns Object with ordered nodes and any detected cycles
+ */
+export declare function getGraphOrder<T>(nodes: Iterable<T>, edges: (node: T) => Iterable<T>): {
+    order: T[];
+    cycles: T[][];
+};

package/esm/utils/graph-ordering.js

@@ -83,4 +83,3 @@ export function getGraphOrder(nodes, edges) {
     }
     return { order, cycles };
 }
-//# sourceMappingURL=graph-ordering.js.map

package/esm/utils/normalized-name.d.ts

@@ -0,0 +1,17 @@
+export declare enum NameStyle {
+    OBJECT = "object",
+    WEBC = "webc",
+    URN = "urn",
+    URL = "url",
+    DNS = "dns"
+}
+export type NameStyleConfig = {
+    namespace: string;
+    key: string;
+};
+export declare const NormalizedNameSeparators: Record<NameStyle, NameStyleConfig>;
+export declare function detectNormalizedNameStyle(name: string): NameStyle;
+export declare function isNormalizedName(name: string, expectedStyle?: NameStyle): boolean;
+export declare function getNormalizedKeys(name: string, fromStyle?: NameStyle): string[];
+export declare function makeNormalizedName(name: string, targetStyle: NameStyle, fromStyle?: NameStyle): string;
+export declare function computeNameHashID(identity: string): string;

package/esm/utils/normalized-name.js

@@ -93,4 +93,3 @@ export function computeNameHashID(identity) {
     hasher.write(identity);
     return hasher.digest().toString("base64url");
 }
-//# sourceMappingURL=normalized-name.js.map

package/esm/workspace/component.d.ts

@@ -0,0 +1,70 @@
+export type JSONSchema = any;
+export type ResourceEntry<ResourceInterface = any> = ResourceLink<ResourceInterface> | {
+    type: ResourceLink<ResourceFactory<ResourceInterface>>;
+    data?: any;
+};
+export type ResourceFactory<ResourceInterface = any> = (data: any) => Promise<ResourceInterface>;
+export type ResourceLink<ResourceInterface = any> = string;
+export type ComponentID = string;
+export type BundleID = ComponentID;
+export type ComponentSpec = {
+    "view"?: {
+        properties: Record<string, JSONSchema>;
+    };
+    "component"?: {
+        services: string[];
+        attributes: Record<string, JSONSchema>;
+    };
+    [customSpec: string]: any;
+};
+export type ComponentManifest<Data extends any = unknown> = {
+    $id: string;
+    type?: string;
+    name?: string;
+    icon?: string;
+    title?: string;
+    tags?: string[];
+    keywords?: string[];
+    description?: string;
+    selectors?: string[];
+    specs?: Record<string, ComponentSpec>;
+    data?: Data;
+    resources?: Record<string, ResourceEntry>;
+    apis?: Record<string, ResourceEntry>;
+};
+/** 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 interface ComponentPublication {
+    id: ComponentID;
+    ref?: string;
+    type?: string;
+    title: string;
+    icon?: string;
+    description?: string;
+    services?: string[];
+    keywords?: string[];
+    tags?: string[];
+}
+export declare function checkComponentManifest(manif: ComponentManifest, path: string): Error;
+export declare function makeComponentPublication(manif: ComponentManifest): ComponentPublication;

package/esm/workspace/component.js

@@ -20,4 +20,3 @@ export function makeComponentPublication(manif) {
         tags: manif.tags,
     };
 }
-//# sourceMappingURL=component.js.map

package/esm/workspace/helpers/config-loader.d.ts

@@ -0,0 +1,37 @@
+/** Supported config file extensions in precedence order */
+export declare const config_extensions: readonly [".json", ".yaml", ".yml", ".toml"];
+export type ConfigExtension = typeof config_extensions[number];
+/**
+ * Check whether a filename matches a config base name (e.g. "component", "application")
+ * in any supported format (json, yaml, yml, toml).
+ * Matches exact names like `component.json` and dotted prefixes like `foo.component.yaml`.
+ */
+export declare function is_config_filename(fname: string, config_base: string): boolean;
+/**
+ * Parse a config string based on its file extension.
+ */
+export declare function parseConfigContent(text: string, ext: ConfigExtension): any;
+/**
+ * Read and parse a config file. The format is determined by its extension.
+ * Returns `undefined` if the file doesn't exist or can't be parsed.
+ */
+export declare function readConfigFile<T = any>(path: string): Promise<T | undefined>;
+/**
+ * Read and parse a config file synchronously.
+ * Returns `undefined` if the file doesn't exist or can't be parsed.
+ */
+export declare function readConfigFileSync<T = any>(path: string): T | undefined;
+/**
+ * Find config files matching a base name (e.g. "bundle.component") in a directory.
+ * Returns all matching paths across supported extensions.
+ */
+export declare function findConfigFile(dir: string, baseName: string, fnames?: string[]): string;
+/**
+ * Read a singleton config file (exactly one format must exist).
+ * Throws if multiple formats are found for the same base name.
+ * Returns `undefined` if no matching file exists.
+ */
+export declare function readSingletonConfigFile<T = any>(dir: string, baseName: string, fnames?: string[]): Promise<{
+    data: T;
+    path: string;
+} | undefined>;

package/esm/workspace/helpers/config-loader.js

@@ -1,8 +1,8 @@
-import YAML from 'yaml';
-import TOML from 'toml';
-import Path from 'node:path';
+import YAML from "yaml";
+import TOML from "toml";
+import Path from "node:path";
 import Fsp from "node:fs/promises";
-import Fs from 'node:fs';
+import Fs from "node:fs";
 /** Supported config file extensions in precedence order */
 export const config_extensions = [".json", ".yaml", ".yml", ".toml"];
 /**
@@ -97,4 +97,3 @@ export async function readSingletonConfigFile(dir, baseName, fnames) {
     const data = await readConfigFile(path);
     return data !== undefined ? { data, path } : undefined;
 }
-//# sourceMappingURL=config-loader.js.map

package/esm/workspace/helpers/create-manifests.d.ts

@@ -0,0 +1,13 @@
+import { type BundleManifest } from "../component.ts";
+import type { Bundle, Library, PackageDescriptor } from "../workspace.ts";
+export type ExportEntry = {
+    id: string;
+    exported?: string;
+    basename: string;
+    filename: string;
+    source: string;
+};
+export type ExportEntries = Record<string, ExportEntry>;
+export declare function create_export_map(lib: Library, bun: Bundle): ExportEntries;
+export declare function create_bundle_manifest(lib: Library, bun: Bundle): BundleManifest;
+export declare function create_package_manifest(lib: Library, bun: Bundle, build_version?: string): PackageDescriptor;

package/esm/workspace/helpers/create-manifests.js

@@ -20,8 +20,8 @@ export function create_export_map(lib, bun) {
     const exports = {};
     if (bun) {
         for (const id in bun.distribueds) {
-            const basename = lib.make_file_id("redist", id);
-            const entry = lib.resolve_entry_path(id, lib.path);
+            const basename = bun.make_file_id("redist", id);
+            const entry = bun.resolve_entry_path(id, lib.path);
             exports[id] = {
                 id,
                 basename: basename,
@@ -84,7 +84,7 @@ export function create_package_manifest(lib, bun, build_version) {
         optionalDependencies: undefined,
     };
     if (pkg_manif.dependencies) {
-        const resolved = lib.resolved_versions;
+        const resolved = lib.deps.resolved_versions;
         for (const dep in pkg_manif.dependencies) {
             if (pkg_manif.dependencies[dep] === "*") {
                 const dep_resolved = resolved[dep];
@@ -111,4 +111,3 @@ export function create_package_manifest(lib, bun, build_version) {
     }
     return pkg_manif;
 }
-//# sourceMappingURL=create-manifests.js.map

package/esm/workspace/helpers/discover-workspace.d.ts

@@ -0,0 +1,4 @@
+import { Bundle, Library, Workspace } from "../workspace.ts";
+export declare function discover_component(bundle: Bundle, fpath: string): Promise<boolean>;
+export declare function discover_library_definitions(lib: Library, path: string, subdir?: boolean): Promise<void>;
+export declare function discover_workspace(ws: Workspace): Promise<Workspace>;

package/esm/workspace/helpers/discover-workspace.js

@@ -2,8 +2,6 @@ import Fs from "node:fs";
 import Fsp from "node:fs/promises";
 import { readJsonFile } from "../storage.js";
 import { checkComponentManifest } from "../component.js";
-import { makeNormalizedName, NameStyle } from "../../utils/normalized-name.js";
-import { create_bundle_manifest } from "./create-manifests.js";
 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";
@@ -20,8 +18,7 @@ function is_ignored_dir(ws, path) {
     }
     return false;
 }
-export async function discover_component(lib, fpath) {
-    const { bundle } = lib;
+export async function discover_component(bundle, fpath) {
     if (bundle.components.has(fpath)) {
         return true;
     }
@@ -35,18 +32,18 @@ export async function discover_component(lib, fpath) {
                 throw err;
             if (!desc.apis && desc["services"]) {
                 desc.apis = desc["services"]; // Migrate renaming 'services' -> 'apis'
-                lib.log.warn(`Component '${desc.$id}' manifest shall rename 'services' -> 'apis'`);
+                bundle.log.warn(`Component '${desc.$id}' manifest shall rename 'services' -> 'apis'`);
             }
             bundle.components.set(fpath, desc);
-            lib.log.info(`+ 🧩 component: ${desc.$id} ${desc.type ? `(${desc.type})` : ""}`);
+            bundle.log.info(`+ 🧩 component: ${desc.$id} ${desc.type ? `(${desc.type})` : ""}`);
             return true;
         }
         else if (bundle.path !== make_normalized_dirname(fpath)) {
-            lib.log.error(`invalid bundle component at ${fpath}`);
+            bundle.log.error(`invalid bundle component at ${fpath}`);
         }
     }
     catch (e) {
-        lib.log.error(`invalid component at ${fpath}: ${e?.message}`);
+        bundle.log.error(`invalid component at ${fpath}: ${e?.message}`);
     }
     return false;
 }
@@ -86,14 +83,12 @@ export async function discover_library_definitions(lib, path, subdir = false) {
         const fstat = await Fsp.stat(fpath);
         if (fstat.isDirectory()) {
             if (!exclude_dirs.includes(fname)) {
-                if (await discover_bundle(lib, fpath) === Discovered.None) {
-                    await discover_library_definitions(lib, fpath, true);
-                }
+                await discover_library_definitions(lib, fpath, true);
             }
         }
         else if (fstat.isFile()) {
             if (is_config_filename(fname, "component")) {
-                await discover_component(lib, fpath);
+                await discover_component(lib.master, fpath);
             }
             else if (is_config_filename(fname, "application")) {
                 await discover_application(lib, fpath);
@@ -145,7 +140,6 @@ async function discover_library(ws, location) {
     ws.libraries.push(lib);
     ws.log.info(`+ 📚 library: ${lib.get_id()} (${make_relative_path(ws.path, location)})`);
     // Discover library-level search_directories, lockfile, and constants (walk up to workspace root)
-    let lockfile = null;
     lib.constants = { ...ws.constants };
     for (let path = lib.path;;) {
         const package_json = await readJsonFile(path + "/package.json");
@@ -161,24 +155,20 @@ async function discover_library(ws, location) {
                 };
             }
         }
-        if (!lockfile) {
-            lockfile = await read_lockfile(path);
+        if (!lib.deps) {
+            lib.deps = await read_lockfile(path);
         }
         const next_path = make_normalized_dirname(path);
         if (next_path === path)
             break;
         path = next_path;
     }
-    // Analyze lock file
-    if (lockfile) {
-        lib.resolved_versions = lockfile.resolved_versions;
-        for (const dep_id in lockfile.resolved_versions) {
-            const dep_path = lib.resolved_versions[dep_id];
-            await discover_bundle(lib, dep_path);
-        }
-    }
-    else {
-        throw new Error(`Lock file not found for '${ws.name}'`);
+    if (!lib.deps)
+        throw new Error(`Lock file not found for '${lib.name}'`);
+    // Discover side bundles from lock file
+    for (const dep_id in lib.descriptor.dependencies) {
+        const dep_path = lib.deps.resolved_paths[dep_id];
+        await discover_bundle(lib, dep_path);
     }
     // Load library packager
     let packager = null;
@@ -217,15 +207,15 @@ async function discover_bundle(lib, location) {
             return Discovered.Ignored;
         }
     }
-    const bun = new Bundle(bun_manif, lib.path, lib.workspace);
-    lib.bundle = bun;
+    // Register bundle into library
+    const bun = new Bundle(bun_manif, lib.path, lib);
     lib.shelve.push(bun);
     lib.log.info(`+ 📦 bundle: ${bun.id} ⏬`);
     // Analyze library deployment manifest (supports json/yaml/yml/toml, singleton)
     if (bun_manif?.data?.components) {
         for (const pub of bun_manif.data.components) {
-            const fpath = lib.path + "/" + (pub.ref ?? pub.id);
-            await discover_component(lib, fpath);
+            const fpath = bun_path + "/" + (pub.ref ?? pub.id);
+            await discover_component(bun, fpath);
         }
     }
     return Discovered.Registered;
@@ -276,4 +266,3 @@ export async function discover_workspace(ws) {
     show_constants(ws);
     return ws;
 }
-//# sourceMappingURL=discover-workspace.js.map

package/esm/workspace/helpers/lockfile.d.ts

@@ -0,0 +1,5 @@
+export type PackageDepsInfo = {
+    resolved_versions: Record<string, string>;
+    resolved_paths: Record<string, string>;
+};
+export declare function read_lockfile(dir: string): Promise<PackageDepsInfo | null>;

package/esm/workspace/helpers/lockfile.js

@@ -19,27 +19,27 @@ export async function read_lockfile(dir) {
 }
 function parse_npm_lockfile(lock) {
     const resolved_versions = {};
-    const installed_locations = [];
+    const resolved_paths = {};
     for (const location in lock.packages) {
         if (!location)
             continue;
-        installed_locations.push(location);
         if (location.startsWith("node_modules/")) {
             let pkg = lock.packages[location];
             if (pkg.link) {
                 pkg = lock.packages[pkg.resolved];
             }
             const name = location.replace(/^.*node_modules\//, "");
+            resolved_paths[name] = location;
             if (pkg?.version) {
                 resolved_versions[name] = pkg.version;
             }
         }
     }
-    return { resolved_versions, installed_locations };
+    return { resolved_versions, resolved_paths };
 }
 function parse_pnpm_lockfile(lock) {
     const resolved_versions = {};
-    const locations = new Set();
+    const resolved_paths = {};
     if (lock.packages) {
         for (const key in lock.packages) {
             const clean = key.startsWith("/") ? key.slice(1) : key;
@@ -49,7 +49,7 @@ function parse_pnpm_lockfile(lock) {
                 const version = clean.slice(atIdx + 1).split("(")[0];
                 if (name && version) {
                     resolved_versions[name] = version;
-                    locations.add("node_modules/" + name);
+                    resolved_paths[name] = "node_modules/" + name;
                 }
             }
         }
@@ -57,14 +57,14 @@ function parse_pnpm_lockfile(lock) {
     if (lock.importers) {
         for (const key in lock.importers) {
             if (key !== ".")
-                locations.add(key);
+                resolved_paths[key] = key;
         }
     }
-    return { resolved_versions, installed_locations: [...locations] };
+    return { resolved_versions, resolved_paths };
 }
 function parse_yarn_lockfile(text) {
     const resolved_versions = {};
-    const locations = new Set();
+    const resolved_paths = {};
     if (text.includes("__metadata:")) {
         const lock = YAML.parse(text);
         for (const key in lock) {
@@ -74,15 +74,15 @@ function parse_yarn_lockfile(text) {
                 const name = extract_package_name(key.split(",")[0].trim());
                 if (name) {
                     resolved_versions[name] = lock[key].version;
-                    locations.add("node_modules/" + name);
+                    resolved_paths[name] = "node_modules/" + name;
                 }
             }
         }
     }
     else {
-        parse_yarn_classic(text, resolved_versions, locations);
+        parse_yarn_classic(text, resolved_versions, resolved_paths);
     }
-    return { resolved_versions, installed_locations: [...locations] };
+    return { resolved_versions, resolved_paths };
 }
 function extract_package_name(entry) {
     entry = entry.replace(/^"|"$/g, "");
@@ -90,7 +90,7 @@ function extract_package_name(entry) {
     const at = entry.startsWith("@") ? entry.indexOf("@", 1) : entry.indexOf("@");
     return at > 0 ? entry.slice(0, at) : null;
 }
-function parse_yarn_classic(text, resolved_versions, locations) {
+function parse_yarn_classic(text, resolved_versions, resolved_paths) {
     let current_name = null;
     for (const line of text.split("\n")) {
         const trimmed = line.trim();
@@ -100,9 +100,8 @@ function parse_yarn_classic(text, resolved_versions, locations) {
         else if (current_name && trimmed.startsWith("version ")) {
             const version = trimmed.slice(8).replace(/^"|"$/g, "");
             resolved_versions[current_name] = version;
-            locations.add("node_modules/" + current_name);
+            resolved_paths[current_name] = "node_modules/" + current_name;
             current_name = null;
         }
     }
 }
-//# sourceMappingURL=lockfile.js.map