@pb33f/cowboy-components 0.7.18 → 0.9.0

package/dist/infoDiagram-F6ZHWCRC-DoDRDWc6.js

@@ -0,0 +1,24 @@
+import { _ as e, l as s, H as o, e as i, I as g } from "./cowboy-components-BRANjWMG.js";
+import { p } from "./mermaid-parser.core-quOEU4Mi.js";
+var v = {
+  parse: /* @__PURE__ */ e(async (r) => {
+    const a = await p("info", r);
+    s.debug(a);
+  }, "parse")
+}, d = {
+  version: g.version + ""
+}, c = /* @__PURE__ */ e(() => d.version, "getVersion"), m = {
+  getVersion: c
+}, l = /* @__PURE__ */ e((r, a, n) => {
+  s.debug(`rendering info diagram
+` + r);
+  const t = o(a);
+  i(t, 100, 400, !0), t.append("g").append("text").attr("x", 100).attr("y", 40).attr("class", "version").attr("font-size", 32).style("text-anchor", "middle").text(`v${n}`);
+}, "draw"), f = { draw: l }, b = {
+  parser: v,
+  db: m,
+  renderer: f
+};
+export {
+  b as diagram
+};

package/dist/init-DjUOC4st.js

@@ -0,0 +1,16 @@
+function t(e, a) {
+  switch (arguments.length) {
+    case 0:
+      break;
+    case 1:
+      this.range(e);
+      break;
+    default:
+      this.range(a).domain(e);
+      break;
+  }
+  return this;
+}
+export {
+  t as i
+};

package/dist/interfaces/bundle-interfaces.d.ts

@@ -0,0 +1,7 @@
+import { Toast } from "../model/toast.js";
+export interface BundleControllerDeps {
+    getBrokerId: () => string | undefined;
+    sendToast: (toast: Toast) => void;
+    requestUpdate: () => void;
+    getOriginalFileName: () => string;
+}

package/dist/interfaces/bundle-interfaces.js

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

package/dist/interfaces/doctor-interfaces.d.ts

@@ -0,0 +1,513 @@
+import { Bag } from "@pb33f/saddlebag";
+import { Bus } from "@pb33f/ranch";
+import { Problem } from "../model/problem.js";
+import { Toast } from "../model/toast.js";
+import type { DoctorEventChannels } from "../services/doctor-events.js";
+export interface ActivityIndicator {
+    show(): void;
+    hide(): void;
+}
+export interface ToastHost {
+    sendToast(toast: Toast): void;
+}
+export interface EditorOperations {
+    setValue(value: string, fireEvent?: boolean): void;
+    getValue(): string;
+    setMarkers(problems: Problem[]): void;
+    clearAllMarkers(): void;
+    setReadOnly(readOnly: boolean): void;
+    revealLineInCenter(line: number): void;
+    toggleMinimap(): void;
+    clearDecorations(): void;
+    applyLinkDecorations(): void;
+    switchLanguage(language: string): void;
+    links: Reference[];
+    readonly breadcumb: {
+        isInvalid: boolean;
+    };
+}
+export interface EditorHost {
+    getEditor(id?: string): EditorOperations | undefined;
+    getDefaultEditor(): EditorOperations | undefined;
+}
+export interface StateHost {
+    getBag<T>(key: string): Bag<T> | undefined;
+    setBagValue<T>(bagKey: string, valueKey: string, value: T): void;
+    getBagValue<T>(bagKey: string, valueKey: string): T | undefined;
+    getBrokerId(): string;
+}
+export interface TabNavigation {
+    showTab(panel: string): void;
+    getSelectedTab(): string;
+}
+export interface RolodexStateAccess {
+    readonly activePath: string | undefined;
+    readonly activeHash: string | undefined;
+    readonly rootPath: string;
+    readonly rootHash: string;
+    needsReset: boolean;
+}
+export interface BusHost {
+    readonly bus: Bus;
+}
+export interface DoctorContext extends ToastHost, StateHost, BusHost {
+    readonly activity: ActivityIndicator;
+    readonly editorHost: EditorHost;
+    readonly controlTabs: TabNavigation;
+    readonly editorTabs: TabNavigation;
+    readonly rolodex: RolodexStateAccess;
+    readonly events: DoctorEventChannels;
+    readonly isAuthenticated: boolean;
+    readonly workspaceReadOnly: boolean;
+    requestUpdate(): void;
+}
+export interface WalletControllerDeps {
+    getBrokerId(): string;
+    sendToast(toast: Toast): void;
+}
+export interface GlobalTaskControllerDeps {
+    readonly bus: Bus;
+    sendToast(toast: Toast): void;
+    getBrokerId(): string;
+}
+export interface DiagramatronControllerDeps {
+    readonly activity: ActivityIndicator;
+    readonly doctorEndpoint?: string;
+    readonly isAuthenticated: boolean;
+    sendToast(toast: Toast): void;
+    getBrokerId(): string;
+}
+import type { Task, TaskAction } from "../model/task.js";
+import type { GraphResponse } from "../model/graph.js";
+import type { SpecSummary } from "../model/timeline.js";
+export interface TaskSubscription {
+    subscribeToTaskType(taskType: string, callback: (task: Task) => void, actions?: TaskAction[]): () => void;
+}
+export interface TimeVortexAccess {
+    getHistorySummary(): Promise<SpecSummary[] | undefined>;
+    historyPicker: {
+        deselectTimelineItems(): void;
+        updateComplete: Promise<boolean>;
+        loadSpecSummary(summary: SpecSummary): void;
+    };
+}
+export interface ProblemListAccess {
+    problems: Problem[];
+    problemItems: any[];
+    allProblemItems: any[];
+}
+export interface ProblemsOverviewAccess {
+    statistics: any;
+    problems: any[];
+}
+export interface ExplorerAccess {
+    updateGraphResponse(graph: GraphResponse): void;
+    readonly equalizer: {
+        maxNodes: number;
+        initializeEqualizer(): void;
+    };
+}
+export interface TimelineControllerDeps extends ToastHost, StateHost {
+    readonly editorHost: EditorHost;
+    readonly editorTabs: TabNavigation;
+    readonly navigatorTabs: TabNavigation;
+    readonly events: DoctorEventChannels;
+    readonly taskSubscription: TaskSubscription;
+    readonly timeVortex: TimeVortexAccess | null;
+    readonly problemList: ProblemListAccess;
+    readonly problemsOverview: ProblemsOverviewAccess;
+    readonly explorer: ExplorerAccess | null;
+    setViewingHistoricalViolations(viewing: boolean): void;
+    setProblems(problems: Problem[]): void;
+    getActiveWorkspaceId(): string | undefined;
+    dispatchEvent(event: Event): boolean;
+}
+export interface BrokerReadiness {
+    waitUntilReady(): Promise<void>;
+}
+export interface DrawerHost {
+    useAllSpace: boolean;
+    open(event: any): Promise<void>;
+}
+export interface DocsControllerDeps extends ToastHost, StateHost {
+    readonly activity: ActivityIndicator;
+    readonly doctorEndpoint: string;
+    readonly genericDrawer: DrawerHost;
+    readonly ruleDocsWorker: Worker;
+    ruleDocsBag: Bag<any> | undefined;
+    functionDocsBag: Bag<any> | undefined;
+    howToFixBag: Bag<any> | undefined;
+    activeURL: string;
+    platformUnavailable(error: any): void;
+    lintSpec(spec: string, url: string): void;
+}
+export interface GitHubControllerDeps extends ToastHost {
+    readonly githubStateBag: Bag<any> | undefined;
+    getBrokerId(): string;
+    reboot(): void;
+}
+export interface WorkspaceControllerDeps {
+    readonly brokerController: BrokerReadiness;
+    readonly walletController: any;
+    readonly host: any;
+    dispatchEvent(event: Event): boolean;
+    updateWorkspaceReadOnlyState(): void;
+}
+import type { Node, Reference, VacuumResult } from "../model/graph.js";
+export interface ModelTreeAccess {
+    nodeMap: Map<string, Node>;
+    violationMap: Map<string, VacuumResult>;
+    node: Node | null;
+}
+export interface ExtendedEditorAccess {
+    clearDecorations(): void;
+    clearAllMarkers(): void;
+    applyLinkDecorations(): void;
+    links: Reference[];
+    showBreadcrumb: boolean;
+    setValue(value: string, fireEvent?: boolean): void;
+    readonly editor?: any;
+}
+export interface ExtendedExplorerAccess {
+    nodeLimitExceeded: boolean;
+    updateGraphResponse(graph: GraphResponse): void;
+}
+export interface TardisModelTreeAccess {
+    readonly tardisControl: {
+        readonly modelTree: ModelTreeAccess;
+        showDiffTab(): void;
+        readonly diffEditor: any;
+    };
+}
+export interface ModelControllerDeps extends ToastHost {
+    readonly editor: ExtendedEditorAccess;
+    readonly explorer: ExtendedExplorerAccess;
+    readonly modelTree: ModelTreeAccess;
+    readonly timeVortex: TardisModelTreeAccess | null;
+    readonly graphBag: Bag<GraphResponse> | undefined;
+    references: Reference[];
+    updateRefmapBag(currentPath: string, result: Reference[]): void;
+}
+export interface RolodexTreeAccess {
+    isRolodex: boolean;
+    nodeMap: Map<string, Node>;
+    childrenRendered: Set<string>;
+    expandedNodes: Map<string, Node>;
+    node: Node | null;
+    pendingNavigationId: string | undefined;
+    pendingNavigationPath: string | undefined;
+    openNodeByPath(path: string): void;
+    requestUpdate(): void;
+}
+export interface RolodexControllerDeps extends StateHost {
+    readonly editor: ExtendedEditorAccess;
+    readonly modelController: {
+        fetchRefMap(currentPath?: string): void;
+    };
+    readonly rolodexTree: RolodexTreeAccess;
+    readonly rolodexStateBag: Bag<any> | undefined;
+    readonly rolodexResponseBag: Bag<any> | undefined;
+    rolodexActivePath: string | undefined;
+    rolodexActiveHash: string | undefined;
+    rolodexRootPath: string;
+    rolodexRootHash: string;
+    rolodexNeedsReset: boolean;
+    rolodexRoot: Node;
+    rolodexProblemMap: Map<string, Problem[]>;
+    importDisabled: boolean;
+    lintSpec(spec: string): void;
+    loadStoredDiagnostics(): Promise<void>;
+    requestUpdate(): void;
+}
+export interface PanelTabSwitch {
+    showTab(panel: string): void;
+}
+export interface ProblemControllerDeps {
+    readonly viewingHistoricalViolations: boolean;
+    readonly rolodexRoot: Node;
+    readonly rolodexRootPath: string;
+    readonly modelController: any;
+    readonly nodeClickerController: {
+        rolodexTreeNodeClicked(event: CustomEvent<any>): void;
+    };
+    readonly rolodexTree: RolodexTreeAccess;
+    readonly editorPanel: PanelTabSwitch | null;
+    readonly sidebarPanel: PanelTabSwitch | null;
+    readonly problemList: ProblemListAccess & {
+        lineClicked(line: number): void;
+    };
+    readonly editor: ExtendedEditorAccess;
+    readonly genericDrawer: {
+        close(): void;
+    };
+    readonly timeVortex: TardisModelTreeAccess | null;
+    selectedEditorTab: string;
+    selectTardis(): void;
+}
+import type { RenderMap, RuleConfig, RuleSet } from "../model/vacuum_rule.js";
+export interface SidebarPanelAccess extends PanelTabSwitch {
+    readonly tabGroup?: {
+        querySelector(selector: string): Element | null;
+    };
+}
+export interface SpecControllerDeps {
+    readonly docBag: Bag<string> | undefined;
+    readonly graphBag: Bag<GraphResponse> | undefined;
+    readonly sessionRulesetMapBag: Bag<RenderMap> | undefined;
+    readonly autoDiagnose: boolean;
+    readonly isBundled: boolean;
+    readonly selectedEditorTab: string;
+    readonly sidebarClosed: boolean;
+    readonly editorMap: Map<string, any>;
+    readonly genericDrawer: {
+        close(): void;
+    };
+    readonly problemList: {
+        lineClicked(line: number, scroll?: boolean): void;
+    };
+    readonly modelTree: {
+        explorerClicked(nodeId: string): void;
+    };
+    readonly sidebarPanel: SidebarPanelAccess | null;
+    readonly modelController: {
+        nodeMap: Map<string, Node>;
+        renderedNodeComponent: {
+            node: Node | null;
+        };
+    };
+    setExplorerActiveNode(node: Node): void;
+    setEditorDirty(dirty: boolean): void;
+    openSidebar(): void;
+    lintSpec(content: string): void;
+    rulesetManuallyChanged(): void;
+}
+export interface RulesetEditorAccess {
+    getValue(): string;
+    setValue(value: string, fireEvent?: boolean): void;
+    setMarkers(markers: any[]): void;
+    setPosition(position: {
+        lineNumber: number;
+        column: number;
+    }): void;
+    revealLineInCenter(line: number): void;
+}
+export interface ManageRulesetAccess {
+    clearRuleProblems(): void;
+    processBadRules(errors: any[]): void;
+    setCustomRulesetManual(ruleset: RuleSet | undefined): void;
+    buildRulesets(): void;
+    customRulesetManual: RuleSet | undefined;
+    defaultRuleset: RuleSet | undefined;
+    owaspRuleset: RuleSet | undefined;
+    allRuleset: RuleSet | undefined;
+    functions: string[] | undefined;
+    rulesetConfig: RuleConfig | undefined;
+    customRuleset: RuleSet | undefined;
+}
+export interface RuleControllerDeps extends ToastHost {
+    readonly docBag: Bag<string> | undefined;
+    readonly customRulesetBag: Bag<RuleSet> | undefined;
+    readonly ruleConfigBag: Bag<RuleConfig> | undefined;
+    readonly sessionRulesetMapBag: Bag<RenderMap> | undefined;
+    readonly sessionRulesetYamlBag: Bag<string> | undefined;
+    readonly allRulesetBag: Bag<RuleSet> | undefined;
+    readonly defaultRulesetBag: Bag<RuleSet> | undefined;
+    readonly OWASPRulesetBag: Bag<RuleSet> | undefined;
+    readonly rulesetEditor: RulesetEditorAccess;
+    readonly manageRuleset: ManageRulesetAccess;
+    readonly problemList: {
+        dispatchEvent(event: Event): boolean;
+    };
+    readonly editorPanel: PanelTabSwitch | null;
+    readonly sidebarPanel: PanelTabSwitch | null;
+    readonly downloadRulesetLink: HTMLAnchorElement;
+    readonly exportRulesetDialog: {
+        hide(): void;
+    };
+    readonly rolodexActivePath: string | undefined;
+    selectedEditorTab: string;
+    rulesetPulse: boolean;
+    customRuleset: RuleSet | undefined;
+    allRuleset: RuleSet | undefined;
+    defaultRuleset: RuleSet | undefined;
+    OWASPRuleset: RuleSet | undefined;
+    getSessionId(): string;
+    lintSpec(content: string, path?: string): void;
+}
+import type { DrDiagnostics } from "../model/document-statistics.js";
+import type { PlatformError } from "../model/errors.js";
+export interface DiagnosticEditorAccess {
+    readonly breadcumb: {
+        isInvalid: boolean;
+    };
+    showBreadcrumb: boolean;
+    setMarkers(problems: Problem[]): void;
+    clearAllMarkers(): void;
+    clearDecorations(): void;
+    dead(): void;
+    revive(): void;
+}
+export interface DiagnosticProblemListAccess {
+    problems: Problem[];
+    readonly problemItems: any[];
+    readonly allProblemItems: any[];
+    isInvalid: boolean;
+}
+export interface DiagnosticProblemsOverviewAccess {
+    problems: any[];
+    statistics: DrDiagnostics | null;
+}
+export interface DiagnosticExplorerAccess {
+    readonly equalizer: {
+        maxNodes: number;
+        initializeEqualizer(): void;
+    };
+}
+export interface DiagnosticControllerDeps extends ToastHost, StateHost {
+    readonly activity: ActivityIndicator;
+    readonly editor: DiagnosticEditorAccess;
+    readonly problemList: DiagnosticProblemListAccess;
+    readonly problemsOverview: DiagnosticProblemsOverviewAccess;
+    readonly explorer: DiagnosticExplorerAccess | null;
+    readonly creditTicker: {
+        credits: number;
+    } | null;
+    readonly statusBar: {
+        visible: boolean;
+    };
+    readonly timeVortex: {
+        getHistorySummary(): Promise<any>;
+    } | null;
+    rolodexActivePath: string | undefined;
+    rolodexRootPath: string;
+    readonly rolodexNeedsReset: boolean;
+    readonly rolodexRoot: Node | null;
+    readonly rolodexProblemMap: Map<string, Problem[]>;
+    problems: Problem[];
+    explorerBooted: boolean;
+    readonly skipTimeline: boolean;
+    readonly isAuthenticated: boolean;
+    readonly referenceMapBag: Bag<any> | undefined;
+    readonly problemBag: Bag<Problem[]> | undefined;
+    readonly diagnosticBag: Bag<DrDiagnostics> | undefined;
+    readonly settingsBag: Bag<any> | undefined;
+    showUrlLoading(): void;
+    hideUrlError(): void;
+    showUrlError(error: PlatformError): void;
+    buildRolodexResultMap(problems: Problem[]): Map<string, Problem[]>;
+    queryRolodex(path?: string): void;
+    fetchRefMap(path?: string): void;
+    extractGraph(graph: GraphResponse): void;
+    updateSpecProblems(problems: Problem[]): void;
+    readonly brokerConnectionId: string;
+}
+export interface BrokerControllerDeps extends EventTarget {
+    readonly bus: Bus;
+    readonly authController: {
+        associateBroker(brokerId: string): Promise<boolean>;
+        readonly authenticated: boolean;
+    };
+    readonly globalTaskController: {
+        init(): void;
+    };
+    readonly timelineController: {
+        init(): void;
+    };
+    readonly bagManager: {
+        resetBags(): void;
+    };
+    readonly docBag: Bag<string> | undefined;
+    readonly editor: {
+        setValue(value: string, skipBroker: boolean): void;
+    } | null;
+    readonly creditTicker: {
+        credits: number;
+    };
+    nukeWorkspaceHandler(): void;
+    boostrap(): void;
+    requestUpdate(): void;
+}
+export interface StateControllerDeps {
+    readonly settingsBag: Bag<any> | undefined;
+    readonly rolodexResponseBag: Bag<any> | undefined;
+    readonly rolodexStateBag: Bag<any> | undefined;
+    readonly referenceMapBag: Bag<any> | undefined;
+    readonly docBag: Bag<string> | undefined;
+    problemBag: Bag<Problem[]> | undefined;
+    howToFixBag: Bag<any> | undefined;
+    diagnosticBag: Bag<DrDiagnostics> | undefined;
+    readonly graphBag: Bag<GraphResponse> | undefined;
+    readonly panelStateBag: Bag<any> | undefined;
+    defaultRulesetBag: Bag<RuleSet> | undefined;
+    OWASPRulesetBag: Bag<RuleSet> | undefined;
+    allRulesetBag: Bag<RuleSet> | undefined;
+    functionsBag: Bag<any> | undefined;
+    functionSchemaBag: Bag<any> | undefined;
+    customRulesetBag: Bag<RuleSet> | undefined;
+    ruleConfigBag: Bag<RuleConfig> | undefined;
+    sessionRulesetMapBag: Bag<any> | undefined;
+    sessionRulesetYamlBag: Bag<string> | undefined;
+    readonly editor: EditorOperations | undefined;
+    readonly rulesetEditor: EditorOperations | undefined;
+    readonly rolodexTree: RolodexTreeAccess | null;
+    readonly modelTree: ModelTreeAccess | null;
+    readonly explorer: ExplorerAccess | null;
+    readonly problemList: ProblemListAccess | null;
+    readonly problemsOverview: ProblemsOverviewAccess | null;
+    readonly manageRuleset: ManageRulesetAccess | null;
+    readonly settingsComponent: {
+        settings: any;
+        settingsBag?: Bag<any>;
+        bootstrap?(): void;
+    } | null;
+    readonly splitPanelExplorer: {
+        position: number;
+    } | null;
+    readonly splitPanelInspector: {
+        position: number;
+    } | null;
+    readonly modelController: {
+        extractGraph(graph: GraphResponse): void;
+        fetchRefMap(path?: string): void;
+    };
+    readonly specController: {
+        updateProblems(problems: Problem[]): void;
+    };
+    readonly rolodexController: {
+        buildRolodexResultMap(problems: Problem[]): Map<string, Problem[]>;
+        queryRolodex(path?: string): void;
+    };
+    readonly ruleController: {
+        fetchDefaultRuleset(): Promise<RuleSet>;
+        fetchOWASPRuleset(): Promise<RuleSet>;
+        fetchAllRuleset(): Promise<RuleSet>;
+        fetchSessionRulesetAsYaml(): Promise<string>;
+        fetchRulesetMap(): void;
+    };
+    readonly docsController: {
+        fetchDocs(): void;
+    };
+    readonly bagManager: {
+        getBag<T>(key: string): Bag<T> | undefined;
+    };
+    settingsChanged(key: string, settings: any): void;
+    platformUnavailable(error: any): void;
+    requestUpdate(): void;
+    rolodexDividerPosition: number;
+    explorerDividerPosition: number;
+    inspectorDividerPosition: number;
+    rolodexActivePath: string | undefined;
+    rolodexActiveHash: string | undefined;
+    rolodexRoot: Node | null;
+    rolodexRootPath: string;
+    rolodexRootHash: string;
+    rolodexNeedsReset: boolean;
+    readonly rolodexProblemMap: Map<string, Problem[]>;
+    references: Reference[];
+    problems: Problem[];
+    defaultRuleset: RuleSet | undefined;
+    OWASPRuleset: RuleSet | undefined;
+    allRuleset: RuleSet | undefined;
+    functions: string[] | undefined;
+    customRuleset: RuleSet | undefined;
+}

package/dist/interfaces/doctor-interfaces.js

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