@pb33f/cowboy-components 0.7.4 → 0.7.6

package/dist/controllers/diagnostic-controller.js

@@ -0,0 +1,262 @@
+import { DiagnosticBag, DocumentProblems, SettingsBag } from "../components/the-doctor/the-doctor.js";
+import { LintingService } from "../services/linting-service.js";
+import { ModelService } from "../services/model-service.js";
+import { ToastType } from "../model/toast.js";
+export class DiagnosticController extends EventTarget {
+    constructor(doc) {
+        super();
+        this.doc = doc;
+    }
+    lintSpec(value, url) {
+        this.doc.activitySpinner.show();
+        this.doc.editor.breadcumb.isInvalid = false;
+        if (url) {
+            if (url === 'root') {
+                url = '';
+            }
+            else {
+                this.doc.urlProblem.style.display = 'none';
+                this.doc.urlOverlay.style.display = "block";
+                this.doc.urlSpinner.style.display = "block";
+                this.doc.referenceMapBag?.reset(); // wipe out refs.
+            }
+        }
+        else {
+            this.doc.urlProblem.style.display = 'none';
+            this.doc.urlOverlay.style.display = "none";
+            this.doc.urlSpinner.style.display = "none";
+        }
+        let replaceResults = false;
+        let currentPath = this.doc.rolodexActivePath;
+        if (this.doc.rolodexActivePath === this.doc.rolodexRootPath || this.doc.rolodexActivePath === 'root') {
+            replaceResults = true;
+            currentPath = '';
+            this.doc.editor.showBreadcrumb = false;
+        }
+        if (url && url != '') {
+            try {
+                const parsedUrl = new URL(url);
+                if (parsedUrl) {
+                    currentPath = parsedUrl.pathname;
+                    this.doc.rolodexActivePath = currentPath;
+                    this.doc.rolodexRootPath = currentPath;
+                    replaceResults = true;
+                }
+            }
+            catch (e) {
+                // do nothing for now.
+            }
+        }
+        let revive = true;
+        LintingService.lintFile(value, this.doc.brokerController.brokerConnectionId, url, currentPath, this.doc.skipTimeline).then((result) => {
+            //if (replaceResults) {
+            this.doc.activitySpinner.hide();
+            const map = this.doc.rolodexController.buildRolodexResultMap(result);
+            if (url) {
+                this.doc.urlOverlay.style.display = "none";
+                this.doc.urlSpinner.style.display = "none";
+                this.doc.urlProblem.style.display = 'none';
+            }
+            // extract empty location problems as we are replacing the root results
+            let rootProblems = this.doc.rolodexProblemMap.get("root");
+            if (!this.doc.rolodexRoot) {
+                rootProblems = [];
+            }
+            if (result && !Array.isArray(result)) {
+                const r = [result];
+                if (this.doc.rolodexProblemMap.size > 0 && this.doc.rolodexProblemMap.has(this.doc.rolodexActivePath)) {
+                    const probs = this.doc.rolodexProblemMap.get(this.doc.rolodexActivePath);
+                    if (probs) {
+                        if (rootProblems) {
+                            probs.push(...rootProblems);
+                        }
+                        this.doc.editor.setMarkers(probs);
+                    }
+                    else {
+                        if (rootProblems) {
+                            r.push(...rootProblems);
+                        }
+                        this.doc.editor.setMarkers(r);
+                    }
+                }
+                else {
+                    if (rootProblems) {
+                        r.push(...rootProblems);
+                    }
+                    this.doc.editor.setMarkers(r);
+                }
+                this.doc.problemBag?.set(DocumentProblems, r);
+                this.doc.problemList.problems = r;
+                this.doc.problems = r;
+                this.doc.problemsOverview.problems = this.doc.problemList.problemItems;
+            }
+            if (result && Array.isArray(result)) {
+                if (result.length == 0) {
+                    this.doc.editor.clearAllMarkers();
+                    this.doc.editor.breadcumb.isInvalid = false;
+                    this.doc.editor.showBreadcrumb = false;
+                    revive = true;
+                    this.doc.problemList.isInvalid = false;
+                }
+                // check if this problem is 'unable to parse'
+                if (result.length == 1 && result[0].message.startsWith('unable to parse')) {
+                    // short circuit, we are dead.
+                    this.doc.editor.clearDecorations();
+                    this.doc.editor.clearAllMarkers();
+                    this.doc.editor.setMarkers(result);
+                    this.doc.editor.breadcumb.isInvalid = true;
+                    this.doc.editor.showBreadcrumb = true;
+                    this.doc.editor.dead();
+                    this.doc.problemList.isInvalid = true;
+                    revive = false;
+                }
+                // extract empty location problems as we are replacing the root results
+                if (revive && this.doc.rolodexProblemMap.size > 0 && this.doc.rolodexProblemMap.has(this.doc.rolodexActivePath)) {
+                    const probs = this.doc.rolodexProblemMap.get(this.doc.rolodexActivePath);
+                    if (probs) {
+                        if (rootProblems) {
+                            probs.push(...rootProblems);
+                        }
+                        this.doc.editor.setMarkers(probs);
+                    }
+                    else {
+                        if (rootProblems) {
+                            result.push(...rootProblems);
+                        }
+                        this.doc.editor.setMarkers(result);
+                    }
+                }
+                else {
+                    if (replaceResults) {
+                        this.doc.editor.setMarkers(result);
+                    }
+                    else {
+                        this.doc.modelController.fetchRefMap(currentPath);
+                        if ((this.doc.rolodexRootPath == this.doc.rolodexActivePath || this.doc.rolodexActivePath == 'root') || url || currentPath != '') {
+                            ModelService.fetchLatestGraph().then((result) => {
+                                this.doc.modelController.extractGraph(result);
+                                this.doc.timeVortex.checkHistory();
+                            });
+                        }
+                        return;
+                    }
+                }
+                this.doc.problemBag?.set(DocumentProblems, result);
+                this.doc.problemList.problems = result;
+                this.doc.problems = result;
+                this.doc.problemsOverview.problems = this.doc.problemList.problemItems;
+                if (this.doc.problemsOverview.statistics) {
+                    if (result.length == 1) {
+                        this.doc.problemsOverview.statistics.statistics.totalErrors = 1;
+                        this.doc.problemsOverview.statistics.statistics.overallScore = 0;
+                        this.doc.problemsOverview.statistics.evaluation = 'Useless';
+                        this.doc.problemsOverview.statistics.diagnosis = '<strong>Specification cannot be used</strong>: <br/><br/>' + result[0].message;
+                    }
+                }
+            }
+            // enable pb33f theme.
+            if (revive) {
+                this.doc.editor.revive();
+            }
+            else {
+                return;
+            }
+            // fetch graph
+            if ((this.doc.rolodexRootPath == this.doc.rolodexActivePath || this.doc.rolodexActivePath == 'root') || url || currentPath != '') {
+                ModelService.fetchLatestGraph().then((result) => {
+                    this.doc.modelController.extractGraph(result);
+                    this.doc.timeVortex.checkHistory();
+                });
+            }
+            if (this.doc.rolodexNeedsReset) {
+                this.doc.rolodexController.queryRolodex(currentPath);
+            }
+            else {
+                this.doc.modelController.fetchRefMap(currentPath);
+                //this.timeVortex.tardisControl.fetchHistory()
+            }
+            // update the overview statistics
+            LintingService.fetchStatistics().then((result) => {
+                let oldScore = 0;
+                if (this.doc.problemsOverview.statistics) {
+                    oldScore = this.doc.problemsOverview.statistics.statistics.overallScore;
+                }
+                this.doc.diagnosticBag?.set(DiagnosticBag, result);
+                this.doc.activitySpinner.hide();
+                if (result?.remainingCredit <= 10) {
+                    this.doc.statusBar.callsRemaining = result.remainingCredit;
+                    this.doc.statusBar.visible = true;
+                    console.warn("You are running low on credit, you will need to authenticate soon. " +
+                        "" + result.remainingCredit + " credits remaining.");
+                }
+                // determine if the score went up or down and toast it!
+                this.doc.problemsOverview.statistics = result;
+                const settings = this.doc.settingsBag?.get(SettingsBag);
+                // only toast if we're NOT using auto diagnose, otherwise they are a pain in the ass.
+                if (!settings?.autoDiagnose) {
+                    if (this.doc.problemsOverview.statistics) {
+                        const newScore = result.statistics.overallScore;
+                        if (oldScore > newScore) {
+                            this.doc.sendToast({
+                                id: crypto.randomUUID(),
+                                type: ToastType.SCOREDOWN,
+                                body: "Your score has decreased. It is now " + newScore + "%",
+                                title: "Score went down by " + (oldScore - newScore) + "%"
+                            });
+                        }
+                        if (oldScore < newScore) {
+                            this.doc.sendToast({
+                                id: crypto.randomUUID(),
+                                type: ToastType.SCOREUP,
+                                body: "Your score has increased to " + newScore + "%",
+                                title: "Score went up by " + (newScore - oldScore) + "%"
+                            });
+                        }
+                    }
+                }
+            }).catch((e) => {
+                console.error("statistics service is down", e);
+                this.doc.sendToast({
+                    id: crypto.randomUUID(),
+                    type: ToastType.ERROR,
+                    body: e.detail,
+                    title: "Statistics request failed"
+                });
+            });
+            if (!this.doc.explorerBooted) {
+                this.doc.explorer.equalizer.initializeEqualizer();
+                this.doc.explorerBooted = true;
+            }
+        }).catch((e) => {
+            this.doc.activitySpinner.hide();
+            if (!url) {
+                //this.platformUnavailable(e);
+                console.error("so sorry, the doctor cannot see you right now, the clinic is closed.");
+                if (e) {
+                    console.error(e.detail);
+                    if (e.instance === 'https://pb33f.io/errors/no-credit-remaining') {
+                        this.doc.statusBar.callsRemaining = 0;
+                        this.doc.statusBar.visible = true;
+                        this.doc.sendToast({
+                            id: crypto.randomUUID(),
+                            type: ToastType.ERROR,
+                            body: "Run out of credit, please authenticate for more or wait 24 hours.",
+                            title: "Credit exhausted!",
+                        });
+                    }
+                    else {
+                        this.doc.sendToast({
+                            id: crypto.randomUUID(),
+                            type: ToastType.ERROR,
+                            body: e.detail,
+                            title: "Platform Error",
+                        });
+                    }
+                }
+            }
+            else {
+                this.doc.showUrlError(e);
+            }
+        });
+    }
+}

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

@@ -0,0 +1,8 @@
+import { TheDoctor } from "../components/the-doctor/the-doctor";
+import { ProblemDrawerEvent } from "../components/problem-list/details-drawer";
+export declare class DocsController extends EventTarget {
+    doc: TheDoctor;
+    constructor(doc: TheDoctor);
+    fetchDocs(): void;
+    ruleDocsClicked(event: CustomEvent<ProblemDrawerEvent>): void;
+}

package/dist/controllers/docs-controller.js

@@ -0,0 +1,143 @@
+import { DocumentationExpirationBag, FunctionDocumentationBag, RuleDocumentationBag } from "../components/the-doctor/the-doctor";
+import { LintingService } from "../services/linting-service";
+import { ProblemDrawerEventType } from "../components/problem-list/details-drawer";
+import { ToastType } from "../model/toast";
+export class DocsController extends EventTarget {
+    constructor(doc) {
+        super();
+        this.doc = doc;
+    }
+    fetchDocs() {
+        this.doc.activitySpinner.show();
+        const url = new URL(window.location.href);
+        const urlParam = url.searchParams.get('url');
+        if (urlParam) {
+            //this.urlInput.value = urlParam;
+            this.doc.activeURL = urlParam;
+            this.doc.diagnosticController.lintSpec('', urlParam);
+        }
+        LintingService.fetchAllHowToFix().then((result) => {
+            if (result) {
+                result.forEach((howToFix) => {
+                    this.doc.howToFixBag?.set(howToFix.ruleId, howToFix);
+                });
+            }
+        }).catch((e) => {
+            this.doc.platformUnavailable(e);
+            console.error("documentation service is down");
+        });
+        this.doc.ruleDocsBag = this.doc.bagManager.getBag(RuleDocumentationBag);
+        this.doc.functionDocsBag = this.doc.bagManager.getBag(FunctionDocumentationBag);
+        // populate docs via worker.
+        this.doc.ruleDocsWorker.addEventListener("message", (event) => {
+            const data = event.data;
+            if (data) {
+                data.forEach((doc) => {
+                    if (doc.ruleId) {
+                        this.doc.ruleDocsBag?.set(doc.ruleId, doc);
+                    }
+                    if (doc.functionId) {
+                        this.doc.functionDocsBag?.set(doc.functionId, doc);
+                    }
+                });
+                this.doc.activitySpinner.hide();
+            }
+        });
+        // let ruleDocs: string[] = [];
+        // let functionDocs: string[] = [];
+        // if (this.ruleDocsBag) {
+        //     ruleDocs = Array.from(this.ruleDocsBag.export().keys());
+        // }
+        // if (this.functionDocsBag) {
+        //     functionDocs = Array.from(this.functionDocsBag.export().keys());
+        // }
+        const fetchDocs = () => {
+            this.doc.ruleDocsWorker.postMessage({
+                start: true,
+                endpoint: this.doc.doctorEndpoint,
+                existingRules: [],
+                existingFunctions: []
+            });
+        };
+        // check expiration
+        if (this.doc.docExpirationBag) {
+            const expiration = this.doc.docExpirationBag.get(DocumentationExpirationBag);
+            // if the docs are older than 15 days, refresh them.
+            if (expiration) {
+                const now = new Date().getTime();
+                const then = new Date(expiration).getTime();
+                // if (now - then > 1296000000) {
+                //     fetchDocs();
+                // } else {
+                //     this.activitySpinner.hide();
+                // }
+                fetchDocs(); // always fetch for now.
+            }
+            else {
+                fetchDocs();
+            }
+        }
+        else {
+            fetchDocs();
+        }
+    }
+    ruleDocsClicked(event) {
+        const ruleId = event.detail.rule;
+        if (ruleId) {
+            switch (event.detail.type) {
+                case ProblemDrawerEventType.RULE_DOCS:
+                    const ruleDoc = this.doc.ruleDocsBag?.get(ruleId);
+                    if (ruleDoc) {
+                        event.detail.body = ruleDoc.body;
+                        this.doc.detailsDrawer.open(event.detail);
+                    }
+                    else {
+                        this.doc.sendToast({
+                            id: crypto.randomUUID(),
+                            type: ToastType.INFO,
+                            title: "Rule documentation unavailable",
+                            body: `Documentation for '${ruleId}' not available`
+                        });
+                    }
+                    break;
+                case ProblemDrawerEventType.HOW_TO_FIX:
+                    const howToFix = this.doc.howToFixBag?.get(ruleId);
+                    if (howToFix) {
+                        event.detail.body = howToFix.howToFix;
+                        this.doc.detailsDrawer.open(event.detail);
+                    }
+                    else {
+                        this.doc.sendToast({
+                            id: crypto.randomUUID(),
+                            type: ToastType.INFO,
+                            title: "How to fix unavailable",
+                            body: `Information on how to fix '${ruleId}' not available`
+                        });
+                    }
+                    break;
+                case ProblemDrawerEventType.FUNCTION_DOCS:
+                    const funcDocs = this.doc.functionDocsBag?.get(ruleId);
+                    if (funcDocs) {
+                        event.detail.body = funcDocs.body;
+                        this.doc.detailsDrawer.open(event.detail);
+                    }
+                    else {
+                        this.doc.sendToast({
+                            id: crypto.randomUUID(),
+                            type: ToastType.INFO,
+                            title: "Function documentation unavailable",
+                            body: `Documentation for '${ruleId}' not available`
+                        });
+                    }
+                    break;
+            }
+        }
+        else {
+            switch (event.detail.type) {
+                case ProblemDrawerEventType.RENDERED_EXAMPLE:
+                case ProblemDrawerEventType.MARKDOWN:
+                    this.doc.detailsDrawer.open(event.detail);
+            }
+        }
+    }
+}

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

@@ -0,0 +1,8 @@
+import { TheDoctor } from "../components/the-doctor/the-doctor.js";
+import { GraphResponse } from "../model/graph";
+export declare class ModelController extends EventTarget {
+    doc: TheDoctor;
+    constructor(doc: TheDoctor);
+    fetchRefMap(currentPath?: string): void;
+    extractGraph(graph: GraphResponse): void;
+}

package/dist/controllers/model-controller.js

@@ -0,0 +1,87 @@
+import { GraphBag } from "../components/the-doctor/the-doctor.js";
+import { ModelService } from "../services/model-service";
+import { ToastType } from "../model/toast";
+export class ModelController extends EventTarget {
+    constructor(doc) {
+        super();
+        this.doc = doc;
+    }
+    fetchRefMap(currentPath = '') {
+        ModelService.fetchReferenceMap(currentPath).then((result) => {
+            this.doc.editor.clearDecorations();
+            this.doc.references = result;
+            this.doc.editor.links = result;
+            this.doc.editor.applyLinkDecorations();
+            // add references to our stateful bag
+            this.doc.updateRefmapBag(currentPath, result);
+        }).catch((e) => {
+            console.error('an error occurred fetching the reference map', currentPath, e);
+            this.doc.editor.clearDecorations();
+            this.doc.editor.clearAllMarkers();
+            this.doc.toastManager.addToastManually({
+                id: crypto.randomUUID(),
+                type: ToastType.INFO,
+                title: "File not analyzed",
+                body: "Cannot extract the references from this file.",
+            });
+        });
+    }
+    extractGraph(graph) {
+        // handled stripped nodes
+        if (graph.stripped) {
+            this.doc.explorer.nodeLimitExceeded = true;
+            this.doc.modelTree.nodeLimitExceeded = true;
+            if (graph.strippedCount) {
+                this.doc.explorer.nodeLimit = graph.strippedCount;
+                this.doc.modelTree.nodeLimit = graph.strippedCount;
+            }
+        }
+        else {
+            this.doc.explorer.nodeLimitExceeded = false;
+            this.doc.modelTree.nodeLimitExceeded = false;
+        }
+        this.doc.explorer.renderedNodeMap.clear();
+        this.doc.nodeMap.clear();
+        this.doc.nodeIdMap.clear();
+        this.doc.nodeIdHashMap.clear();
+        const renderedNodes = new Map();
+        graph?.nodesRendered?.forEach((node) => {
+            this.doc.explorer.renderedNodeMap.set(node.id, node);
+            renderedNodes.set(node.id, node);
+        });
+        for (let i = 0; i < graph?.nodesRendered?.length; i++) {
+            this.doc.renderedNodeMap.set(graph.nodesRendered[i].id, graph.nodesRendered[i]);
+        }
+        graph?.nodes?.forEach((node) => {
+            this.doc.nodeMap.set(node.id, node);
+            if (node.idHash.includes('root')) {
+                this.doc.nodeIdMap.set('root', node);
+                this.doc.nodeIdHashMap.set(node.id, node);
+            }
+            else {
+                this.doc.nodeIdMap.set(node.id, node);
+                this.doc.nodeIdHashMap.set(node.idHash, node);
+            }
+            if (node.filtered) {
+                this.doc.filteredNodes.set(node.id, node);
+            }
+            const renderedNode = this.doc.renderedNodeMap.get(node.id);
+            if (this.doc.activeNode?.id === node.id && this.doc.renderedNodeMap.get(node.id)) {
+                if (this.doc.renderedNode && renderedNode) {
+                    this.doc.renderedNode.node = renderedNode;
+                }
+            }
+        });
+        this.doc.graphBag?.set(GraphBag, graph);
+        this.doc.explorer.updateGraphResponse(graph);
+        if (graph && graph.nodes) {
+            this.doc.modelTree.node = graph?.nodesRendered[0]; // update tree
+        }
+        if (!this.doc.explorer.equalizer.isInitialized()) {
+            this.doc.explorer.equalizer.initializeEqualizer();
+        }
+        else {
+            this.doc.explorer.equalizer.runEQ(true);
+        }
+    }
+}

package/dist/controllers/node-clicker-controller.d.ts

@@ -0,0 +1,11 @@
+import { TheDoctor } from "../components/the-doctor/the-doctor.js";
+import { DocumentReference, NodeClickedEvent, NodeReferenceEvent } from "../events/doctor.js";
+export declare class NodeClickerController extends EventTarget {
+    doc: TheDoctor;
+    constructor(doc: TheDoctor);
+    rolodexTreeNodeClicked(evt: CustomEvent<NodeClickedEvent>): void;
+    explorerNodeClicked(evt: CustomEvent<NodeClickedEvent>, replaceRenderedNode?: boolean): void;
+    modelTreeNodeClicked(evt: CustomEvent<NodeClickedEvent>): void;
+    explorerReferenceClicked(evt: CustomEvent<NodeReferenceEvent>): void;
+    documentReferenceClicked(evt: CustomEvent<DocumentReference>): void;
+}