@pb33f/cowboy-components 0.6.7 → 0.7.0

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

@@ -0,0 +1 @@
+export declare function rgbaToHex(rgba: string): string;

package/dist/services/color-service.js

@@ -0,0 +1,13 @@
+export function rgbaToHex(rgba) {
+    const parts = rgba.match(/\d+(\.\d+)?/g)?.map(Number);
+    if (!parts || parts.length < 3)
+        return '#000000';
+    const [r, g, b, a = 1] = parts;
+    const toHex = (x) => x.toString(16).padStart(2, '0');
+    const hex = `#${toHex(r)}${toHex(g)}${toHex(b)}`;
+    if (a < 1) {
+        const alphaHex = toHex(Math.round(a * 255));
+        return `${hex}${alphaHex}`;
+    }
+    return hex;
+}

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

@@ -1,13 +1,11 @@
 import { Problem } from "../model/problem.js";
 import { HowToFix } from "../model/how_to_fix.js";
 import { DrDiagnostics } from "../model/document-statistics.js";
-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, currentPath?: string): Promise<Problem[]>;
+    static lintFile(file: string, brokerId?: string, url?: string, currentPath?: string, skipTimeline?: boolean): Promise<Problem[]>;
     static fetchAllHowToFix(): Promise<HowToFix[]>;
     static fetchStatistics(): Promise<DrDiagnostics>;
-    static startSession(): Promise<Session>;
     static bootstrapEditor(): Promise<string>;
 }

package/dist/services/linting-service.js

@@ -19,14 +19,15 @@ export class LintingService {
         }
         return 0;
     }
-    static async lintFile(file, brokerId, url, currentPath) {
+    static async lintFile(file, brokerId, url, currentPath, skipTimeline) {
         return new Promise(async (resolve, reject) => {
             try {
                 const headers = HeaderService.buildDefaultHeaders(brokerId);
                 let lintResults;
+                let skipTimelineParam = skipTimeline ? 'skipTimeline=true' : '';
                 if (!url) {
                     if (currentPath) {
-                        lintResults = await fetch(LintingService.doctorEndpoint + '/lint-lsp?currentPath=' + encodeURIComponent(currentPath), {
+                        lintResults = await fetch(LintingService.doctorEndpoint + '/diagnose?currentPath=' + encodeURIComponent(currentPath) + '&' + skipTimelineParam, {
                             method: 'POST',
                             credentials: 'include',
                             headers: headers,
@@ -34,7 +35,7 @@ export class LintingService {
                         });
                     }
                     else {
-                        lintResults = await fetch(LintingService.doctorEndpoint + '/lint-lsp', {
+                        lintResults = await fetch(LintingService.doctorEndpoint + '/diagnose' + (skipTimelineParam ? '?' + skipTimelineParam : ''), {
                             method: 'POST',
                             credentials: 'include',
                             headers: headers,
@@ -43,7 +44,7 @@ export class LintingService {
                     }
                 }
                 else {
-                    lintResults = await fetch(LintingService.doctorEndpoint + '/lint-lsp?url=' + encodeURIComponent(url), {
+                    lintResults = await fetch(LintingService.doctorEndpoint + '/diagnose?url=' + encodeURIComponent(url) + '&' + skipTimelineParam, {
                         method: 'GET',
                         credentials: 'include',
                         headers: headers,
@@ -60,13 +61,23 @@ export class LintingService {
                 }
                 const lintData = apiResult;
                 const constructedProblems = [];
-                if (lintData && Array.isArray(lintData)) {
-                    for (let i = 0; i < lintData.length; i++) {
-                        const problem = lintData[i];
+                if (lintData && !lintData.response && !lintData.message) {
+                    resolve([]);
+                    return;
+                }
+                if (lintData && !lintData.response && lintData.message) {
+                    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, problem.sourceLocation));
+                    resolve(constructedProblems);
+                    return;
+                }
+                if (lintData && Array.isArray(lintData.response)) {
+                    for (let i = 0; i < lintData.response.length; i++) {
+                        const problem = lintData.response[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, problem.sourceLocation));
                     }
                 }
-                if (lintData && !Array.isArray(lintData)) {
+                if (lintData && !Array.isArray(lintData.response)) {
                     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, problem.sourceLocation));
                 }
@@ -74,7 +85,7 @@ export class LintingService {
                 resolve(constructedProblems);
             }
             catch (e) {
-                reject({ detail: "the pb33f platform is unresponsive" });
+                reject({ detail: "the pb33f platform is unresponsive", "error": e });
             }
         });
     }
@@ -102,7 +113,7 @@ export class LintingService {
     static async fetchStatistics() {
         return new Promise(async (resolve, reject) => {
             try {
-                const lintStatsJSON = await fetch(LintingService.doctorEndpoint + '/lint-statistics', {
+                const lintStatsJSON = await fetch(LintingService.doctorEndpoint + '/diagnosis-statistics', {
                     method: 'GET',
                     credentials: 'include',
                 });
@@ -117,25 +128,6 @@ export class LintingService {
             }
         });
     }
-    // TODO: this needs to be moved out of here.
-    static async startSession() {
-        return new Promise(async (resolve, reject) => {
-            try {
-                const sessionJSON = await fetch(LintingService.doctorEndpoint + '/start-session', {
-                    method: 'GET',
-                    credentials: 'include',
-                });
-                const session = await sessionJSON.json();
-                if (session.type && session.title && session.status) {
-                    reject(session);
-                }
-                resolve(session);
-            }
-            catch (e) {
-                reject({ detail: "the pb33f platform is unresponsive" });
-            }
-        });
-    }
     static async bootstrapEditor() {
         return new Promise(async (resolve, reject) => {
             try {

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

@@ -4,7 +4,7 @@ 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 fetchLatestGraph(): Promise<GraphResponse>;
     static fetchReferenceMap(): Promise<Reference[]>;
     static uploadArchive(formData: FormData): Promise<ArchiveFileResponse>;
     static selectRootPath(path: string): Promise<Node>;

package/dist/services/model-service.js

@@ -1,14 +1,13 @@
 export class ModelService {
-    static async createGraph(spec = '') {
+    static async fetchLatestGraph() {
         return new Promise(async (resolve, reject) => {
             try {
                 const graph = await fetch(ModelService.doctorEndpoint + '/model/graph', {
-                    method: 'POST',
+                    method: 'GET',
                     credentials: 'include',
                     headers: {
                         'Content-Type': 'application/json'
                     },
-                    body: spec,
                 });
                 const graphData = await graph.json();
                 if (!graphData) {
@@ -19,7 +18,29 @@ export class ModelService {
                     reject(graphData);
                     return;
                 }
-                resolve(graphData);
+                const graphRevisions = graphData;
+                if (graphRevisions) {
+                    // first is latest, grab the id
+                    const gId = graphRevisions[0].graphId;
+                    const graphFile = await fetch(ModelService.doctorEndpoint + '/model/graph/' + gId, {
+                        method: 'GET',
+                        credentials: 'include',
+                        headers: {
+                            'Content-Type': 'application/json'
+                        },
+                    });
+                    const graphFileData = await graphFile.json();
+                    if (!graphFileData) {
+                        reject({ detail: 'unable to fetch model graph file' });
+                        return;
+                    }
+                    if (graphFileData?.type && graphFileData?.title && graphFileData?.status) {
+                        reject(graphFileData);
+                        return;
+                    }
+                    resolve(graphFileData);
+                }
+                reject({ detail: 'no graph data could be extracted' });
             }
             catch (e) {
                 reject({ detail: 'unable fetch model graph: ' + e });
@@ -29,14 +50,14 @@ export class ModelService {
     static async fetchReferenceMap() {
         return new Promise(async (resolve, reject) => {
             try {
-                const graph = await fetch(ModelService.doctorEndpoint + '/model/reference-map', {
+                const refs = await fetch(ModelService.doctorEndpoint + '/model/reference-map', {
                     method: 'GET',
                     credentials: 'include',
                     headers: {
                         'Content-Type': 'application/json'
                     },
                 });
-                const referenceMap = await graph.json();
+                const referenceMap = await refs.json();
                 if (!referenceMap) {
                     reject({ detail: 'unable to fetch reference map' });
                     return;
@@ -45,10 +66,16 @@ export class ModelService {
                     reject(referenceMap);
                     return;
                 }
-                resolve(referenceMap);
+                const apiResponse = referenceMap;
+                if (apiResponse.response) {
+                    resolve(apiResponse.response);
+                }
+                else {
+                    reject({ detail: 'unable to fetch reference map' });
+                }
             }
             catch (e) {
-                reject({ detail: 'unable fetch model graph: ' + e });
+                reject({ detail: 'unable fetch refernce map ' + e });
             }
         });
     }

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

@@ -1,5 +1,11 @@
 import { RoundupStats } from "../model/roundup-stats.js";
+import { ChartResultData } from "../model/chart-data";
 export declare class RodeoService {
     static doctorEndpoint: string;
     static getRoundup(): Promise<RoundupStats>;
+    static getNpmStatistics(project: string): Promise<ChartResultData>;
+    static getGithubStatistics(project: string, showPatches?: boolean): Promise<ChartResultData>;
+    static getGithubCloneStatistics(project: string): Promise<ChartResultData>;
+    static getGithubStars(project: string): Promise<ChartResultData>;
+    static getDockerPulls(project: string): Promise<ChartResultData>;
 }

package/dist/services/rodeo-service.js

@@ -25,5 +25,139 @@ export class RodeoService {
             }
         });
     }
+    static async getNpmStatistics(project) {
+        return new Promise(async (resolve, reject) => {
+            try {
+                const npmStats = await fetch(RodeoService.doctorEndpoint + '/rodeo/statistics/npm/' + project, {
+                    method: 'GET',
+                    credentials: 'include',
+                    headers: {
+                        'Content-Type': 'application/json'
+                    },
+                });
+                const apiResult = await npmStats.json();
+                if (!apiResult) {
+                    reject({ details: 'unable to send feedback' });
+                    return;
+                }
+                if (apiResult?.type && apiResult?.title && apiResult?.status) {
+                    reject(apiResult);
+                    return;
+                }
+                resolve(apiResult);
+            }
+            catch (e) {
+                reject({ details: `unable to get npm statistics for project ${project}: ` + e });
+            }
+        });
+    }
+    static async getGithubStatistics(project, showPatches = false) {
+        return new Promise(async (resolve, reject) => {
+            try {
+                let patches = '';
+                if (showPatches) {
+                    patches = '?showPatches=true';
+                }
+                const githubResult = await fetch(RodeoService.doctorEndpoint + '/rodeo/statistics/github/' + project + patches, {
+                    method: 'GET',
+                    credentials: 'include',
+                    headers: {
+                        'Content-Type': 'application/json'
+                    },
+                });
+                const apiResult = await githubResult.json();
+                if (!apiResult) {
+                    reject({ details: 'unable to send feedback' });
+                    return;
+                }
+                if (apiResult?.type && apiResult?.title && apiResult?.status) {
+                    reject(apiResult);
+                    return;
+                }
+                resolve(apiResult);
+            }
+            catch (e) {
+                reject({ details: `unable to get github statistics for project ${project}: ` + e });
+            }
+        });
+    }
+    static async getGithubCloneStatistics(project) {
+        return new Promise(async (resolve, reject) => {
+            try {
+                const githubResult = await fetch(RodeoService.doctorEndpoint + '/rodeo/statistics/github-clones/' + project, {
+                    method: 'GET',
+                    credentials: 'include',
+                    headers: {
+                        'Content-Type': 'application/json'
+                    },
+                });
+                const apiResult = await githubResult.json();
+                if (!apiResult) {
+                    reject({ details: 'unable to send feedback' });
+                    return;
+                }
+                if (apiResult?.type && apiResult?.title && apiResult?.status) {
+                    reject(apiResult);
+                    return;
+                }
+                resolve(apiResult);
+            }
+            catch (e) {
+                reject({ details: `unable to get github clone statistics for project ${project}: ` + e });
+            }
+        });
+    }
+    static async getGithubStars(project) {
+        return new Promise(async (resolve, reject) => {
+            try {
+                const githubResult = await fetch(RodeoService.doctorEndpoint + '/rodeo/statistics/github-stars/' + project, {
+                    method: 'GET',
+                    credentials: 'include',
+                    headers: {
+                        'Content-Type': 'application/json'
+                    },
+                });
+                const apiResult = await githubResult.json();
+                if (!apiResult) {
+                    reject({ details: 'unable to send feedback' });
+                    return;
+                }
+                if (apiResult?.type && apiResult?.title && apiResult?.status) {
+                    reject(apiResult);
+                    return;
+                }
+                resolve(apiResult);
+            }
+            catch (e) {
+                reject({ details: `unable to get github stars statistics for project ${project}: ` + e });
+            }
+        });
+    }
+    static async getDockerPulls(project) {
+        return new Promise(async (resolve, reject) => {
+            try {
+                const githubResult = await fetch(RodeoService.doctorEndpoint + '/rodeo/statistics/docker-pulls/' + project, {
+                    method: 'GET',
+                    credentials: 'include',
+                    headers: {
+                        'Content-Type': 'application/json'
+                    },
+                });
+                const apiResult = await githubResult.json();
+                if (!apiResult) {
+                    reject({ details: 'unable to send feedback' });
+                    return;
+                }
+                if (apiResult?.type && apiResult?.title && apiResult?.status) {
+                    reject(apiResult);
+                    return;
+                }
+                resolve(apiResult);
+            }
+            catch (e) {
+                reject({ details: `unable to get docker pull statistics for project ${project}: ` + e });
+            }
+        });
+    }
 }
 RodeoService.doctorEndpoint = 'https://doctor.pb33f.io';

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

@@ -0,0 +1,8 @@
+import { ChangeHistory, SpecSummary } from "../model/timeline";
+import { GraphResponse } from "../model/graph";
+export declare class TimelineService {
+    static doctorEndpoint: string;
+    static getSummary(): Promise<SpecSummary[]>;
+    static fetchChange(changeId: string, report?: boolean): Promise<GraphResponse>;
+    static fetchHistory(): Promise<ChangeHistory>;
+}

package/dist/services/timeline-service.js

@@ -0,0 +1,85 @@
+export class TimelineService {
+    static async getSummary() {
+        return new Promise(async (resolve, reject) => {
+            try {
+                const summary = await fetch(TimelineService.doctorEndpoint + '/timeline/summary', {
+                    method: 'GET',
+                    credentials: 'include',
+                    headers: {
+                        'Content-Type': 'application/json'
+                    },
+                });
+                const summaryData = await summary.json();
+                if (!summaryData) {
+                    reject({ detail: 'unable to fetch model graph' });
+                    return;
+                }
+                if (summaryData?.type && summaryData?.title && summaryData?.status) {
+                    reject(summaryData);
+                    return;
+                }
+                resolve(summaryData);
+            }
+            catch (e) {
+                reject({ detail: 'unable fetch timeline summary: ' + e });
+            }
+        });
+    }
+    static async fetchChange(changeId, report = true) {
+        return new Promise(async (resolve, reject) => {
+            try {
+                let command = 'change';
+                if (!report) {
+                    command = 'graph';
+                }
+                const summary = await fetch(TimelineService.doctorEndpoint + '/timeline/' + command + '/' + changeId, {
+                    method: 'GET',
+                    credentials: 'include',
+                    headers: {
+                        'Content-Type': 'application/json'
+                    },
+                });
+                const change = await summary.json();
+                if (!change) {
+                    reject({ detail: 'unable to fetch model graph' });
+                    return;
+                }
+                if (change?.type && change?.title && change?.status) {
+                    reject(change);
+                    return;
+                }
+                resolve(change);
+            }
+            catch (e) {
+                reject({ detail: 'unable fetch timeline change ' + e });
+            }
+        });
+    }
+    static async fetchHistory() {
+        return new Promise(async (resolve, reject) => {
+            try {
+                const summary = await fetch(TimelineService.doctorEndpoint + '/timeline/history', {
+                    method: 'GET',
+                    credentials: 'include',
+                    headers: {
+                        'Content-Type': 'application/json'
+                    },
+                });
+                const history = await summary.json();
+                if (!history) {
+                    reject({ detail: 'unable to fetch timeline history' });
+                    return;
+                }
+                if (history?.type && history?.title && history?.status) {
+                    reject(history);
+                    return;
+                }
+                resolve(history);
+            }
+            catch (e) {
+                reject({ detail: 'unable fetch timeline change ' + e });
+            }
+        });
+    }
+}
+TimelineService.doctorEndpoint = 'https://doctor.pb33f.io';