@pb33f/cowboy-components 0.7.5 → 0.7.7

package/dist/css/pb33f-theme.css

@@ -146,6 +146,7 @@ html {
     --error-color: #ff3c74;
     --error-color-glow: #fd497b;
     --error-font-color: #ff246b;
+    --error-color-dimmed: rgba(255, 60, 116, 0.6);
     --error-color-lowalpha: rgba(255, 60, 116, 0.4);
     --error-color-dark: #250911;
     --error-color-loweralpha: rgba(255, 60, 116, 0.2);

package/dist/css/shared.css.js

@@ -23,6 +23,11 @@ export default css `
         margin-top: 10px;
     }
 
+    .origin-location {
+        font-size: 0.8rem;
+    }
+
+
     .empty-data {
         text-align: center;
         padding-top: 20px;

package/dist/events/doctor.d.ts

@@ -5,6 +5,7 @@ import { Toast } from "../model/toast.js";
 import { RuleActionComponent } from "../components/manage-ruleset/rule-action";
 import { GraphResponse, Node, References, Spacing, Options, Change } from "../model/graph";
 import { SpecSummary } from "../model/timeline";
+import { AuthenticationState } from "../model/auth";
 export declare const EditorUpdated: string;
 export declare const EditorClicked: string;
 export declare const ProblemClicked: string;
@@ -52,14 +53,25 @@ export declare const DocumentReferenceClicked: string;
 export declare const LoadRenderedNodeIntoInspector: string;
 export declare const NukeWorkspaceEvent: string;
 export declare const AuthenticationGithubRequested = "authenticationGithubRequested";
+export declare const AuthenticationStateChange = "authenticationStateChange";
 export declare const LogoutRequested = "logoutRequested";
 export declare const TimelineHistoryRefresh = "timelineHistoryRefresh";
 export declare const RevisionClicked = "revisionClicked";
 export declare const ShowTimelineSummary = "showTimelineSummary";
 export declare const OpenSettings = "openSettings";
+export declare const OpenAuthentication = "openAuthentication";
+export declare const StartSessionFailed = "startSessionFailed";
+export declare const CreditEmpty = "creditEmpty";
 export interface RevisionClickedEvent {
     specSummary: SpecSummary;
 }
+export interface NukeLogout {
+    resetFiles: boolean;
+}
+export interface AuthenticationMeta {
+    redirectURL?: string;
+    state?: AuthenticationState;
+}
 export interface ArchiveURLRequestedEvent {
     url: string;
 }

package/dist/events/doctor.js

@@ -45,11 +45,15 @@ export const DocumentReferenceClicked = "documentReferenceClicked";
 export const LoadRenderedNodeIntoInspector = "loadRenderedNodeIntoInspector";
 export const NukeWorkspaceEvent = "nukeWorkspace";
 export const AuthenticationGithubRequested = "authenticationGithubRequested";
+export const AuthenticationStateChange = "authenticationStateChange";
 export const LogoutRequested = "logoutRequested";
 export const TimelineHistoryRefresh = "timelineHistoryRefresh";
 export const RevisionClicked = "revisionClicked";
 export const ShowTimelineSummary = "showTimelineSummary";
 export const OpenSettings = "openSettings";
+export const OpenAuthentication = "openAuthentication";
+export const StartSessionFailed = "startSessionFailed";
+export const CreditEmpty = "creditEmpty";
 export var ActiveView;
 (function (ActiveView) {
     ActiveView["Problems"] = "problems";

package/dist/model/api-response.d.ts

@@ -4,3 +4,10 @@ export declare class APIResponse<T> {
     };
     response?: T;
 }
+export declare class APIError {
+    type: string;
+    title: string;
+    status: number;
+    detail: string;
+    instance: string;
+}

package/dist/model/api-response.js

@@ -1,2 +1,4 @@
 export class APIResponse {
 }
+export class APIError {
+}

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

@@ -2,4 +2,5 @@ import { AuthenticationState } from "../model/auth.js";
 export declare class AuthService {
     static doctorEndpoint: string;
     static checkAuth(): Promise<AuthenticationState>;
+    static logout(redirectUrl?: string): Promise<boolean>;
 }

package/dist/services/auth-service.js

@@ -20,5 +20,33 @@ export class AuthService {
             }
         });
     }
+    static async logout(redirectUrl) {
+        return new Promise(async (resolve, reject) => {
+            try {
+                let redirect = '';
+                {
+                    if (redirectUrl) {
+                        redirect = '?redirectUrl=' + redirectUrl;
+                    }
+                }
+                const authState = await fetch(AuthService.doctorEndpoint + '/auth/logout' + redirect, {
+                    method: 'GET',
+                    credentials: 'include',
+                    redirect: 'manual'
+                });
+                let state = await authState.text();
+                if (!authState.ok) {
+                    reject(false);
+                }
+                resolve(true);
+            }
+            catch (e) {
+                reject({
+                    tile: "platform error", detail: "cannot logout " +
+                        "please try again later."
+                });
+            }
+        });
+    }
 }
 AuthService.doctorEndpoint = 'https://doctor.pb33f.io';

package/dist/services/linting-service.js

@@ -1,5 +1,6 @@
 import { Problem } from "../model/problem.js";
 import { HeaderService } from "./header-service";
+import { AuthController } from "../controllers/auth-controller";
 export class LintingService {
     static compareProblems(a, b) {
         if (a.startLineNumber < b.startLineNumber) {
@@ -131,11 +132,19 @@ export class LintingService {
     static async bootstrapEditor() {
         return new Promise(async (resolve, reject) => {
             try {
-                const boostrapSpec = await fetch(LintingService.doctorEndpoint + '/bootstrap/train-travel', {
+                let bootstrapSpec;
+                // check state from the auth service to determine if we're extracting trains, or a workspace.
+                const authController = AuthController.getInstance();
+                let endpoint = '/bootstrap/train-travel';
+                // get the current spec if we're authenticated.
+                if (authController && authController.state && authController.authenticated) {
+                    endpoint = '/model/current-spec';
+                }
+                bootstrapSpec = await fetch(LintingService.doctorEndpoint + endpoint, {
                     method: 'GET',
                     credentials: 'include',
                 });
-                const spec = await boostrapSpec.text();
+                const spec = await bootstrapSpec.text();
                 resolve(spec);
             }
             catch (e) {

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

@@ -5,7 +5,7 @@ import { ArchiveFileResponse, RolodexResponse } from "../model/rolodex";
 export declare class ModelService {
     static doctorEndpoint: string;
     static fetchLatestGraph(): Promise<GraphResponse>;
-    static fetchReferenceMap(): Promise<Reference[]>;
+    static fetchReferenceMap(currentPath?: string): Promise<Reference[]>;
     static uploadArchive(formData: FormData): Promise<ArchiveFileResponse>;
     static selectRootPath(path: string): Promise<Node>;
     static queryRolodex(id?: string, path?: string): Promise<RolodexResponse>;
@@ -13,4 +13,5 @@ export declare class ModelService {
     static generateExample(example: ExampleContainer): Promise<ExampleContainer>;
     static convertJSONToYAML(json?: string): Promise<any>;
     static resetWorkspace(): Promise<boolean>;
+    static getCurrentSpec(): Promise<string>;
 }

package/dist/services/model-service.js

@@ -47,10 +47,14 @@ export class ModelService {
             }
         });
     }
-    static async fetchReferenceMap() {
+    static async fetchReferenceMap(currentPath = '') {
         return new Promise(async (resolve, reject) => {
             try {
-                const refs = await fetch(ModelService.doctorEndpoint + '/model/reference-map', {
+                let cp = '';
+                if (currentPath !== '') {
+                    cp = '?path=' + currentPath;
+                }
+                const refs = await fetch(ModelService.doctorEndpoint + '/model/reference-map' + cp, {
                     method: 'GET',
                     credentials: 'include',
                     headers: {
@@ -75,7 +79,7 @@ export class ModelService {
                 }
             }
             catch (e) {
-                reject({ detail: 'unable fetch refernce map ' + e });
+                reject({ detail: 'unable fetch reference map ' + e });
             }
         });
     }
@@ -119,14 +123,14 @@ export class ModelService {
                     reject({ detail: 'unable to fetch archive data' });
                     return;
                 }
-                if (archiveData?.type && archiveData?.title && archiveData?.status) {
+                if (!graph.ok) {
                     reject(archiveData);
                     return;
                 }
                 resolve(await archiveData);
             }
             catch (e) {
-                reject({ detail: 'unable fetch archive data: ' + e });
+                reject(e);
             }
         });
     }
@@ -264,5 +268,27 @@ export class ModelService {
             resolve(true);
         });
     }
+    static async getCurrentSpec() {
+        return new Promise(async (resolve, reject) => {
+            try {
+                const spec = await fetch(ModelService.doctorEndpoint + '/model/current-spec', {
+                    method: 'GET',
+                    credentials: 'include',
+                    headers: {
+                        'Content-Type': 'application/json'
+                    },
+                });
+                const latestSpec = await spec.text();
+                if (!latestSpec) {
+                    reject("cannot fetch latest specification from pb33f platform");
+                    return;
+                }
+                resolve(latestSpec);
+            }
+            catch (e) {
+                reject("cannot fetch latest specification from pb33f platform: " + e);
+            }
+        });
+    }
 }
 ModelService.doctorEndpoint = 'https://doctor.pb33f.io';