@jointhedots/gear 1.1.18 → 1.2.2

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

@@ -84,7 +84,7 @@ export function create_package_manifest(lib, bun, build_version) {
         optionalDependencies: undefined,
     };
     if (pkg_manif.dependencies) {
-        const resolved = lib.workspace.resolved_versions;
+        const resolved = lib.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 { Library, Workspace } from "../workspace.ts";
+export declare function discover_component(lib: Library, 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>;