@pb33f/cowboy-components 0.1.15 → 0.2.0

package/dist/workers/rule-documentation.worker.d.ts

@@ -1 +1,9 @@
-export {};
+import { DoctorDocumentation } from "../model/rule_documentation.js";
+declare const _default: (this: Window, e: MessageEvent<any>) => void;
+export default _default;
+export declare function buildRuleDocs(endpoint: string): Promise<DoctorDocumentation[]>;
+export declare function buildFunctionDocs(endpoint: string): Promise<DoctorDocumentation[]>;
+export declare function fetchAllRuleDocumentation(endpoint: string): Promise<DoctorDocumentation[]>;
+export declare function fetchAllFunctionDocumentation(endpoint: string): Promise<DoctorDocumentation[]>;
+export declare function fetchRuleDocumentation(ruleId: string, endpoint: string): Promise<DoctorDocumentation>;
+export declare function fetchFunctionDocumentation(functionId: string, endpoint: string): Promise<DoctorDocumentation>;

package/dist/workers/rule-documentation.worker.js

@@ -1,13 +1,15 @@
-onmessage = function (e) {
+import { DocumentationType } from "../model/rule_documentation.js";
+export default onmessage = function (e) {
     if (e.data.start) {
-        buildRuleDocs(e.data.endpoint).then((docs) => {
-            postMessage(docs);
+        const promises = [buildRuleDocs(e.data.endpoint), buildFunctionDocs(e.data.endpoint)];
+        Promise.all(promises).then((docs) => {
+            postMessage(docs.flat());
         }).catch(() => {
             console.error('documentation cannot be fetched');
         });
     }
 };
-async function buildRuleDocs(endpoint) {
+export async function buildRuleDocs(endpoint) {
     return new Promise(async (resolve, reject) => {
         try {
             const docs = await fetchAllRuleDocumentation(endpoint);
@@ -15,6 +17,7 @@ async function buildRuleDocs(endpoint) {
                 if (fullDoc.body) {
                     doc.body = fullDoc.body;
                 }
+                doc.type = DocumentationType.RULE;
                 return doc;
             }));
             const updatedDocs = await Promise.all(fetchPromises);
@@ -26,11 +29,65 @@ async function buildRuleDocs(endpoint) {
         }
     });
 }
-async function fetchAllRuleDocumentation(endpoint) {
+export async function buildFunctionDocs(endpoint) {
+    return new Promise(async (resolve, reject) => {
+        try {
+            const docs = await fetchAllFunctionDocumentation(endpoint);
+            const fetchPromises = docs.map(doc => fetchFunctionDocumentation(doc.functionId, endpoint).then(fullDoc => {
+                if (fullDoc.body) {
+                    doc.body = fullDoc.body;
+                }
+                doc.type = DocumentationType.FUNCTION;
+                return doc;
+            }));
+            const updatedDocs = await Promise.all(fetchPromises);
+            resolve(updatedDocs);
+        }
+        catch (e) {
+            console.error('documentation service is down');
+            reject(e);
+        }
+    });
+}
+export async function fetchAllRuleDocumentation(endpoint) {
     try {
         const response = await fetch(endpoint + '/rules/documentation', {
             method: 'GET',
             credentials: 'include',
+            headers: {
+                'Content-Type': 'application/json'
+            },
+        });
+        const apiResult = await response.json();
+        if (!apiResult) {
+            // @ts-ignore
+            return new Promise(async (resolve, reject) => {
+                reject("nothing returned");
+            });
+        }
+        if (apiResult?.error) {
+            // @ts-ignore
+            return new Promise(async (resolve, reject) => {
+                reject(apiResult.error);
+            });
+        }
+        return apiResult;
+    }
+    catch (e) {
+        // @ts-ignore
+        return new Promise(async (resolve, reject) => {
+            reject(e);
+        });
+    }
+}
+export async function fetchAllFunctionDocumentation(endpoint) {
+    try {
+        const response = await fetch(endpoint + '/functions/documentation', {
+            method: 'GET',
+            credentials: 'include',
+            headers: {
+                'Content-Type': 'application/json'
+            },
         });
         const apiResult = await response.json();
         if (!apiResult) {
@@ -54,11 +111,45 @@ async function fetchAllRuleDocumentation(endpoint) {
         });
     }
 }
-async function fetchRuleDocumentation(ruleId, endpoint) {
+export async function fetchRuleDocumentation(ruleId, endpoint) {
     try {
         const response = await fetch(endpoint + `/rules/documentation/${ruleId}`, {
             method: 'GET',
             credentials: 'include',
+            headers: {
+                'Content-Type': 'application/json'
+            },
+        });
+        const apiResult = await response.json();
+        if (!apiResult) {
+            // @ts-ignore
+            return new Promise(async (accept, reject) => {
+                reject("nothing returned");
+            });
+        }
+        if (apiResult?.error) {
+            // @ts-ignore
+            return new Promise(async (accept, reject) => {
+                reject(apiResult.error);
+            });
+        }
+        return apiResult;
+    }
+    catch (e) {
+        // @ts-ignore
+        return new Promise(async (accept, reject) => {
+            reject(e);
+        });
+    }
+}
+export async function fetchFunctionDocumentation(functionId, endpoint) {
+    try {
+        const response = await fetch(endpoint + `/functions/documentation/${functionId}`, {
+            method: 'GET',
+            credentials: 'include',
+            headers: {
+                'Content-Type': 'application/json'
+            },
         });
         const apiResult = await response.json();
         if (!apiResult) {
@@ -82,4 +173,3 @@ async function fetchRuleDocumentation(ruleId, endpoint) {
         });
     }
 }
-export {};

package/dist/workers/search-problems.worker.d.ts

@@ -1 +1,2 @@
-export {};
+declare const _default: (this: Window, e: MessageEvent<any>) => void;
+export default _default;

package/dist/workers/search-problems.worker.js

@@ -1,4 +1,4 @@
-onmessage = function (e) {
+export default onmessage = function (e) {
     if (e.data.search && e.data.problems) {
         let unfilteredProblems = e.data.problems;
         const filteredProblems = unfilteredProblems.filter((problem) => {
@@ -16,4 +16,3 @@ onmessage = function (e) {
         postMessage(filteredProblems);
     }
 };
-export {};

package/package.json

@@ -3,7 +3,7 @@
   "description": "Princess Beef Heavy Industries Cowboy Components",
   "private": false,
   "license": "BUSL-1.1",
-  "version": "0.1.15",
+  "version": "0.2.0",
   "type": "module",
   "main": "./dist/cowboy-components.umd.cjs",
   "module": "./dist/cowboy-components.js",

package/dist/assets/rule-documentation.worker-BFIxMBU8.js

@@ -1 +0,0 @@
-(function(){"use strict";onmessage=function(t){t.data.start&&i(t.data.endpoint).then(o=>{postMessage(o)}).catch(()=>{console.error("documentation cannot be fetched")})};async function i(t){return new Promise(async(o,n)=>{try{const r=(await u(t)).map(s=>d(s.ruleId,t).then(a=>(a.body&&(s.body=a.body),s))),c=await Promise.all(r);o(c)}catch(e){console.error("documentation service is down"),n(e)}})}async function u(t){try{const n=await(await fetch(t+"/rules/documentation",{method:"GET",credentials:"include"})).json();return n?n!=null&&n.error?new Promise(async(e,r)=>{r(n.error)}):n:new Promise(async(e,r)=>{r("nothing returned")})}catch(o){return new Promise(async(n,e)=>{e(o)})}}async function d(t,o){try{const e=await(await fetch(o+`/rules/documentation/${t}`,{method:"GET",credentials:"include"})).json();return e?e!=null&&e.error?new Promise(async(r,c)=>{c(e.error)}):e:new Promise(async(r,c)=>{c("nothing returned")})}catch(n){return new Promise(async(e,r)=>{r(n)})}}})();