@jointhedots/gear 1.1.18 → 1.2.2

package/esm/core/logging/mod.js

@@ -0,0 +1,142 @@
+import { getComponentFromData } from "../components/manifold.js";
+export { print } from "./trace.js";
+class ConsoleLog {
+    notifyError(error, target) {
+        console.error(error);
+        this.notifyObject(createLogFromError(error, target));
+    }
+    notifyObject(object) {
+        log_objects.push(object);
+        console.log(object);
+    }
+}
+const log_dispatchers = new Set();
+const log_objects = [];
+let log_object_ids = 0;
+const default_log = new ConsoleLog();
+registerLogCollector(default_log);
+function generateLogId() {
+    log_object_ids++;
+    return 'id-' + Date.now().toString(36) + '-' + log_object_ids.toString(2);
+}
+export function registerLogCollector(collector) {
+    log_dispatchers.add(collector);
+}
+export function unregisterLogCollector(collector) {
+    log_dispatchers.delete(collector);
+}
+export function queryLogCount() {
+    return log_objects.length;
+}
+export function queryLogObjects(count, component_id) {
+    const objects = [];
+    for (const obj of log_objects) {
+        if (component_id === undefined || component_id === obj.component_id) {
+            if (objects.length >= count) {
+                return { objects, hasMore: true };
+            }
+            objects.push(obj);
+        }
+    }
+    return { objects, hasMore: false };
+}
+export function queryLogInfos(component_id) {
+    return log_objects.reduce((info, obj) => {
+        if (component_id === undefined || component_id === obj.component_id) {
+            switch (obj.status) {
+                case "error":
+                    info.error_count++;
+                    info.warn_count++;
+                    info.notify_count++;
+                    info.info_count++;
+                    break;
+                case "warn":
+                    info.warn_count++;
+                    info.notify_count++;
+                    info.info_count++;
+                    break;
+                case "notify":
+                    info.notify_count++;
+                    info.info_count++;
+                    break;
+                case "info":
+                    info.info_count++;
+                    break;
+            }
+        }
+        return info;
+    }, {
+        action_expected_count: 0,
+        error_count: 0,
+        warn_count: 0,
+        notify_count: 0,
+        info_count: 0,
+    });
+}
+export const Log = {
+    send(object) {
+        setTimeout(() => {
+            for (const collector of log_dispatchers) {
+                collector.notifyObject(object);
+            }
+        }, 0);
+    },
+    error(error, target) {
+        setTimeout(() => {
+            for (const collector of log_dispatchers) {
+                collector.notifyError(error, target);
+            }
+        }, 0);
+    },
+    event(target, options) {
+        const entry = getComponentFromData(target);
+        const id = generateLogId();
+        Log.send({
+            ...options,
+            kind: "event",
+            status: options.status || "error",
+            message: options.message || `Issue with component: ${id}`,
+            component_id: entry.id,
+            id,
+        });
+    },
+    openTicket(target, name, options) {
+        const entry = getComponentFromData(target);
+        const id = `${entry.id}/${name}`;
+        Log.send({
+            ...options,
+            kind: "ticket",
+            status: options.status || "error",
+            message: options.message || `Issue with component: ${id}`,
+            component_id: entry.id,
+            id,
+        });
+    },
+    closeTicket(target, name) {
+        const entry = getComponentFromData(target);
+        const id = `${entry.id}/${name}`;
+        const index = log_objects.findIndex(x => x.id === id);
+        if (index >= 0) {
+            const ticket = log_objects[index];
+            log_objects.splice(index, 1);
+            Log.event(target, {
+                ...ticket,
+                kind: "event",
+                status: "info",
+                icon: "[success]bi:check-circle",
+                message: `[closed] ${ticket.message}`,
+                actions: undefined,
+                doc_uri: undefined,
+            });
+        }
+    },
+};
+export function createLogFromError(error, target) {
+    return {
+        id: generateLogId(),
+        kind: "event",
+        status: "error",
+        component_id: getComponentFromData(target).id,
+        message: error.message,
+    };
+}

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

@@ -0,0 +1,51 @@
+export declare const originalConsole: {
+    assert(condition?: boolean, ...data: any[]): void;
+    assert(value: any, message?: string, ...optionalParams: any[]): void;
+    clear(): void;
+    clear(): void;
+    count(label?: string): void;
+    count(label?: string): void;
+    countReset(label?: string): void;
+    countReset(label?: string): void;
+    debug(...data: any[]): void;
+    debug(message?: any, ...optionalParams: any[]): void;
+    dir(item?: any, options?: any): void;
+    dir(obj: any, options?: import("util").InspectOptions): void;
+    dirxml(...data: any[]): void;
+    dirxml(...data: any[]): void;
+    error(...data: any[]): void;
+    error(message?: any, ...optionalParams: any[]): void;
+    group(...data: any[]): void;
+    group(...label: any[]): void;
+    groupCollapsed(...data: any[]): void;
+    groupCollapsed(...label: any[]): void;
+    groupEnd(): void;
+    groupEnd(): void;
+    info(...data: any[]): void;
+    info(message?: any, ...optionalParams: any[]): void;
+    log(...data: any[]): void;
+    log(message?: any, ...optionalParams: any[]): void;
+    table(tabularData?: any, properties?: string[]): void;
+    table(tabularData: any, properties?: readonly string[]): void;
+    time(label?: string): void;
+    time(label?: string): void;
+    timeEnd(label?: string): void;
+    timeEnd(label?: string): void;
+    timeLog(label?: string, ...data: any[]): void;
+    timeLog(label?: string, ...data: any[]): void;
+    timeStamp(label?: string): void;
+    timeStamp(label?: string): void;
+    trace(...data: any[]): void;
+    trace(message?: any, ...optionalParams: any[]): void;
+    warn(...data: any[]): void;
+    warn(message?: any, ...optionalParams: any[]): void;
+    Console: console.ConsoleConstructor;
+    profile(label?: string): void;
+    profileEnd(label?: string): void;
+};
+export declare const logError: (...args: any[]) => void;
+export declare const logWarning: (...args: any[]) => void;
+export declare const logInfo: (...args: any[]) => void;
+export declare const logTrace: (...args: any[]) => void;
+export declare const logDebug: (...args: any[]) => void;
+export declare const print: Console;

package/esm/core/logging/trace.js

@@ -0,0 +1,17 @@
+export const originalConsole = { ...console };
+export const logError = console.error = (...args) => {
+    originalConsole.error(...args.map(arg => typeof arg === "string" ? `\x1b[31m${arg}\x1b[0m` : arg));
+};
+export const logWarning = console.warn = (...args) => {
+    originalConsole.warn(...args.map(arg => typeof arg === "string" ? `\x1b[35m${arg}\x1b[0m` : arg));
+};
+export const logInfo = console.info = (...args) => {
+    originalConsole.info(...args.map(arg => typeof arg === "string" ? `\x1b[36m${arg}\x1b[0m` : arg));
+};
+export const logTrace = console.trace = (...args) => {
+    originalConsole.trace(...args.map(arg => typeof arg === "string" ? `\x1b[34m${arg}\x1b[0m` : arg));
+};
+export const logDebug = console.debug = (...args) => {
+    originalConsole.debug(...args.map(arg => typeof arg === "string" ? `\x1b[32m${arg}\x1b[0m` : arg));
+};
+export const print = console;

package/esm/core/mod-browser.d.ts

@@ -0,0 +1 @@
+export * from "./mod.ts";

package/esm/core/mod-browser.js

@@ -0,0 +1 @@
+export * from "./mod.js";

package/esm/core/mod-node.d.ts

@@ -0,0 +1 @@
+export * from "./mod.ts";

package/esm/core/mod-node.js

@@ -0,0 +1 @@
+export * from "./mod.js";

package/esm/core/mod.d.ts

@@ -0,0 +1,5 @@
+export * from "./components/mod.ts";
+export * from "./services/mod.ts";
+export * from "./commands/interface.ts";
+export * from "./logging/mod.ts";
+export * from "./schema/mod.ts";

package/esm/core/mod.js

@@ -0,0 +1,5 @@
+export * from "./components/mod.js";
+export * from "./services/mod.js";
+export * from "./commands/interface.js";
+export * from "./logging/mod.js";
+export * from "./schema/mod.js";

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

@@ -0,0 +1,36 @@
+import { type JSONSchema } from "./schema.ts";
+export declare const CommonTypes: {
+    boolean: JSONSchema;
+    string: JSONSchema;
+    number: JSONSchema;
+    object: JSONSchema;
+    view: JSONSchema;
+    display: JSONSchema;
+    function: JSONSchema;
+    null: JSONSchema;
+    unknown: JSONSchema;
+    any: JSONSchema;
+};
+export declare const CommonMakers: {
+    enums(base: JSONSchema, ...values: string[]): JSONSchema;
+    array(base: JSONSchema): JSONSchema;
+    record(fields: Record<string, JSONSchema>): JSONSchema;
+    collection(items: JSONSchema): JSONSchema;
+    event_fn(event?: JSONSchema): JSONSchema;
+};
+export declare const ErrorTypes: Record<string, JSONSchema>;
+declare function getPropertyTyping(propertyName: string, schema: JSONSchema): JSONSchema;
+declare function getItemTyping(index: number, schema: JSONSchema): JSONSchema;
+declare function getValueTyping(value: any): JSONSchema;
+declare function isType(typing: JSONSchema, kind: string): boolean;
+declare function typeAsString(type: JSONSchema["type"]): string;
+declare function generateTypescript(schema: JSONSchema): string;
+export declare const Schema: {
+    getPropertyTyping: typeof getPropertyTyping;
+    getItemTyping: typeof getItemTyping;
+    getValueTyping: typeof getValueTyping;
+    isType: typeof isType;
+    typeAsString: typeof typeAsString;
+    generateTypescript: typeof generateTypescript;
+};
+export {};

package/esm/core/schema/helpers.js

@@ -0,0 +1,163 @@
+import {} from "./schema.js";
+export const CommonTypes = {
+    boolean: {
+        type: "boolean"
+    },
+    string: {
+        type: "string"
+    },
+    number: {
+        type: "number"
+    },
+    object: {
+        type: "object"
+    },
+    view: {
+        type: "view"
+    },
+    display: {
+        type: "display"
+    },
+    function: {
+        type: "function"
+    },
+    null: {
+        type: "null"
+    },
+    unknown: {
+        type: "null"
+    },
+    any: {},
+};
+export const CommonMakers = {
+    enums(base, ...values) {
+        return { ...base, enum: values };
+    },
+    array(base) {
+        return { type: "array", items: base };
+    },
+    record(fields) {
+        return { type: "object", properties: fields };
+    },
+    collection(items) {
+        return { type: "object", additionalProperties: items };
+    },
+    event_fn(event) {
+        return { type: "function", args: [event || CommonTypes.any] };
+    },
+};
+export const ErrorTypes = {
+    invalid: {
+        $error: "Cannot determine the type"
+    }
+};
+function getPropertyTyping(propertyName, schema) {
+    if (!schema)
+        return ErrorTypes.invalid;
+    // Search as standard property
+    let typing = schema.properties?.[propertyName];
+    if (typing)
+        return typing;
+    // Search as pattern property
+    const { patternProperties } = schema;
+    for (const pattern in patternProperties) {
+        if (propertyName.match(pattern)) {
+            return patternProperties[pattern];
+        }
+    }
+    // Check error
+    if (schema["$error"]) {
+        return ErrorTypes.invalid;
+    }
+    return schema.additionalProperties || CommonTypes.any;
+}
+function getItemTyping(index, schema) {
+    if (!schema)
+        return ErrorTypes.invalid;
+    // Search as standard property
+    if (Array.isArray(schema.items)) {
+        return schema.items?.[index] || ErrorTypes.invalid;
+    }
+    else if (schema.items) {
+        return schema.items;
+    }
+    else if (schema.type === "element") {
+        return schema;
+    }
+    // Check error
+    if (schema["$error"]) {
+        return ErrorTypes.invalid;
+    }
+    return schema.additionalProperties || CommonTypes.any;
+}
+function getValueTyping(value) {
+    switch (typeof value) {
+        case "undefined":
+            return CommonTypes.null;
+        case "boolean":
+            return CommonTypes.boolean;
+        case "symbol":
+        case "string":
+            return CommonTypes.string;
+        case "bigint":
+        case "number":
+            return CommonTypes.number;
+        case "function":
+            return CommonTypes.function;
+        case "object": {
+            if (Array.isArray(value)) {
+                return {
+                    type: "array",
+                    items: value.map(getValueTyping)
+                };
+            }
+            else if (value !== null) {
+                const properties = {};
+                for (const key in properties) {
+                    properties[key] = getValueTyping(properties[key]);
+                }
+                return {
+                    type: "array",
+                    properties,
+                };
+            }
+            return CommonTypes.null;
+        }
+        default:
+            return ErrorTypes.invalid;
+    }
+}
+function isType(typing, kind) {
+    const { type } = typing;
+    return Array.isArray(type) ? type.includes(kind) : type === kind;
+}
+function typeAsString(type) {
+    return Array.isArray(type) ? type.join(',') : type;
+}
+function generateTypescript(schema) {
+    if (schema.type === "object") {
+        const ln = [];
+        for (const key in schema.properties) {
+            ln.push(`${key}: ${generateTypescript(schema.properties[key])}`);
+        }
+        for (const key in schema.additionalProperties) {
+            ln.push(`${key}?: ${generateTypescript(schema.additionalProperties[key])}`);
+        }
+        for (const key in schema.patternProperties) {
+            ln.push(`[${key}: ${generateTypescript(schema.patternProperties[key])}]`);
+        }
+        return ln.join("\n");
+    }
+    else if (schema.type) {
+        return schema.type;
+    }
+    return "any";
+}
+export const Schema = {
+    getPropertyTyping,
+    getItemTyping,
+    getValueTyping,
+    isType,
+    typeAsString,
+    generateTypescript,
+};

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

@@ -0,0 +1,3 @@
+export * from "./helpers.ts";
+export * from "./schema.ts";
+export * from "./zod.ts";

package/esm/core/schema/mod.js

@@ -0,0 +1,3 @@
+export * from "./helpers.js";
+export * from "./schema.js";
+export * from "./zod.js";