@pb33f/cowboy-components 0.7.18 → 0.8.0

package/dist/services/diagramatron-service.d.ts

@@ -0,0 +1,20 @@
+export interface DiagramatronRequest {
+    id: string;
+}
+export interface DiagramatronResponse {
+    diagram: string;
+    format: string;
+    metadata?: {
+        generatedAt?: string;
+        nodeCount?: number;
+        relationshipCount?: number;
+    };
+}
+export declare class DiagramatronService {
+    private static instance;
+    private endpoint;
+    private constructor();
+    static getInstance(): DiagramatronService;
+    setEndpoint(endpoint: string): void;
+    generateClassDiagram(id: string, brokerId?: string): Promise<DiagramatronResponse>;
+}

package/dist/services/diagramatron-service.js

@@ -0,0 +1,48 @@
+// Copyright 2023-2025 Princess Beef Heavy Industries, LLC / Dave Shanley
+// https://pb33f.io
+import { HeaderService } from './header-service.js';
+export class DiagramatronService {
+    constructor() {
+        this.endpoint = '';
+    }
+    static getInstance() {
+        if (!DiagramatronService.instance) {
+            DiagramatronService.instance = new DiagramatronService();
+        }
+        return DiagramatronService.instance;
+    }
+    setEndpoint(endpoint) {
+        this.endpoint = endpoint;
+    }
+    async generateClassDiagram(id, brokerId) {
+        if (!this.endpoint) {
+            throw new Error('Diagramatron endpoint not configured');
+        }
+        const encodedId = encodeURIComponent(id);
+        const url = `${this.endpoint}/model/diagramatron/mermaid/class?id=${encodedId}`;
+        const headers = HeaderService.buildDefaultHeaders(brokerId);
+        const response = await fetch(url, {
+            method: 'GET',
+            credentials: 'include',
+            headers: headers
+        });
+        if (!response.ok) {
+            if (response.status === 402) {
+                const error = await response.json();
+                throw error;
+            }
+            throw new Error(`Failed to generate diagram: ${response.statusText}`);
+        }
+        const diagramText = await response.text();
+        const data = {
+            diagram: diagramText,
+            format: 'mermaid',
+            metadata: {
+                generatedAt: new Date().toISOString(),
+                nodeCount: 0,
+                relationshipCount: 0
+            }
+        };
+        return data;
+    }
+}

package/dist/services/doctor-events.d.ts

@@ -0,0 +1,58 @@
+import { Bus, Channel, Subscription } from "@pb33f/ranch";
+import { Problem } from "../model/problem.js";
+import { DocumentStatistics } from "../model/document-statistics.js";
+import { GraphResponse } from "../model/graph.js";
+export interface LintCompletedPayload {
+    problems: Problem[];
+    statistics: DocumentStatistics;
+    currentPath: string;
+}
+export interface GraphUpdatedPayload {
+    graph: GraphResponse;
+}
+export interface NodeSelectedPayload {
+    nodeId: string;
+    nodeHashId: string;
+    path: string;
+    source: 'tree' | 'explorer' | 'editor' | 'rolodex';
+}
+export interface ProblemsUpdatedPayload {
+    problems: Problem[];
+    source: 'lint' | 'timeline' | 'filter';
+}
+export interface RulesetChangedPayload {
+    rulesetId: string;
+    rulesetType: 'builtin' | 'custom';
+    triggerLint: boolean;
+}
+export interface RolodexFilePayload {
+    path: string;
+    nodeHashId: string;
+    content?: string;
+}
+export interface EditorDirtyPayload {
+    dirty: boolean;
+    editorId: string;
+}
+export interface ActivityStatePayload {
+    active: boolean;
+    source: string;
+}
+export declare class TypedChannel<T> {
+    private readonly channel;
+    constructor(channel: Channel);
+    get name(): string;
+    publish(payload: T): void;
+    subscribe(callback: (payload: T) => void): Subscription;
+}
+export interface DoctorEventChannels {
+    readonly lintCompleted: TypedChannel<LintCompletedPayload>;
+    readonly graphUpdated: TypedChannel<GraphUpdatedPayload>;
+    readonly nodeSelected: TypedChannel<NodeSelectedPayload>;
+    readonly problemsUpdated: TypedChannel<ProblemsUpdatedPayload>;
+    readonly rulesetChanged: TypedChannel<RulesetChangedPayload>;
+    readonly rolodexFileSelected: TypedChannel<RolodexFilePayload>;
+    readonly editorDirty: TypedChannel<EditorDirtyPayload>;
+    readonly activityState: TypedChannel<ActivityStatePayload>;
+}
+export declare function createDoctorEventChannels(bus: Bus): DoctorEventChannels;

package/dist/services/doctor-events.js

@@ -0,0 +1,33 @@
+export class TypedChannel {
+    constructor(channel) {
+        this.channel = channel;
+    }
+    get name() {
+        return this.channel.name;
+    }
+    publish(payload) {
+        this.channel.publish({ payload });
+    }
+    subscribe(callback) {
+        return this.channel.subscribe((msg) => {
+            if (msg.payload !== undefined) {
+                callback(msg.payload);
+            }
+        });
+    }
+}
+function createChannel(bus, name) {
+    return new TypedChannel(bus.createChannel(`doctor:${name}`));
+}
+export function createDoctorEventChannels(bus) {
+    return {
+        lintCompleted: createChannel(bus, 'lint-completed'),
+        graphUpdated: createChannel(bus, 'graph-updated'),
+        nodeSelected: createChannel(bus, 'node-selected'),
+        problemsUpdated: createChannel(bus, 'problems-updated'),
+        rulesetChanged: createChannel(bus, 'ruleset-changed'),
+        rolodexFileSelected: createChannel(bus, 'rolodex-file-selected'),
+        editorDirty: createChannel(bus, 'editor-dirty'),
+        activityState: createChannel(bus, 'activity-state'),
+    };
+}

package/dist/services/drawer-content-registry.d.ts

@@ -0,0 +1,9 @@
+import { DrawerContentHandler, DrawerEvent } from '../model/drawer-content.js';
+export declare class DrawerContentRegistry {
+    private static instance;
+    private handlers;
+    private constructor();
+    static getInstance(): DrawerContentRegistry;
+    registerHandler(handler: DrawerContentHandler): void;
+    getHandler(event: DrawerEvent): DrawerContentHandler | undefined;
+}

package/dist/services/drawer-content-registry.js

@@ -0,0 +1,37 @@
+// Copyright 2023-2025 Princess Beef Heavy Industries, LLC / Dave Shanley
+// https://pb33f.io
+export class DrawerContentRegistry {
+    constructor() {
+        this.handlers = new Map();
+    }
+    static getInstance() {
+        if (!DrawerContentRegistry.instance) {
+            DrawerContentRegistry.instance = new DrawerContentRegistry();
+        }
+        return DrawerContentRegistry.instance;
+    }
+    registerHandler(handler) {
+        handler.supportedTypes.forEach(type => {
+            this.handlers.set(type, handler);
+        });
+        if (handler.initialize) {
+            handler.initialize();
+        }
+    }
+    getHandler(event) {
+        const handler = this.handlers.get(event.type);
+        if (handler?.canHandle(event)) {
+            return handler;
+        }
+        const checkedHandlers = new Set();
+        for (const h of this.handlers.values()) {
+            if (!checkedHandlers.has(h)) {
+                checkedHandlers.add(h);
+                if (h.canHandle(event)) {
+                    return h;
+                }
+            }
+        }
+        return undefined;
+    }
+}

package/dist/services/github-service.d.ts

@@ -0,0 +1,9 @@
+import { APIResponse } from "../model/api-response";
+import { GitHubClaimResponse, GitHubAttachResponse } from "../model/github";
+export declare class GitHubService {
+    static doctorEndpoint: string;
+    static getInstallations(brokerId?: string): Promise<APIResponse<any>>;
+    static getRepositories(brokerId?: string, refresh?: boolean): Promise<APIResponse<any>>;
+    static claimRepository(installationId: number, brokerId?: string): Promise<GitHubClaimResponse>;
+    static attachRepository(repositoryId: string, branch: string, rootFile: string, brokerId?: string): Promise<GitHubAttachResponse>;
+}

package/dist/services/github-service.js

@@ -0,0 +1,166 @@
+import { HeaderService } from "./header-service";
+export class GitHubService {
+    static async getInstallations(brokerId) {
+        return new Promise(async (resolve, reject) => {
+            try {
+                const headers = HeaderService.buildDefaultHeaders(brokerId);
+                const response = await fetch(GitHubService.doctorEndpoint + '/github/installations', {
+                    method: 'GET',
+                    credentials: 'include',
+                    headers: headers,
+                });
+                if (!response.ok) {
+                    try {
+                        const errorResult = await response.json();
+                        reject(errorResult);
+                    }
+                    catch {
+                        reject({ detail: `HTTP ${response.status}: ${response.statusText}` });
+                    }
+                    return;
+                }
+                if (response.status === 204) {
+                    resolve({ response: [] });
+                    return;
+                }
+                const apiResult = await response.json();
+                if (!apiResult) {
+                    reject({ detail: 'unable to fetch GitHub installations, cannot decode JSON' });
+                    return;
+                }
+                if (apiResult?.type && apiResult?.title && apiResult?.status) {
+                    reject(apiResult);
+                    return;
+                }
+                apiResult.httpStatus = response.status;
+                resolve(apiResult);
+            }
+            catch (e) {
+                reject({ detail: 'unable to fetch GitHub installations: ' + e });
+            }
+        });
+    }
+    static async getRepositories(brokerId, refresh = false) {
+        return new Promise(async (resolve, reject) => {
+            try {
+                const headers = HeaderService.buildDefaultHeaders(brokerId);
+                let refreshQuery = '';
+                if (refresh) {
+                    refreshQuery = '?refresh';
+                }
+                const response = await fetch(GitHubService.doctorEndpoint + '/github/repositories' + refreshQuery, {
+                    method: 'GET',
+                    credentials: 'include',
+                    headers: headers,
+                });
+                if (!response.ok) {
+                    try {
+                        const errorResult = await response.json();
+                        reject(errorResult);
+                    }
+                    catch {
+                        reject({ detail: `HTTP ${response.status}: ${response.statusText}` });
+                    }
+                    return;
+                }
+                if (response.status === 204) {
+                    resolve({ response: [] });
+                    return;
+                }
+                const apiResult = await response.json();
+                if (!apiResult) {
+                    reject({ detail: 'unable to fetch GitHub repositories, cannot decode JSON' });
+                    return;
+                }
+                if (apiResult?.type && apiResult?.title && apiResult?.status) {
+                    reject(apiResult);
+                    return;
+                }
+                apiResult.httpStatus = response.status;
+                resolve(apiResult);
+            }
+            catch (e) {
+                reject({ detail: 'unable to fetch GitHub repositories: ' + e });
+            }
+        });
+    }
+    static async claimRepository(installationId, brokerId) {
+        return new Promise(async (resolve, reject) => {
+            try {
+                const headers = HeaderService.buildDefaultHeaders(brokerId);
+                const request = { installationId };
+                const response = await fetch(GitHubService.doctorEndpoint + '/github/claim', {
+                    method: 'POST',
+                    credentials: 'include',
+                    headers: headers,
+                    body: JSON.stringify(request)
+                });
+                if (!response.ok) {
+                    try {
+                        const errorResult = await response.json();
+                        reject(errorResult);
+                    }
+                    catch {
+                        reject({ detail: `HTTP ${response.status}: ${response.statusText}` });
+                    }
+                    return;
+                }
+                const apiResult = await response.json();
+                if (!apiResult) {
+                    reject({ detail: 'unable to claim repository, cannot decode JSON' });
+                    return;
+                }
+                if (apiResult?.type && apiResult?.title && apiResult?.status) {
+                    reject(apiResult);
+                    return;
+                }
+                resolve(apiResult);
+            }
+            catch (e) {
+                reject({ detail: 'unable to claim repository: ' + e });
+            }
+        });
+    }
+    static async attachRepository(repositoryId, branch, rootFile, brokerId) {
+        return new Promise(async (resolve, reject) => {
+            try {
+                const headers = HeaderService.buildDefaultHeaders(brokerId);
+                const request = {
+                    repositoryId,
+                    branch,
+                    rootFile
+                };
+                const response = await fetch(GitHubService.doctorEndpoint + '/github/repository/attach?switchWorkspace', {
+                    method: 'POST',
+                    credentials: 'include',
+                    headers: headers,
+                    body: JSON.stringify(request)
+                });
+                if (!response.ok) {
+                    try {
+                        const errorResult = await response.json();
+                        reject(errorResult);
+                    }
+                    catch {
+                        reject({ detail: `HTTP ${response.status}: ${response.statusText}` });
+                    }
+                    return;
+                }
+                const apiResult = await response.json();
+                if (!apiResult) {
+                    reject({ detail: 'unable to attach repository, cannot decode JSON' });
+                    return;
+                }
+                if (apiResult?.type && apiResult?.title && apiResult?.status) {
+                    reject(apiResult);
+                    return;
+                }
+                resolve(apiResult);
+            }
+            catch (e) {
+                reject({ detail: 'unable to attach repository: ' + e });
+            }
+        });
+    }
+}
+GitHubService.doctorEndpoint = 'https://doctor.pb33f.io';

package/dist/services/global-task-service.d.ts

@@ -0,0 +1,6 @@
+import { TaskListResponse } from "../model/task";
+import { APIResponse } from "../model/api-response";
+export declare class GlobalTaskService {
+    static doctorEndpoint: string;
+    static getActiveTasks(brokerId?: string): Promise<APIResponse<TaskListResponse>>;
+}

package/dist/services/global-task-service.js

@@ -0,0 +1,27 @@
+import { HeaderService } from "./header-service";
+export class GlobalTaskService {
+    static async getActiveTasks(brokerId) {
+        try {
+            const response = await fetch(GlobalTaskService.doctorEndpoint + '/global-tasks', {
+                method: 'GET',
+                credentials: 'include',
+                headers: HeaderService.buildDefaultHeaders(brokerId),
+            });
+            const apiResult = await response.json();
+            if (!apiResult) {
+                throw { detail: 'unable to fetch active tasks, cannot decode JSON' };
+            }
+            if (apiResult?.type && apiResult?.title && apiResult?.status) {
+                throw apiResult;
+            }
+            return apiResult;
+        }
+        catch (e) {
+            if (e?.detail) {
+                throw e;
+            }
+            throw { detail: 'unable to fetch active tasks: ' + e };
+        }
+    }
+}
+GlobalTaskService.doctorEndpoint = 'https://doctor.pb33f.io';

package/dist/services/header-service.d.ts

@@ -1,5 +1,7 @@
 export declare class HeaderService {
-    static buildDefaultHeaders(broker?: any): any;
-    static addBrokerHeader(headers: any, broker?: string): any;
-    static addJSONHeader(headers: any): any;
+    static getOrCreateClientId(): string;
+    static buildDefaultHeaders(broker?: string): Record<string, string>;
+    static addBrokerHeader(headers: Record<string, string>, broker?: string): void;
+    static addClientHeader(headers: Record<string, string>): void;
+    static addJSONHeader(headers: Record<string, string>): void;
 }

package/dist/services/header-service.js

@@ -1,7 +1,17 @@
+const CLIENT_ID_STORAGE_KEY = 'pb33f_client_id';
 export class HeaderService {
+    static getOrCreateClientId() {
+        let clientId = sessionStorage.getItem(CLIENT_ID_STORAGE_KEY);
+        if (!clientId) {
+            clientId = crypto.randomUUID();
+            sessionStorage.setItem(CLIENT_ID_STORAGE_KEY, clientId);
+        }
+        return clientId;
+    }
     static buildDefaultHeaders(broker) {
         const headers = {};
         HeaderService.addBrokerHeader(headers, broker);
+        HeaderService.addClientHeader(headers);
         HeaderService.addJSONHeader(headers);
         return headers;
     }
@@ -13,6 +23,9 @@ export class HeaderService {
             console.warn('unable to add broker header, broker is missing');
         }
     }
+    static addClientHeader(headers) {
+        headers['x-pb33f-client'] = HeaderService.getOrCreateClientId();
+    }
     static addJSONHeader(headers) {
         headers['Content-Type'] = 'application/json';
     }

package/dist/services/linting-service.d.ts

@@ -8,4 +8,6 @@ export declare class LintingService {
     static fetchAllHowToFix(): Promise<HowToFix[]>;
     static fetchStatistics(): Promise<DrDiagnostics>;
     static bootstrapEditor(): Promise<string>;
+    static refreshViolations(brokerId?: string, currentPath?: string, skipTimeline?: boolean): Promise<Problem[]>;
+    static refreshStatistics(): Promise<DrDiagnostics>;
 }

package/dist/services/linting-service.js

@@ -1,6 +1,6 @@
 import { Problem } from "../model/problem.js";
-import { HeaderService } from "./header-service";
-import { AuthController } from "../controllers/auth-controller";
+import { HeaderService } from "./header-service.js";
+import { AuthController } from "../controllers/auth-controller.js";
 export class LintingService {
     static compareProblems(a, b) {
         if (a.startLineNumber < b.startLineNumber) {
@@ -152,5 +152,22 @@ export class LintingService {
             }
         });
     }
+    static async refreshViolations(brokerId, currentPath, skipTimeline) {
+        const specResponse = await fetch(LintingService.doctorEndpoint + '/model/current-spec', {
+            method: 'GET',
+            credentials: 'include',
+            headers: {
+                'Content-Type': 'application/json'
+            },
+        });
+        if (!specResponse.ok) {
+            throw { detail: 'unable to fetch current spec for re-linting' };
+        }
+        const currentSpec = await specResponse.text();
+        return LintingService.lintFile(currentSpec, brokerId, undefined, currentPath, skipTimeline);
+    }
+    static async refreshStatistics() {
+        return LintingService.fetchStatistics();
+    }
 }
 LintingService.doctorEndpoint = 'https://doctor.pb33f.io';

package/dist/services/mermaid-config-service.d.ts

@@ -0,0 +1,53 @@
+import { MermaidConfig } from 'mermaid';
+export interface MermaidThemeConfig {
+    primaryColor: string;
+    primaryTextColor: string;
+    primaryBorderColor: string;
+    lineColor: string;
+    secondaryColor: string;
+    tertiaryColor: string;
+    background: string;
+    fontFamily: string;
+    fontSize: string;
+    darkMode: boolean;
+    [key: string]: any;
+}
+export interface MermaidLayoutOptions {
+    layout: 'dagre-d3' | 'dagre-wrapper' | 'elk';
+    rankDir?: 'TB' | 'BT' | 'LR' | 'RL';
+    nodeSpacing?: number;
+    rankSpacing?: number;
+    curve?: 'basis' | 'linear' | 'cardinal' | 'monotoneX' | 'monotoneY' | 'natural' | 'step' | 'stepBefore' | 'stepAfter';
+}
+export declare class MermaidConfigService {
+    private static instance;
+    private currentTheme;
+    private customThemeVariables;
+    private layoutOptions;
+    private colorCache;
+    private cacheValid;
+    private themeObserver;
+    private static readonly CSS_VARS;
+    private static readonly RGBA_REGEX;
+    private constructor();
+    private extractCSSColor;
+    private parseColorValue;
+    private rgbaToHex;
+    private invalidateCache;
+    private extractCSSValue;
+    static getInstance(): MermaidConfigService;
+    private detectTheme;
+    private observeThemeChanges;
+    cleanup(): void;
+    getTheme(): 'light' | 'dark';
+    setCustomThemeVariables(variables: Partial<MermaidThemeConfig>): void;
+    getThemeVariables(): MermaidThemeConfig;
+    private getDarkThemeVariables;
+    private getLightThemeVariables;
+    setLayoutOptions(options: Partial<MermaidLayoutOptions>): void;
+    getLayoutOptions(): MermaidLayoutOptions;
+    getMermaidConfig(overrides?: Partial<MermaidConfig>): MermaidConfig;
+    getClassDiagramConfig(): Partial<MermaidConfig>;
+    getFlowchartConfig(): Partial<MermaidConfig>;
+    getSequenceDiagramConfig(): Partial<MermaidConfig>;
+}