@pb33f/cowboy-components 0.3.4 → 0.4.0

package/dist/css/hr.css.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("lit").CSSResult;
+export default _default;

package/dist/css/hr.css.js

@@ -0,0 +1,12 @@
+import { css } from "lit";
+export default css `
+    hr {
+        height: 1px;
+        border-bottom: none;
+        border-left: none;
+        border-right: none;
+        border-top: 1px dashed var(--secondary-color);
+        margin-bottom: 20px;
+        margin-top: 10px;
+    }
+`;

package/dist/css/pb33f-theme.css

@@ -72,6 +72,7 @@ html {
     --font-color-sub1: #a7a7a7;
     --font-color-sub2: #787878;
     --font-color-sub3: #585858;
+    --font-color-sub4: #2f2f2f;
     --secondary-color: #f83aff;
     --secondary-color-dimmer: rgba(248, 58, 255, 0.45);
     --secondary-color-text-shadow: rgba(250, 113, 251, 0.5);

package/dist/events/doctor.d.ts

@@ -30,6 +30,8 @@ export declare const AddToast: string;
 export declare const ToastExpired: string;
 export declare const MessageEvent: string;
 export declare const ModelTreeNodeClicked: string;
+export declare const RolodexTreeNodeClicked: string;
+export declare const RolodexRootFileSelected: string;
 export declare const ExplorerNodeClicked: string;
 export declare const NodeReferenceClicked: string;
 export declare const GenerateMockFromSchema: string;
@@ -44,6 +46,12 @@ export declare const ExplorerKeyClose: string;
 export declare const ExplorerEqualizerChanged: string;
 export declare const ExplorerEqualizerFiltered: string;
 export declare const ExplorerDependentNodeClicked: string;
+export declare const ArchiveURLRequested: string;
+export declare const DocumentReferenceClicked: string;
+export declare const NukeWorkspaceEvent: string;
+export interface ArchiveURLRequestedEvent {
+    url: string;
+}
 export interface ExplorerDependentNodeClickedEvent {
     node: Node;
     collapse: boolean;
@@ -54,13 +62,21 @@ export interface ExplorerEqualizerChangedEvent {
     references?: References;
     options?: Options;
 }
+export interface DocumentReference {
+    jsonPath: string;
+    noState?: boolean;
+}
 export interface NodeReferenceEvent {
     nodePath: string;
 }
 export interface NodeClickedEvent {
-    nodeHashId: string;
+    nodeHashId?: string;
     first?: boolean;
+    content?: string;
+    path?: string;
     noState?: boolean;
+    line?: number;
+    column?: number;
 }
 export interface ProblemLabelViewFilterChangedEvent {
     label: string;
@@ -81,6 +97,7 @@ export interface MainViewSlideChangedEvent {
 export interface EditorUpdatedEvent {
     content: string;
     id: string;
+    path?: string;
 }
 export interface CustomRulesetEnabledEvent {
     rules: RuleComponent[];
@@ -144,4 +161,5 @@ export interface HistoryState {
     page: number;
     view: ActiveView;
     activeNode: string;
+    ref: string;
 }

package/dist/events/doctor.js

@@ -24,6 +24,8 @@ export const AddToast = "addToast";
 export const ToastExpired = "toastExpired";
 export const MessageEvent = "message";
 export const ModelTreeNodeClicked = "modelTreeNodeClicked";
+export const RolodexTreeNodeClicked = "rolodexNodeClicked";
+export const RolodexRootFileSelected = "rolodexRootFileSelected";
 export const ExplorerNodeClicked = "explorerNodeClicked";
 export const NodeReferenceClicked = "nodeReferenceClicked";
 export const GenerateMockFromSchema = "generateMockFromSchema";
@@ -38,6 +40,9 @@ export const ExplorerKeyClose = "explorerKeyClose";
 export const ExplorerEqualizerChanged = "explorerEqualizerChanged";
 export const ExplorerEqualizerFiltered = "explorerEqualizerFiltered";
 export const ExplorerDependentNodeClicked = "explorerDependentNodeClicked";
+export const ArchiveURLRequested = "archiveURLRequested";
+export const DocumentReferenceClicked = "documentReferenceClicked";
+export const NukeWorkspaceEvent = "nukeWorkspace";
 export var ActiveView;
 (function (ActiveView) {
     ActiveView["Problems"] = "problems";

package/dist/model/channels.d.ts

@@ -1,5 +1,6 @@
 export declare const DoctorServiceChannel = "doctor-service";
 export declare const SpecStreamChannel = "spec-stream";
+export declare const CreditStreamChannel = "credit-stream";
 export declare const TopicPrefix = "/t/";
 export declare const QueuePrefix = "/q/";
 export declare function isBrokerResponse(obj: any): obj is BrokerResponse;

package/dist/model/channels.js

@@ -1,5 +1,6 @@
 export const DoctorServiceChannel = "doctor-service";
 export const SpecStreamChannel = "spec-stream";
+export const CreditStreamChannel = "credit-stream";
 export const TopicPrefix = "/t/";
 export const QueuePrefix = "/q/";
 export function isBrokerResponse(obj) {

package/dist/model/graph.d.ts

@@ -33,6 +33,9 @@ export interface Node {
     isPoly?: boolean;
     searchMatch?: string;
     searchKey?: string;
+    openapi?: boolean;
+    origin?: string;
+    path?: string;
 }
 export interface Edge {
     id: string;
@@ -71,6 +74,7 @@ export interface GraphResponse {
     };
     stripped?: boolean;
     strippedCount?: number;
+    rebuild?: boolean;
 }
 export interface VacuumResult {
     message: string;
@@ -78,3 +82,16 @@ export interface VacuumResult {
     ruleId: string;
     ruleSeverity: string;
 }
+export interface Reference {
+    definition: string;
+    fullDefinition: string;
+    targetLine: number;
+    targetColumn: number;
+    jsonPath: string;
+    line: number;
+    startColumn: number;
+    endColumn: number;
+    isPolymorphic: boolean;
+    rolodexIdHash?: string;
+}
+export declare function SearchNodeTreeForPath(node: Node, path: string): Node | null;

package/dist/model/graph.js

@@ -1 +1,17 @@
-export {};
+export function SearchNodeTreeForPath(node, path) {
+    if (!node) {
+        return null;
+    }
+    if (node.path === path) {
+        return node;
+    }
+    if (node.nodes && node.nodes.length > 0) {
+        for (let n of node.nodes) {
+            let found = SearchNodeTreeForPath(n, path);
+            if (found) {
+                return found;
+            }
+        }
+    }
+    return null;
+}

package/dist/model/link.d.ts

@@ -13,3 +13,11 @@ export interface Link {
     server?: Server;
     $ref?: string;
 }
+export interface EditorLink {
+    startLineNumber: number;
+    startColumn: number;
+    endLineNumber: number;
+    endColumn: number;
+    target: string;
+    isPolymorphic: boolean;
+}

package/dist/model/node_type.d.ts

@@ -45,5 +45,26 @@ export declare enum NodeType {
     POLYMORPHIC = "polymorphic",
     ERROR = "error",
     WARNING = "warning",
-    UNKNOWN = "unknown"
+    ROLODEX_FILE = "rolodex-file",
+    ROLODEX_FOLDER = "rolodex-dir",
+    OPENAPI = "openapi",
+    UPLOAD = "upload",
+    ADD = "add",
+    UNKNOWN = "unknown",
+    JS = "js",
+    GO = "go",
+    TS = "ts",
+    CS = "cs",
+    C = "c",
+    CPP = "cpp",
+    PHP = "php",
+    PY = "py",
+    HTML = "html",
+    MD = "md",
+    JAVA = "java",
+    RS = "rs",
+    ZIG = "zig",
+    RB = "rb",
+    YAML = "yaml",
+    JSON = "json"
 }

package/dist/model/node_type.js

@@ -46,5 +46,27 @@ export var NodeType;
     NodeType["POLYMORPHIC"] = "polymorphic";
     NodeType["ERROR"] = "error";
     NodeType["WARNING"] = "warning";
+    NodeType["ROLODEX_FILE"] = "rolodex-file";
+    NodeType["ROLODEX_FOLDER"] = "rolodex-dir";
+    NodeType["OPENAPI"] = "openapi";
+    NodeType["UPLOAD"] = "upload";
+    NodeType["ADD"] = "add";
     NodeType["UNKNOWN"] = "unknown";
+    NodeType["JS"] = "js";
+    NodeType["GO"] = "go";
+    NodeType["TS"] = "ts";
+    NodeType["CS"] = "cs";
+    NodeType["C"] = "c";
+    NodeType["CPP"] = "cpp";
+    NodeType["PHP"] = "php";
+    NodeType["PY"] = "py";
+    NodeType["HTML"] = "html";
+    NodeType["MD"] = "md";
+    NodeType["JAVA"] = "java";
+    NodeType["RS"] = "rs";
+    NodeType["ZIG"] = "zig";
+    NodeType["RB"] = "rb";
+    NodeType["YAML"] = "yaml";
+    NodeType["JSON"] = "json";
+    //case YAML, JSON, JS, GO, TS, CS, C, CPP, PHP, PY, HTML, MD, JAVA, RS, ZIG, RB:
 })(NodeType || (NodeType = {}));

package/dist/model/panel-state.d.ts

@@ -0,0 +1,5 @@
+export interface PanelState {
+    explorerPanel?: number;
+    rolodexPanel?: number;
+    inspectorPanel?: number;
+}

package/dist/model/panel-state.js

@@ -0,0 +1 @@
+export {};

package/dist/model/problem.d.ts

@@ -3,6 +3,7 @@ import { MarkerSeverity } from "monaco-editor";
 export declare class Problem implements monaco.editor.IMarkerData {
     category: string;
     jsonPath: string;
+    jsonPaths: string[];
     endColumn: number;
     endLineNumber: number;
     message: string;
@@ -11,8 +12,9 @@ export declare class Problem implements monaco.editor.IMarkerData {
     startLineNumber: number;
     source: string;
     id: string;
+    sourceLocation: string;
     static reconstruct(problem: Problem): Problem;
-    constructor(category: string, jsonPath: string, endColumn: number, endLineNumber: number, message: string, severity: MarkerSeverity, startColumn: number, startLineNumber: number, source: string, id: string);
+    constructor(category: string, jsonPath: string, endColumn: number, endLineNumber: number, message: string, severity: MarkerSeverity, startColumn: number, startLineNumber: number, source: string, id: string, sourceLocation?: string, jsonPaths?: string[]);
     hash(): string;
 }
 export declare function getProblemClass(problem: Problem): string;

package/dist/model/problem.js

@@ -1,9 +1,9 @@
 import * as monaco from "monaco-editor";
 export class Problem {
     static reconstruct(problem) {
-        return new Problem(problem.category, problem.jsonPath, problem.endColumn, problem.endLineNumber, problem.message, problem.severity, problem.startColumn, problem.startLineNumber, problem.source, problem.id);
+        return new Problem(problem.category, problem.jsonPath, problem.endColumn, problem.endLineNumber, problem.message, problem.severity, problem.startColumn, problem.startLineNumber, problem.source, problem.id, problem.sourceLocation, problem.jsonPaths);
     }
-    constructor(category, jsonPath, endColumn, endLineNumber, message, severity, startColumn, startLineNumber, source, id) {
+    constructor(category, jsonPath, endColumn, endLineNumber, message, severity, startColumn, startLineNumber, source, id, sourceLocation = '', jsonPaths = []) {
         this.category = category;
         this.jsonPath = jsonPath;
         this.endColumn = endColumn;
@@ -14,6 +14,8 @@ export class Problem {
         this.startLineNumber = startLineNumber;
         this.source = source;
         this.id = id;
+        this.sourceLocation = sourceLocation;
+        this.jsonPaths = jsonPaths;
         if (this.startLineNumber === 0) {
             this.startLineNumber = 1;
         }

package/dist/model/rolodex.d.ts

@@ -0,0 +1,34 @@
+import { DocumentStatistics } from "./document-statistics";
+import { Node, Reference } from "./graph";
+export interface RolodexResponse {
+    rolodexRoot: Node;
+    statistics: DocumentStatistics;
+}
+export interface ArchiveFileResponse {
+    files: FileMeta[];
+}
+export interface FileMeta {
+    name: string;
+    isOpenAPI?: boolean;
+}
+export interface RolodexFile {
+    content: string;
+}
+export interface RolodexFiles {
+    files: {
+        [path: string]: Node;
+    };
+}
+export interface ReferenceMap {
+    references: {
+        [path: string]: Reference[];
+    };
+}
+export interface RolodexState {
+    activePath?: string;
+    activeHash?: string;
+    activeLanguage?: string;
+    activeNode?: Node;
+    rootHash?: string;
+    rootPath?: string;
+}

package/dist/model/rolodex.js

@@ -0,0 +1 @@
+export {};

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

@@ -5,7 +5,7 @@ import { Session } from "../model/session.js";
 export declare class LintingService {
     static doctorEndpoint: string;
     static compareProblems(a: Problem, b: Problem): number;
-    static lintFile(file: string, brokerId?: string, url?: string): Promise<Problem[]>;
+    static lintFile(file: string, brokerId?: string, url?: string, currentPath?: string): Promise<Problem[]>;
     static fetchAllHowToFix(): Promise<HowToFix[]>;
     static fetchStatistics(): Promise<DrDiagnostics>;
     static startSession(): Promise<Session>;

package/dist/services/linting-service.js

@@ -19,18 +19,28 @@ export class LintingService {
         }
         return 0;
     }
-    static async lintFile(file, brokerId, url) {
+    static async lintFile(file, brokerId, url, currentPath) {
         return new Promise(async (resolve, reject) => {
             try {
                 const headers = HeaderService.buildDefaultHeaders(brokerId);
                 let lintResults;
                 if (!url) {
-                    lintResults = await fetch(LintingService.doctorEndpoint + '/lint-lsp', {
-                        method: 'POST',
-                        credentials: 'include',
-                        headers: headers,
-                        body: file
-                    });
+                    if (currentPath) {
+                        lintResults = await fetch(LintingService.doctorEndpoint + '/lint-lsp?currentPath=' + encodeURIComponent(currentPath), {
+                            method: 'POST',
+                            credentials: 'include',
+                            headers: headers,
+                            body: file
+                        });
+                    }
+                    else {
+                        lintResults = await fetch(LintingService.doctorEndpoint + '/lint-lsp', {
+                            method: 'POST',
+                            credentials: 'include',
+                            headers: headers,
+                            body: file
+                        });
+                    }
                 }
                 else {
                     lintResults = await fetch(LintingService.doctorEndpoint + '/lint-lsp?url=' + encodeURIComponent(url), {
@@ -53,12 +63,12 @@ export class LintingService {
                 if (lintData && Array.isArray(lintData)) {
                     for (let i = 0; i < lintData.length; i++) {
                         const problem = lintData[i];
-                        constructedProblems.push(new Problem(problem.category, problem.jsonPath, problem.endColumn, problem.endLineNumber, problem.message, problem.severity, problem.startColumn, problem.startLineNumber, problem.source, problem.id));
+                        constructedProblems.push(new Problem(problem.category, problem.jsonPath, problem.endColumn, problem.endLineNumber, problem.message, problem.severity, problem.startColumn, problem.startLineNumber, problem.source, problem.id, problem.sourceLocation));
                     }
                 }
                 if (lintData && !Array.isArray(lintData)) {
                     const problem = lintData;
-                    constructedProblems.push(new Problem(problem.category, problem.jsonPath, problem.endColumn, problem.endLineNumber, problem.message, problem.severity, problem.startColumn, problem.startLineNumber, problem.source, problem.id));
+                    constructedProblems.push(new Problem(problem.category, problem.jsonPath, problem.endColumn, problem.endLineNumber, problem.message, problem.severity, problem.startColumn, problem.startLineNumber, problem.source, problem.id, problem.sourceLocation));
                 }
                 constructedProblems.sort(LintingService.compareProblems);
                 resolve(constructedProblems);
@@ -82,8 +92,10 @@ export class LintingService {
                 resolve(howToFix);
             }
             catch (e) {
-                reject({ tile: "platform error", detail: "the pb33f platform is unresponsive, " +
-                        "please try again later." });
+                reject({
+                    tile: "platform error", detail: "the pb33f platform is unresponsive, " +
+                        "please try again later."
+                });
             }
         });
     }

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

@@ -1,9 +1,16 @@
-import { GraphResponse } from "../model/graph";
+import { GraphResponse, Reference } from "../model/graph";
 import { ExampleContainer } from "../model/example";
+import { Node } from "../model/graph";
+import { ArchiveFileResponse, RolodexResponse } from "../model/rolodex";
 export declare class ModelService {
     static doctorEndpoint: string;
     static createGraph(spec?: string): Promise<GraphResponse>;
+    static fetchReferenceMap(): Promise<Reference[]>;
+    static uploadArchive(formData: FormData): Promise<ArchiveFileResponse>;
+    static selectRootPath(path: string): Promise<Node>;
+    static queryRolodex(id?: string, path?: string): Promise<RolodexResponse>;
     static generateMock(spec?: string): Promise<any>;
     static generateExample(example: ExampleContainer): Promise<ExampleContainer>;
     static convertJSONToYAML(json?: string): Promise<any>;
+    static resetWorkspace(): Promise<boolean>;
 }

package/dist/services/model-service.js

@@ -26,6 +26,121 @@ export class ModelService {
             }
         });
     }
+    static async fetchReferenceMap() {
+        return new Promise(async (resolve, reject) => {
+            try {
+                const graph = await fetch(ModelService.doctorEndpoint + '/model/reference-map', {
+                    method: 'GET',
+                    credentials: 'include',
+                    headers: {
+                        'Content-Type': 'application/json'
+                    },
+                });
+                const referenceMap = await graph.json();
+                if (!referenceMap) {
+                    reject({ detail: 'unable to fetch reference map' });
+                    return;
+                }
+                if (referenceMap?.type && referenceMap?.title && referenceMap?.status) {
+                    reject(referenceMap);
+                    return;
+                }
+                resolve(referenceMap);
+            }
+            catch (e) {
+                reject({ detail: 'unable fetch model graph: ' + e });
+            }
+        });
+    }
+    static async uploadArchive(formData) {
+        return new Promise(async (resolve, reject) => {
+            try {
+                const graph = await fetch(ModelService.doctorEndpoint + '/model/upload-archive', {
+                    method: 'POST',
+                    credentials: 'include',
+                    body: formData,
+                });
+                const archiveData = await graph.json();
+                if (!archiveData) {
+                    reject({ detail: 'unable to fetch archive data' });
+                    return;
+                }
+                if (archiveData?.type && archiveData?.title && archiveData?.status) {
+                    reject(archiveData);
+                    return;
+                }
+                resolve(archiveData);
+            }
+            catch (e) {
+                reject({ detail: 'unable fetch archive data: ' + e });
+            }
+        });
+    }
+    static async selectRootPath(path) {
+        return new Promise(async (resolve, reject) => {
+            try {
+                const graph = await fetch(ModelService.doctorEndpoint + '/model/select-root', {
+                    method: 'POST',
+                    credentials: 'include',
+                    headers: {
+                        'Content-Type': 'application/json'
+                    },
+                    body: JSON.stringify({ rolodexRoot: path }),
+                });
+                const archiveData = await graph.json();
+                if (!archiveData) {
+                    reject({ detail: 'unable to fetch archive data' });
+                    return;
+                }
+                if (archiveData?.type && archiveData?.title && archiveData?.status) {
+                    reject(archiveData);
+                    return;
+                }
+                resolve(await archiveData);
+            }
+            catch (e) {
+                reject({ detail: 'unable fetch archive data: ' + e });
+            }
+        });
+    }
+    static async queryRolodex(id, path = '') {
+        return new Promise(async (resolve, reject) => {
+            try {
+                let query = '';
+                if (id)
+                    query = '?id=' + id;
+                if (path != '') {
+                    if (query == '') {
+                        query += '?';
+                    }
+                    else {
+                        query += '&';
+                    }
+                    query += 'path=' + encodeURIComponent(path);
+                }
+                const graph = await fetch(ModelService.doctorEndpoint + '/model/rolodex' + query, {
+                    method: 'GET',
+                    credentials: 'include',
+                    headers: {
+                        'Content-Type': 'application/json'
+                    },
+                });
+                const rolodexData = await graph.json();
+                if (!rolodexData) {
+                    reject({ detail: 'unable to fetch model rolodex' });
+                    return;
+                }
+                if (rolodexData?.type && rolodexData?.title && rolodexData?.status) {
+                    reject(rolodexData);
+                    return;
+                }
+                resolve(rolodexData);
+            }
+            catch (e) {
+                reject({ detail: 'unable fetch model rolodex: ' + e });
+            }
+        });
+    }
     static async generateMock(spec = '') {
         return new Promise(async (resolve, reject) => {
             try {
@@ -110,5 +225,17 @@ export class ModelService {
             }
         });
     }
+    static async resetWorkspace() {
+        return new Promise(async (resolve) => {
+            const reset = await fetch(ModelService.doctorEndpoint + '/model/reset-workspace', {
+                method: 'GET',
+                credentials: 'include',
+                headers: {
+                    'Content-Type': 'application/json'
+                },
+            });
+            resolve(true);
+        });
+    }
 }
 ModelService.doctorEndpoint = 'https://doctor.pb33f.io';