@jointhedots/gear 1.2.0 → 1.2.3

package/esm/core/components/manifold.js

@@ -0,0 +1,442 @@
+import { URI, Utils } from "vscode-uri";
+import { ComponentControllerKey } from "./components.js";
+import { Log, queryLogInfos, queryLogObjects } from "../logging/mod.js";
+import { parseResourceEntry } from "./helpers.js";
+import { ComponentProviderHub } from "./provider.js";
+// Component registry entry
+export class ComponentEntry {
+    id;
+    __instance__ = undefined;
+    manifest = undefined;
+    constructor(id) {
+        this.id = id;
+    }
+    get title() {
+        return this.id;
+    }
+    get namespace() {
+        const sep = this.id.indexOf(":");
+        switch (sep) {
+            case -1:
+                return "std";
+            case 0:
+                return "";
+            default:
+                return this.id.slice(0, sep);
+        }
+    }
+    get valid() {
+        return this.manifest !== undefined && this.manifest.type !== "<error>";
+    }
+    get loaded() {
+        return this.manifest !== undefined;
+    }
+    get installed() {
+        return this.__instance__ !== undefined;
+    }
+    get instance() {
+        return this.__instance__;
+    }
+    set instance(value) {
+        this.__instance__ = value;
+        if (value instanceof Object) {
+            ComponentsRegistry.datamap.set(value, this);
+        }
+        else if (value !== null) {
+            this.__instance__ = null;
+            throw new Error(`Component instance shall be an object`);
+        }
+    }
+    get() {
+        if (this.manifest === undefined) {
+            throw new Error(`Cannot get manifest of not loaded module`);
+        }
+        return this.manifest;
+    }
+    set(manifest) {
+        this.manifest = manifest;
+        return this;
+    }
+    fetch() {
+        let loading = ComponentsRegistry.loadings.get(this);
+        if (loading)
+            return loading;
+        if (this.manifest === undefined) {
+            loading = ComponentsRegistry.components_provider.get_component_manifest(this.id).then(async (manifest) => {
+                if (manifest) {
+                    if (manifest.type) {
+                        await acquireComponent(manifest.type).fetch();
+                    }
+                    this.manifest = manifest;
+                }
+                else
+                    throw new Error(`Component '${this.id}' not found`);
+                return this.manifest;
+            }).catch((e) => {
+                Log.error(e, this);
+                this.set({
+                    $id: this.id,
+                    type: "<error>",
+                    message: e.message,
+                    stack: e.stack,
+                });
+                this.__instance__ = new Error(e.message);
+                return this.manifest;
+            });
+        }
+        else {
+            loading = Promise.resolve(this.manifest);
+        }
+        ComponentsRegistry.loadings.set(this, loading);
+        return loading;
+    }
+    async install() {
+        let installing = ComponentsRegistry.installings.get(this);
+        if (installing)
+            return installing;
+        if (this.instance === undefined) {
+            this.instance = null;
+            installing = new Promise(async (resolve) => {
+                try {
+                    if (this.loaded === false) {
+                        await this.fetch();
+                    }
+                    const type = this.manifest?.type;
+                    if (type) {
+                        const entry = acquireComponent(type);
+                        const controller = await ComponentControllerKey.fetch(entry);
+                        await controller.createComponent(this, this.manifest);
+                    }
+                }
+                catch (e) {
+                    Log.error(e, this);
+                }
+                resolve(this);
+            });
+        }
+        else {
+            installing = Promise.resolve(this);
+        }
+        ComponentsRegistry.installings.set(this, installing);
+        return installing;
+    }
+    acquireResource(identifier) {
+        const ref = `${this.id}#${identifier}`;
+        let rc = ComponentsRegistry.resources.get(ref);
+        if (!rc) {
+            rc = new ComponentResource(this, identifier);
+            ComponentsRegistry.resources.set(ref, rc);
+        }
+        return rc;
+    }
+    getResource(identifier) {
+        if (this.hasResource(identifier)) {
+            return this.acquireResource(identifier);
+        }
+        return null;
+    }
+    hasResource(identifier) {
+        const { manifest } = this;
+        if (manifest?.apis?.[identifier]) {
+            return true;
+        }
+        else if (manifest?.type) {
+            const type = acquireComponent(manifest.type);
+            if (type) {
+                return type?.hasResource(`component.${identifier}`);
+            }
+        }
+        return false;
+    }
+    async getResourceAsync(identifier) {
+        if (this.manifest === undefined)
+            await this.fetch();
+        return this.getResource(identifier);
+    }
+    async fetchResource(identifier) {
+        if (this.manifest === undefined)
+            await this.fetch();
+        return this.getResource(identifier)?.fetch();
+    }
+    getLogStats() {
+        return queryLogInfos(this.id);
+    }
+    getLogs(count) {
+        return queryLogObjects(count, this.id);
+    }
+}
+// Component resource
+export class ComponentResource {
+    component;
+    resource;
+    entry = undefined;
+    identifier = undefined;
+    constructor(component, resource) {
+        this.component = component;
+        this.resource = resource;
+        component.fetch();
+    }
+    get valid() {
+        return this.identifier !== undefined && this.component.valid;
+    }
+    get loaded() {
+        return this.identifier !== undefined;
+    }
+    async fetch() {
+        if (this.identifier === undefined) {
+            let loading = ComponentsRegistry.loadings.get(this);
+            if (loading)
+                return loading;
+            loading = new Promise(async (resolve) => {
+                const { component } = this;
+                try {
+                    // Fetch manifest with resource catalog
+                    if (component.installed === false) {
+                        await component.install();
+                    }
+                    // Fetch resource data
+                    const { manifest } = component;
+                    const entry = parseResourceEntry(manifest.apis?.[this.resource]);
+                    const type = entry?.type;
+                    if (type === "module") {
+                        this.entry = await ComponentsRegistry.resources_loader.load_resource(entry.location);
+                        this.identifier = entry.identifier;
+                    }
+                    /*else if (type === "api.rest") {
+                       this.entry = __import_RESTService(entry as RESTServiceImport, component)
+                       this.identifier = null
+                    }*/
+                    else if (manifest.type) {
+                        const controller = acquireComponent(manifest.type);
+                        const resource = controller.getResource(`component.${this.resource}`);
+                        if (resource) {
+                            const getter = await resource.fetch();
+                            if (getter)
+                                this.entry = await getter(this.component);
+                            else
+                                this.entry = null;
+                            this.identifier = null;
+                        }
+                        else {
+                            throw new Error(`Cannot provide resource '${this.resource}'`);
+                        }
+                    }
+                    else {
+                        throw new Error(`Cannot load resource '${this.resource}': ${JSON.stringify(entry)}`);
+                    }
+                    const entrypoint = this.get();
+                    if (entrypoint instanceof Object) {
+                        ComponentsRegistry.datamap.set(entrypoint, this);
+                    }
+                }
+                catch (e) {
+                    console.error(`Cannot install service api '${this.resource}' of '${component.id}':`, e);
+                    this.entry = null;
+                    this.identifier = null;
+                }
+                resolve(this.get());
+                ComponentsRegistry.loadings.set(this, null);
+            });
+            ComponentsRegistry.loadings.set(this, loading);
+            return loading;
+        }
+        else {
+            return this.get();
+        }
+    }
+    get() {
+        if (this.entry) {
+            if (this.identifier !== null) {
+                return this.entry?.[this.identifier];
+            }
+            else {
+                return this.entry;
+            }
+        }
+        return undefined;
+    }
+    set(data) {
+        this.entry = data;
+        this.identifier = null;
+    }
+    get spec() {
+        const norm = this.resource.split(".")[0];
+        return this.component.manifest?.specs?.[norm];
+    }
+    get url() {
+        const ref = this.component.manifest?.apis?.[this.resource];
+        if (typeof ref === "string") {
+            const base = URI.parse(window.location.href).with({ fragment: null });
+            const uri = Utils.joinPath(base, "..", ref.split("#")[0]);
+            return uri.toString();
+        }
+        return null;
+    }
+}
+export class ComponentsManifold {
+    components = new Map();
+    resources = new Map();
+    datamap = new WeakMap();
+    loadings = new Map();
+    installings = new Map();
+    listeners = new Set();
+    components_provider = null;
+    resources_loader = null;
+    content_provider = null;
+    constructor() {
+        /*
+        const componen_provider=new ComponentProviderHub()
+        this.content_provider = new StaticContentProvider()
+        this.components_provider.add_provider(new StaticComponentProvider(this.content_provider))
+        this.components_provider.add_provider(createLocalComponentProvider())
+        this.resources_loader = new CommonResourceProvider(this.content_provider)*/
+    }
+    listen(l) {
+        this.listeners.add(l);
+        return l;
+    }
+    unlisten(l) {
+        this.listeners.delete(l);
+    }
+    notifyError(subject, error) {
+    }
+}
+export const ComponentsRegistry = new ComponentsManifold();
+acquireComponent("<error>").set({
+    $id: "<error>",
+    icon: "bi:house",
+    title: "Define invalid component",
+});
+export function getDefaultComponent() {
+    return acquireComponent("log:application");
+}
+export function getComponentFromData(data, is_static) {
+    if (data instanceof Object) {
+        const target = ComponentsRegistry.datamap.get(data) || data;
+        if (target instanceof ComponentEntry) {
+            return target;
+        }
+        if (target instanceof ComponentResource) {
+            return target.component;
+        }
+        if (!is_static && data["getComponent"] instanceof Function) {
+            return getComponentFromData(data["getComponent"](), true);
+        }
+    }
+    return getDefaultComponent();
+}
+export function acquireComponent(id) {
+    let obj = ComponentsRegistry.components.get(id);
+    if (!obj && typeof id === "string") {
+        obj = new ComponentEntry(id);
+        ComponentsRegistry.components.set(id, obj);
+    }
+    return obj;
+}
+export function acquireFutureComponent(manifest) {
+    const id = manifest.$id;
+    let obj = ComponentsRegistry.components.get(id);
+    if (!obj && typeof id === "string") {
+        obj = new ComponentEntry(id);
+        obj.manifest = manifest;
+        obj.instance = null;
+        ComponentsRegistry.components.set(id, obj);
+    }
+    return obj;
+}
+export function acquireResource(ref) {
+    const parts = ref.split("#");
+    if (parts.length === 2) {
+        const entry = acquireComponent(parts[0]);
+        return entry?.acquireResource(parts[1]);
+    }
+    return null;
+}
+export function resolveRelativeComponent(ref, from) {
+    if (from && ref.startsWith("/")) {
+        return acquireComponent(`${from?.id}${ref}`);
+    }
+    return null;
+}
+export async function saveComponentManifest(manifest) {
+    const component = acquireComponent(manifest.$id);
+    ComponentsRegistry.loadings.delete(component);
+    component.manifest = manifest;
+    return saveComponent(component);
+}
+export async function saveComponent(component) {
+    console.log("[Update Component]", component.id);
+    const manifest = await component.fetch();
+    const provider = ComponentsRegistry.components_provider;
+    if (!provider)
+        throw new Error(`No component provider`);
+    await provider.add_component(manifest);
+    if (component.loaded) {
+        if (manifest.type && component.installed) {
+            const controller = await ComponentControllerKey.fetch(acquireComponent(manifest.type));
+            if (controller) {
+                if (component.instance) {
+                    await controller.updateComponent(component, manifest);
+                }
+                else {
+                    component["__instance__"] = undefined;
+                    await controller.createComponent(component, manifest);
+                }
+            }
+            if (component.instance instanceof Object) {
+                ComponentsRegistry.datamap.set(component.instance, component);
+            }
+            ComponentsRegistry.listeners.forEach(l => l(component));
+        }
+    }
+    return component;
+}
+export async function deleteComponent(id) {
+    console.log("deleteComponent", id);
+    const provider = ComponentsRegistry.components_provider;
+    if (!provider)
+        throw new Error(`No component provider`);
+    if (await provider.delete_component(id)) {
+        unregisterComponent(id);
+    }
+}
+export function unregisterComponent(id) {
+    const component = ComponentsRegistry.components.get(id);
+    if (component) {
+        component.set({
+            $id: component.id,
+            type: "<error>",
+            message: `Component deleted`,
+        });
+        ComponentsRegistry.listeners.forEach(l => l(component));
+        ComponentsRegistry.components.delete(id);
+    }
+}
+export async function searchComponentsPublications(filter) {
+    const provider = ComponentsRegistry.components_provider;
+    if (!provider)
+        throw new Error(`No component provider`);
+    return provider.search_component_publications(filter);
+}
+export async function fetchComponentsPublications(components_ids) {
+    const results = [];
+    const provider = ComponentsRegistry.components_provider;
+    if (!provider)
+        throw new Error(`No component provider`);
+    for (const id of components_ids) {
+        const cnx = await provider.get_component_publication(id);
+        if (cnx) {
+            results.push(cnx);
+        }
+        else {
+            results.push(failedComponentPublication(id));
+        }
+    }
+    return results;
+}
+export function failedComponentPublication(id, title) {
+    return {
+        id: id,
+        title: title ? title : "! Not found: " + id,
+    };
+}

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

@@ -0,0 +1,4 @@
+export * from "./components.ts";
+export * from "./manifold.ts";
+export * from "./provider.ts";
+export * from "./helpers.ts";

package/esm/core/components/mod.js

@@ -0,0 +1,4 @@
+export * from "./components.js";
+export * from "./manifold.js";
+export * from "./provider.js";
+export * from "./helpers.js";

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

@@ -0,0 +1,42 @@
+import { type ComponentManifest, type ComponentPublication } from "@jointhedots/gear/core";
+import { URI } from "vscode-uri";
+export type ContentType = string;
+export interface IResourceLoader {
+    load_resource(uri: string): Promise<any>;
+}
+export interface IComponentPublisher {
+    search_component_publications(filter: ComponentFilter): Promise<ComponentPublication[]>;
+    get_component_publication(component_id: string): Promise<ComponentPublication>;
+}
+export interface IComponentProvider extends IComponentPublisher {
+    get_component_manifest(component_id: string): Promise<ComponentManifest>;
+    set_component_manifest(component_id: string, manifest: ComponentManifest): Promise<boolean>;
+    add_component(manifest: ComponentManifest): Promise<ComponentPublication>;
+    delete_component(component_id: string): Promise<boolean>;
+}
+export interface IContentProvider {
+    check_content(uri: URI): Promise<ContentType>;
+    load_content(uri: URI): Promise<Blob>;
+    store_content(uri: URI, content: Blob): Promise<boolean>;
+}
+export type ComponentFilter = {
+    query: string;
+    pattern: RegExp;
+    keywords: string[];
+    tags: string[];
+    types: string[];
+    services: string[];
+};
+export declare function createComponentFilter(filter?: Partial<ComponentFilter>): ComponentFilter;
+export declare function matchComponentFilter(pub: ComponentPublication, filter?: Partial<ComponentFilter>): boolean;
+export declare class ComponentProviderHub implements IComponentProvider {
+    readonly providers: IComponentProvider[];
+    constructor(providers?: IComponentProvider[]);
+    add_provider(provider: IComponentProvider): void;
+    get_component_publication(id: string): Promise<ComponentPublication>;
+    search_component_publications(filter: ComponentFilter): Promise<ComponentPublication[]>;
+    get_component_manifest(id: string): Promise<ComponentManifest>;
+    set_component_manifest(component_id: string, manifest: ComponentManifest): Promise<boolean>;
+    add_component(manifest: ComponentManifest): Promise<ComponentPublication>;
+    delete_component(component_id: string): Promise<boolean>;
+}

package/esm/core/components/provider.js

@@ -0,0 +1,127 @@
+import {} from "@jointhedots/gear/core";
+import { URI } from "vscode-uri";
+export function createComponentFilter(filter) {
+    const result = {
+        query: filter?.query || "",
+        pattern: filter?.pattern || null,
+        tags: filter?.tags || [],
+        keywords: filter?.keywords || [],
+        services: filter?.services || [],
+        types: filter?.types || [],
+    };
+    if (result.query.length > 0) {
+        for (const kw of result.query.split(/\s/)) {
+            if (kw.length > 0 && !result.keywords.includes(kw)) {
+                result.keywords.push(kw);
+            }
+        }
+    }
+    if (result.keywords.length > 0) {
+        result.pattern = new RegExp(`(${result.keywords.join(").*(")})`);
+    }
+    return result;
+}
+export function matchComponentFilter(pub, filter) {
+    function match_text(text, pattern) {
+        if (!pattern) {
+            return true;
+        }
+        if (text) {
+            return !pattern || pattern.test(text);
+        }
+        return false;
+    }
+    function match_item_in_list(target, expecteds) {
+        if (expecteds.length === 0) {
+            return true;
+        }
+        if (target && expecteds.includes(target)) {
+            return true;
+        }
+        return false;
+    }
+    function match_list_in_list(targets, expecteds) {
+        if (expecteds.length === 0) {
+            return true;
+        }
+        if (targets) {
+            for (const target of targets) {
+                if (expecteds.includes(target))
+                    return true;
+            }
+        }
+        return false;
+    }
+    if (!match_text(pub.title || pub.id, filter.pattern) && !match_text(pub.description, filter.pattern))
+        return false;
+    if (!match_list_in_list(pub.services, filter.services))
+        return false;
+    if (!match_list_in_list(pub.keywords, filter.keywords))
+        return false;
+    if (!match_list_in_list(pub.tags, filter.tags))
+        return false;
+    if (!match_item_in_list(pub.type, filter.types))
+        return false;
+    return true;
+}
+//-------------------------------------------------------------
+// Component providers hub
+//-------------------------------------------------------------
+export class ComponentProviderHub {
+    providers;
+    constructor(providers = []) {
+        this.providers = providers;
+    }
+    add_provider(provider) {
+        this.providers.push(provider);
+    }
+    async get_component_publication(id) {
+        for (const provider of this.providers) {
+            const found = await provider.get_component_publication(id);
+            if (found)
+                return found;
+        }
+        return null;
+    }
+    async search_component_publications(filter) {
+        const result = [];
+        for (const provider of this.providers) {
+            const founds = await provider.search_component_publications(filter);
+            if (founds)
+                result.push(...founds);
+        }
+        return result;
+    }
+    async get_component_manifest(id) {
+        for (const provider of this.providers) {
+            const founds = await provider.get_component_manifest(id);
+            if (founds)
+                return founds;
+        }
+        return null;
+    }
+    async set_component_manifest(component_id, manifest) {
+        for (const provider of this.providers) {
+            const done = await provider.set_component_manifest(component_id, manifest);
+            if (done)
+                return true;
+        }
+        return false;
+    }
+    async add_component(manifest) {
+        for (const provider of this.providers) {
+            const done = await provider.add_component(manifest);
+            if (done)
+                return done;
+        }
+        return null;
+    }
+    async delete_component(component_id) {
+        for (const provider of this.providers) {
+            const done = await provider.delete_component(component_id);
+            if (done)
+                return true;
+        }
+        return false;
+    }
+}

package/esm/core/logging/mod.d.ts

@@ -0,0 +1,53 @@
+import type { Command } from "../commands/interface.ts";
+export { print } from "./trace.ts";
+export type LogObjectID = string;
+export type LogStatus = "error" | "warn" | "notify" | "info";
+export type LogKind = "event" | "ticket";
+export interface ILogDispatcher {
+    notifyError(error: Error, subject?: any): any;
+    notifyObject(object: LogObject): any;
+}
+export interface ILogSubject {
+    getSubject(): string;
+}
+export interface LogAction extends Command {
+    optional?: boolean;
+    doc_uri?: string;
+    callback?: Command;
+}
+export interface LogObject {
+    id: LogObjectID;
+    kind: LogKind;
+    status: LogStatus;
+    message: string;
+    component_id: string;
+    doc_uri?: string;
+    icon?: string;
+    title?: string;
+    attributes?: Record<string, string | number>;
+    actions?: LogAction[];
+}
+export declare function registerLogCollector(collector: ILogDispatcher): void;
+export declare function unregisterLogCollector(collector: ILogDispatcher): void;
+export declare function queryLogCount(): number;
+export type QueryLogResult = {
+    objects: LogObject[];
+    hasMore: boolean;
+};
+export declare function queryLogObjects(count: number, component_id?: string): QueryLogResult;
+export type LogInfos = {
+    action_expected_count: number;
+    error_count: number;
+    warn_count: number;
+    notify_count: number;
+    info_count: number;
+};
+export declare function queryLogInfos(component_id?: string): LogInfos;
+export declare const Log: {
+    send(object: LogObject): void;
+    error(error: Error, target?: any): void;
+    event(target: any, options?: Partial<LogObject>): void;
+    openTicket(target: any, name: string, options?: Partial<LogObject>): void;
+    closeTicket(target: any, name: string): void;
+};
+export declare function createLogFromError(error: Error, target?: any): LogObject;