@jointhedots/gear 1.2.0 → 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

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

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

@@ -276,4 +276,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 LockFileInfo = {
+    resolved_versions: Record<string, string>;
+    installed_locations: string[];
+};
+export declare function read_lockfile(dir: string): Promise<LockFileInfo | null>;

package/esm/workspace/helpers/lockfile.js

@@ -105,4 +105,3 @@ function parse_yarn_classic(text, resolved_versions, locations) {
         }
     }
 }
-//# sourceMappingURL=lockfile.js.map

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

@@ -0,0 +1,65 @@
+export interface Message {
+    id: string;
+    text: string;
+    location?: Location | string;
+    notes?: Note[];
+    /**
+     * Optional user-specified data that is passed through unmodified. You can
+     * use this to stash the original error, for example.
+     */
+    detail?: any;
+}
+export interface Note {
+    title?: string;
+    text: string;
+    location?: Location | string;
+}
+export interface Location {
+    file: string;
+    namespace?: string;
+    /** 1-based */
+    line?: number;
+    /** 0-based, in bytes */
+    column?: number;
+    /** in bytes */
+    length?: number;
+    lineText?: string;
+    suggestion?: string;
+}
+export type LogKind = "error" | "warn" | "info" | "success" | "debug" | "trace";
+export type LogMode = "normal" | "debug" | "verbose";
+export interface LogEntry {
+    kind: LogKind;
+    message: Message;
+    timestamp: number;
+}
+export declare class Log {
+    readonly id: string;
+    private entries;
+    private logger;
+    constructor(id: string, logger: Logger);
+    put(kind: LogKind, message: string | Error | Message): void;
+    error(message: string | Error | Message): void;
+    warn(message: string | Error | Message): void;
+    info(message: string | Error | Message): void;
+    success(message: string | Error | Message): void;
+    debug(message: string | Error | Message): void;
+    trace(message: string | Error | Message): void;
+    private normalizeMessage;
+    getEntries(): readonly LogEntry[];
+    clear(): void;
+}
+export declare class Logger {
+    private loggers;
+    readonly mode: LogMode;
+    readonly silentKinds: Set<LogKind>;
+    constructor(mode?: LogMode);
+    get(id: string): Log;
+    has(id: string): boolean;
+    remove(id: string): boolean;
+    all(): IterableIterator<Log>;
+    clear(): void;
+}
+export declare function stringifyLocation(loc: Location | string | null | undefined): string;
+export declare function stringifyLogEntry(loggerId: string, entry: LogEntry): string;
+export declare function stringifyLogEntryPretty(loggerId: string, entry: LogEntry): string;

package/esm/workspace/helpers/logger.js

@@ -145,4 +145,3 @@ export function stringifyLogEntryPretty(loggerId, entry) {
     }
     return lines.join("\n");
 }
-//# sourceMappingURL=logger.js.map

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

@@ -0,0 +1 @@
+export declare function resolvePackageVersion(startDir: string): string | undefined;

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

@@ -18,4 +18,3 @@ export function resolvePackageVersion(startDir) {
     }
     return undefined;
 }
-//# sourceMappingURL=package-npm.js.map

package/esm/workspace/mod.d.ts

@@ -0,0 +1 @@
+export {};

package/esm/workspace/mod.js

@@ -0,0 +1 @@
+export {};

package/esm/workspace/packager.d.ts

@@ -0,0 +1,5 @@
+import type { Bundle, Library } from "./workspace.ts";
+export interface LibraryPackager {
+    discover_library(lib: Library): Promise<Bundle>;
+}
+export declare function LoadLibraryPackager(specifier: string): Promise<LibraryPackager>;

package/esm/workspace/packager.js

@@ -6,7 +6,7 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
     }
     return path;
 };
-import ChildProcess from "child_process";
+import ChildProcess from "node:child_process";
 function parseSpecifier(specifier) {
     let raw = specifier.startsWith("npm:") ? specifier.slice(4) : specifier;
     let exportName;
@@ -50,4 +50,3 @@ export async function LoadLibraryPackager(specifier) {
         return resolveExport(mod, exportName);
     }
 }
-//# sourceMappingURL=packager.js.map

package/esm/workspace/packagers/packager-standard.d.ts

@@ -0,0 +1,7 @@
+import { Bundle, Library } from "../workspace.ts";
+import { type LibraryPackager } from "../packager.ts";
+export declare class DefaultLibraryPackager implements LibraryPackager {
+    discover_library(lib: Library): Promise<Bundle>;
+}
+export declare function setup_library_bundle(lib: Library): Bundle;
+export declare function collect_declarations_field(lib: Library, key: string, value: any): any;

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

@@ -61,4 +61,3 @@ function make_library_bundle_manifest(lib) {
         }
     };
 }
-//# sourceMappingURL=packager-standard.js.map

package/esm/workspace/storage.d.ts

@@ -0,0 +1,59 @@
+export type StorageChanges = {
+    added: string[];
+    updated: string[];
+    changed: boolean;
+};
+export interface IStorageTransaction {
+    commitContent(contentData: Uint8Array | string, contentType?: string): string;
+    commitFile(key: string, contentData: Uint8Array | string, contentType?: string): any;
+    accept(): Promise<StorageChanges>;
+}
+export interface IStorageZone {
+    clean(): any;
+    edit(scratch?: boolean): IStorageTransaction;
+    branch(path: string): IStorageZone;
+    getBaseDirFS(): string;
+}
+export declare class SourceEventEmitter {
+    clients: any[];
+    sendEventsToAll(type: string, data: any): void;
+    route(): (req: any, res: any) => void;
+}
+export declare function createContentCID(data: Uint8Array | string): string;
+export declare function createContentKey(contentData: Uint8Array | string, contentType?: string): string;
+export type FileCache = Map<string, string>;
+export declare class StorageTransaction implements IStorageTransaction {
+    private baseDir;
+    private scratch;
+    private root;
+    private pending;
+    constructor(baseDir: string, scratch: boolean, root: StorageFiles);
+    commitContent(contentData: Uint8Array | string, contentType?: string): string;
+    commitFile(key: string, contentData: Uint8Array | string, contentType?: string): void;
+    accept(): Promise<StorageChanges>;
+}
+export declare class SubStorageFiles implements IStorageZone {
+    readonly root: StorageFiles;
+    readonly baseDir: string;
+    constructor(root: StorageFiles, baseDir: string);
+    getBaseDirFS(): string;
+    clean(): void;
+    edit(scratch?: boolean): IStorageTransaction;
+    branch(path: string): IStorageZone;
+}
+export declare class StorageFiles implements IStorageZone {
+    name: string;
+    readonly baseDir: string;
+    cache: FileCache;
+    on_changes: SourceEventEmitter;
+    constructor(name: string, baseDir: string);
+    getBaseDirFS(): string;
+    clean(): void;
+    edit(scratch?: boolean): IStorageTransaction;
+    branch(path: string): IStorageZone;
+    route(): (req: any, res: any) => void;
+}
+export declare function copyToStorageStream(storage: IStorageTransaction, key: string, path: string, contentType?: string): void;
+export declare function removeFile(path: string): void;
+export declare function removeDirectory(path: string): void;
+export declare function readJsonFile<T = any>(path: string): Promise<T>;

package/esm/workspace/storage.js

@@ -1,8 +1,8 @@
 import Fsp from "node:fs/promises";
-import Fs from 'node:fs';
-import Crypto from 'node:crypto';
-import Path from 'node:path';
-import MIME from 'mime';
+import Fs from "node:fs";
+import Crypto from "node:crypto";
+import Path from "node:path";
+import MIME from "mime";
 import { directory } from "../utils/file.js";
 export class SourceEventEmitter {
     clients = [];
@@ -174,4 +174,3 @@ export async function readJsonFile(path) {
         return undefined;
     }
 }
-//# sourceMappingURL=storage.js.map