@pb33f/cowboy-components 0.7.18 → 0.8.0

package/dist/controllers/bundle-controller.js

@@ -0,0 +1,122 @@
+import { ModelService } from "../services/model-service.js";
+import { ToastType } from "../model/toast.js";
+import { BundleCompleted } from "../events/doctor.js";
+export class BundleController extends EventTarget {
+    constructor(deps) {
+        super();
+        this._bundleResponse = null;
+        this._loading = false;
+        this._referenceMapIndex = null;
+        this.deps = deps;
+    }
+    get isBundled() {
+        return this._bundleResponse !== null;
+    }
+    get isLoading() {
+        return this._loading;
+    }
+    getBundledSpec() {
+        return this._bundleResponse?.bundledSpec ?? null;
+    }
+    getBundleResponse() {
+        return this._bundleResponse;
+    }
+    createToast(type, title, body) {
+        this.deps.sendToast({
+            id: crypto.randomUUID(),
+            type,
+            title,
+            body
+        });
+    }
+    async bundleSpec() {
+        if (this._loading)
+            return;
+        this._loading = true;
+        this.deps.requestUpdate();
+        try {
+            const result = await ModelService.bundleSpec(this.deps.getBrokerId());
+            this._bundleResponse = result;
+            this._referenceMapIndex = null;
+            this.createToast(ToastType.SUCCESS, 'Specification Bundled', result.cached ? 'Loaded bundled view from cache' : 'The model has been upgraded to a bundled view');
+            this.dispatchEvent(new CustomEvent(BundleCompleted, {
+                detail: {
+                    bundledSpec: result.bundledSpec,
+                    bundleId: result.bundleId,
+                    cached: result.cached
+                },
+                bubbles: true,
+                composed: true
+            }));
+        }
+        catch (e) {
+            const error = e;
+            this.createToast(ToastType.ERROR, 'Bundle Failed', `Failed to bundle specification: ${error.detail || 'Unknown error'}`);
+        }
+        finally {
+            this._loading = false;
+            this.deps.requestUpdate();
+        }
+    }
+    downloadBundledSpec() {
+        if (!this._bundleResponse?.bundledSpec)
+            return;
+        const originalFileName = this.deps.getOriginalFileName();
+        const baseName = originalFileName.replace(/\.(yaml|yml|json)$/, '') || 'openapi';
+        const filename = `${baseName}-bundled.yaml`;
+        const blob = new Blob([this._bundleResponse.bundledSpec], { type: 'text/yaml' });
+        const url = URL.createObjectURL(blob);
+        const link = document.createElement('a');
+        link.download = filename;
+        link.href = url;
+        link.click();
+        setTimeout(() => URL.revokeObjectURL(url), 500);
+        this.createToast(ToastType.SUCCESS, 'Download Started', `Downloading ${filename}`);
+    }
+    async copyToClipboard() {
+        if (!this._bundleResponse?.bundledSpec)
+            return;
+        try {
+            await navigator.clipboard.writeText(this._bundleResponse.bundledSpec);
+            this.createToast(ToastType.SUCCESS, 'Copied', 'Bundled spec copied to clipboard');
+        }
+        catch (e) {
+            this.createToast(ToastType.ERROR, 'Copy Failed', 'Failed to copy to clipboard');
+        }
+    }
+    reset() {
+        this._bundleResponse = null;
+        this._referenceMapIndex = null;
+        this.deps.requestUpdate();
+    }
+    buildReferenceMapIndex() {
+        this._referenceMapIndex = new Map();
+        if (!this._bundleResponse?.referenceMap)
+            return;
+        for (const mapping of this._bundleResponse.referenceMap) {
+            this._referenceMapIndex.set(mapping.bundledPath, mapping);
+        }
+    }
+    normalizeBracketNotation(path) {
+        return path.replace(/\['([^']+)'\]/g, '/$1');
+    }
+    findOriginalLocation(nodePath) {
+        if (!this._bundleResponse?.referenceMap)
+            return null;
+        if (!this._referenceMapIndex) {
+            this.buildReferenceMapIndex();
+        }
+        let current = nodePath.startsWith('#') ? nodePath : '#' + nodePath;
+        current = this.normalizeBracketNotation(current);
+        while (current.length > 1) {
+            const mapping = this._referenceMapIndex.get(current);
+            if (mapping)
+                return mapping;
+            const lastSlash = current.lastIndexOf('/');
+            if (lastSlash <= 0)
+                break;
+            current = current.substring(0, lastSlash);
+        }
+        return null;
+    }
+}

package/dist/controllers/countdown-controller.d.ts

@@ -0,0 +1,17 @@
+import { ReactiveController, ReactiveControllerHost } from 'lit';
+export declare class CountdownController implements ReactiveController {
+    host: ReactiveControllerHost;
+    private targetTime;
+    private intervalId;
+    private onExpired?;
+    private hasCalledExpired;
+    remainingMs: number;
+    isCritical: boolean;
+    isExpired: boolean;
+    constructor(host: ReactiveControllerHost, expiresAt: string, onExpired?: () => void);
+    hostConnected(): void;
+    hostDisconnected(): void;
+    stop(): void;
+    private updateRemaining;
+    get formattedTime(): string;
+}

package/dist/controllers/countdown-controller.js

@@ -0,0 +1,59 @@
+export class CountdownController {
+    constructor(host, expiresAt, onExpired) {
+        this.intervalId = null;
+        this.hasCalledExpired = false;
+        this.remainingMs = 0;
+        this.isCritical = false;
+        this.isExpired = false;
+        this.host = host;
+        this.targetTime = new Date(expiresAt);
+        this.onExpired = onExpired;
+        host.addController(this);
+        this.updateRemaining();
+    }
+    hostConnected() {
+        this.intervalId = window.setInterval(() => {
+            const previousFormatted = this.formattedTime;
+            const previousCritical = this.isCritical;
+            const previousExpired = this.isExpired;
+            this.updateRemaining();
+            if (previousFormatted !== this.formattedTime ||
+                previousCritical !== this.isCritical ||
+                previousExpired !== this.isExpired) {
+                this.host.requestUpdate();
+            }
+        }, 1000);
+    }
+    hostDisconnected() {
+        this.stop();
+    }
+    stop() {
+        if (this.intervalId !== null) {
+            clearInterval(this.intervalId);
+            this.intervalId = null;
+        }
+    }
+    updateRemaining() {
+        this.remainingMs = Math.max(0, this.targetTime.getTime() - Date.now());
+        const seconds = Math.floor(this.remainingMs / 1000);
+        this.isCritical = seconds > 0 && seconds < 60;
+        this.isExpired = seconds <= 0;
+        if (this.isExpired && this.onExpired && !this.hasCalledExpired) {
+            this.hasCalledExpired = true;
+            this.onExpired();
+        }
+    }
+    get formattedTime() {
+        const seconds = Math.floor(this.remainingMs / 1000);
+        if (this.isExpired || seconds <= 0)
+            return 'expired';
+        const minutes = Math.floor(seconds / 60);
+        if (minutes >= 2) {
+            return `${minutes} minutes left`;
+        }
+        if (minutes === 1) {
+            return 'about a minute left';
+        }
+        return `${seconds} second${seconds !== 1 ? 's' : ''} left`;
+    }
+}

package/dist/controllers/diagnostic-controller.d.ts

@@ -1,7 +1,20 @@
-import { TheDoctor } from "../components/the-doctor/the-doctor.js";
+import type { DiagnosticControllerDeps } from "../interfaces/doctor-interfaces.js";
 export declare class DiagnosticController extends EventTarget {
-    doc: TheDoctor;
-    oldScore: number;
-    constructor(doc: TheDoctor);
-    lintSpec(value: string, url?: string): void;
+    private readonly deps;
+    private oldScore;
+    constructor(deps: DiagnosticControllerDeps);
+    private createToast;
+    private getMaxNodes;
+    private prepareLintContext;
+    private mergeProblemsWithRoot;
+    private setMarkersWithRootProblems;
+    private handleSingleProblemResult;
+    private handleParseError;
+    private fetchGraphAndHistory;
+    private handlePostLintOperations;
+    private updateStatisticsAndNotify;
+    private initializeExplorerIfNeeded;
+    private handleLintError;
+    private handleArrayProblemResult;
+    lintSpec(value: string, url?: string): Promise<void>;
 }