@pb33f/cowboy-components 0.7.18 → 0.8.0

package/dist/model/graph.d.ts

@@ -1,3 +1,4 @@
+import { ModelController } from "../controllers/model-controller";
 export interface Node {
     id: string;
     idHash: string;
@@ -13,11 +14,11 @@ export interface Node {
     active?: boolean;
     instance: any;
     label: string;
-    nodes: Node[];
+    nodes: string[];
     keyLine: number;
     valueLine: number;
     type: string;
-    results?: VacuumResult[];
+    violationIds?: string[];
     isArray?: boolean;
     arrayValues?: number;
     propertyCount?: number;
@@ -74,13 +75,6 @@ export interface Spacing {
     bendEdges?: boolean;
     bendPoints?: boolean;
 }
-export interface References {
-    renderRefs?: boolean;
-    renderPoly?: boolean;
-}
-export interface Options {
-    dimDependents?: boolean;
-}
 export interface GraphVersion {
     graphId?: string;
     revisionId?: string;
@@ -88,19 +82,19 @@ export interface GraphVersion {
 }
 export interface GraphResponse {
     nodes: Node[];
-    nodesRendered: Node[];
-    nodesChanged?: Node[];
     changes?: Change[];
     edges: Edge[];
     spacing?: Spacing;
-    references?: References;
     graphMap?: {
         [key: string]: string;
     };
-    stripped?: boolean;
-    strippedCount?: number;
+    violations?: {
+        [key: string]: VacuumResult;
+    };
     rebuild?: boolean;
     nodeChangeTree?: Node;
+    stripped?: boolean;
+    strippedCount?: number;
 }
 export interface VacuumResult {
     message: string;
@@ -108,6 +102,12 @@ export interface VacuumResult {
     ruleId: string;
     ruleSeverity: string;
 }
+export interface ViolationCounts {
+    errors: number;
+    warnings: number;
+    info: number;
+}
+export declare function countViolationsBySeverity(node: Node | null | undefined, violationMap: Map<string, VacuumResult> | null | undefined): ViolationCounts;
 export interface Reference {
     definition: string;
     fullDefinition: string;
@@ -120,4 +120,4 @@ export interface Reference {
     isPolymorphic: boolean;
     rolodexIdHash?: string;
 }
-export declare function SearchNodeTreeForPath(node: Node, path: string): Node | null;
+export declare function SearchNodeTreeForPath(node: Node, path: string, modelController: ModelController): Node | null;

package/dist/model/graph.js

@@ -1,4 +1,21 @@
-export function SearchNodeTreeForPath(node, path) {
+export function countViolationsBySeverity(node, violationMap) {
+    const counts = { errors: 0, warnings: 0, info: 0 };
+    if (!node?.violationIds || !violationMap)
+        return counts;
+    for (const id of node.violationIds) {
+        const result = violationMap.get(id);
+        if (!result)
+            continue;
+        if (result.ruleSeverity === 'error')
+            counts.errors++;
+        else if (result.ruleSeverity === 'warn')
+            counts.warnings++;
+        else
+            counts.info++;
+    }
+    return counts;
+}
+export function SearchNodeTreeForPath(node, path, modelController) {
     if (!node) {
         return null;
     }
@@ -7,9 +24,12 @@ export function SearchNodeTreeForPath(node, path) {
     }
     if (node.nodes && node.nodes.length > 0) {
         for (let n of node.nodes) {
-            let found = SearchNodeTreeForPath(n, path);
-            if (found) {
-                return found;
+            const locatedNode = modelController.nodeMap.get(n);
+            if (locatedNode) {
+                let found = SearchNodeTreeForPath(locatedNode, path, modelController);
+                if (found) {
+                    return found;
+                }
             }
         }
     }

package/dist/model/media-type.js

@@ -17,8 +17,8 @@ export function extractExtensions(obj) {
 }
 export function extractDocumentExtensions(obj) {
     const map = new Map;
-    for (let key in obj.extensionData) {
-        map.set(key, obj.extensionData[key]);
+    for (let key in obj?.extensionData) {
+        map.set(key, obj?.extensionData[key]);
     }
     return map;
 }

package/dist/model/node_type.d.ts

@@ -1,6 +1,8 @@
 export declare enum NodeType {
     VERSION = "version",
     SCHEMA = "schema",
+    SCHEMAS = "schemas",
+    SCHEMA_TYPES = "types",
     MEDIA_TYPE = "mediaType",
     HEADER = "header",
     EXAMPLE = "example",
@@ -53,6 +55,8 @@ export declare enum NodeType {
     UPLOAD = "upload",
     ADD = "add",
     UNKNOWN = "unknown",
+    EXPAND_NODE = "expand-node",
+    POV_MODE = "pov-mode",
     JS = "js",
     GO = "go",
     TS = "ts",

package/dist/model/node_type.js

@@ -2,6 +2,8 @@ export var NodeType;
 (function (NodeType) {
     NodeType["VERSION"] = "version";
     NodeType["SCHEMA"] = "schema";
+    NodeType["SCHEMAS"] = "schemas";
+    NodeType["SCHEMA_TYPES"] = "types";
     NodeType["MEDIA_TYPE"] = "mediaType";
     NodeType["HEADER"] = "header";
     NodeType["EXAMPLE"] = "example";
@@ -54,6 +56,8 @@ export var NodeType;
     NodeType["UPLOAD"] = "upload";
     NodeType["ADD"] = "add";
     NodeType["UNKNOWN"] = "unknown";
+    NodeType["EXPAND_NODE"] = "expand-node";
+    NodeType["POV_MODE"] = "pov-mode";
     NodeType["JS"] = "js";
     NodeType["GO"] = "go";
     NodeType["TS"] = "ts";

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

@@ -2,4 +2,5 @@ export interface PanelState {
     explorerPanel?: number;
     rolodexPanel?: number;
     inspectorPanel?: number;
+    minimapVisible?: boolean;
 }

package/dist/model/rolodex.d.ts

@@ -2,6 +2,7 @@ import { DocumentStatistics } from "./document-statistics";
 import { Node, Reference } from "./graph";
 export interface RolodexResponse {
     rolodexRoot: Node;
+    nodes: Node[];
     statistics: DocumentStatistics;
 }
 export interface ArchiveFileResponse {
@@ -26,9 +27,11 @@ export interface ReferenceMap {
 }
 export interface RolodexState {
     activePath?: string;
+    activeId?: string;
     activeHash?: string;
     activeLanguage?: string;
     activeNode?: Node;
+    rootId?: string;
     rootHash?: string;
     rootPath?: string;
 }

package/dist/model/task.d.ts

@@ -0,0 +1,50 @@
+export interface Task {
+    id: string;
+    type: string;
+    parentId?: string;
+    userId: string;
+    workspaceId?: string;
+    name: string;
+    message?: string;
+    status: 'active' | 'completed' | 'failed';
+    progress: number;
+    totalSteps: number;
+    currentStep: number;
+    startedAt: number;
+    updatedAt: number;
+    completedAt?: number;
+    error?: string;
+    subtasks?: Task[];
+}
+export declare enum TaskAction {
+    Create = "create",
+    Update = "update",
+    Complete = "complete",
+    Fail = "fail"
+}
+export interface TaskMessage {
+    action: TaskAction;
+    task: Task;
+}
+export interface TaskListResponse {
+    tasks: Task[];
+    count: number;
+}
+export declare enum TaskType {
+    GitHubImport = "github-import",
+    GitHubImportFile = "github-import-file",
+    GitHubImportDetail = "github-import-detail",
+    GitHubScan = "github-scan",
+    GitHubClone = "github-clone",
+    PrChange = "pr_change"
+}
+export declare enum TaskStatus {
+    Active = "active",
+    Completed = "completed",
+    Failed = "failed"
+}
+export interface TaskTypeSubscription {
+    taskType: string;
+    actions: TaskAction[];
+    callback: (task: Task) => void;
+}

package/dist/model/task.js

@@ -0,0 +1,22 @@
+export var TaskAction;
+(function (TaskAction) {
+    TaskAction["Create"] = "create";
+    TaskAction["Update"] = "update";
+    TaskAction["Complete"] = "complete";
+    TaskAction["Fail"] = "fail";
+})(TaskAction || (TaskAction = {}));
+export var TaskType;
+(function (TaskType) {
+    TaskType["GitHubImport"] = "github-import";
+    TaskType["GitHubImportFile"] = "github-import-file";
+    TaskType["GitHubImportDetail"] = "github-import-detail";
+    TaskType["GitHubScan"] = "github-scan";
+    TaskType["GitHubClone"] = "github-clone";
+    TaskType["PrChange"] = "pr_change";
+})(TaskType || (TaskType = {}));
+export var TaskStatus;
+(function (TaskStatus) {
+    TaskStatus["Active"] = "active";
+    TaskStatus["Completed"] = "completed";
+    TaskStatus["Failed"] = "failed";
+})(TaskStatus || (TaskStatus = {}));

package/dist/model/timeline.d.ts

@@ -1,4 +1,23 @@
-import { LineDataSet } from "../components/charts/config";
+import { LineDataSet } from "../components/charts/config.js";
+import { Problem } from "./problem.js";
+import { DrDiagnostics } from "./document-statistics.js";
+export interface SpecChange {
+    changeId: string;
+    gitChange: boolean;
+    gitCommitSha?: string;
+    gitBranch?: string;
+    gitAuthor?: string;
+    gitMessage?: string;
+    gitPrNumber?: number;
+    gitPrTitle?: string;
+    gitPrUrl?: string;
+    gitRepositoryId?: string;
+    gitRepositoryName?: string;
+    isEphemeral: boolean;
+    ephemeralExpiresAt?: string;
+    createdAt: string;
+    updatedAt: string;
+}
 export interface SpecSummary {
     summaryId?: string;
     changeId?: string;
@@ -20,6 +39,76 @@ export interface SpecSummary {
     wentDown?: boolean;
     wentUp?: boolean;
     scoreVariance?: number;
+    isEphemeral?: boolean;
+    gitChange?: boolean;
+    gitCommitSha?: string;
+    gitBranch?: string;
+    gitAuthor?: string;
+    gitMessage?: string;
+    gitPrNumber?: number;
+    gitPrTitle?: string;
+    gitPrUrl?: string;
+    gitRepositoryId?: string;
+    gitRepositoryName?: string;
+    ephemeralExpiresAt?: string;
+}
+export type PRChangeType = "pull_request" | "branch";
+export interface PRChangeResponse {
+    changeId: string;
+    changeType: PRChangeType;
+    prNumber?: number;
+    prTitle?: string;
+    prUrl?: string;
+    branchName: string;
+    commitSha: string;
+    author?: string;
+    totalChanges: number;
+    breakingChanges: number;
+    additions: number;
+    modifications: number;
+    removals: number;
+    lintingScore: number;
+    errors: number;
+    warnings: number;
+    lastUpdated: string;
+    expiresAt?: string;
+    daysUntilExpiry?: number;
+    repositoryName?: string;
+}
+export interface ChangeMetadata {
+    changeId: string;
+    isEphemeral?: boolean;
+    gitChange?: boolean;
+    gitBranch?: string;
+    gitCommitSha?: string;
+    gitPrNumber?: number;
+    gitPrTitle?: string;
+    gitRepositoryName?: string;
+}
+export interface ComparisonSummary {
+    totalChanges: number;
+    breakingChanges: number;
+    additions: number;
+    modifications: number;
+    removals: number;
+}
+export interface CompareRequest {
+    leftChangeId: string;
+    rightChangeId?: string;
+    compareToMain?: boolean;
+}
+export interface ToolsCompareRequest {
+    rightSpec: string;
+}
+export interface ToolsCompareResponse {
+    changeId: string;
+    summary: SpecSummary;
+}
+export interface CompareResponse {
+    leftChange: ChangeMetadata;
+    rightChange: ChangeMetadata;
+    changes: any;
+    summary: ComparisonSummary;
 }
 export interface ChartResult {
     labels: string[];
@@ -31,3 +120,20 @@ export interface ChangeHistory {
     violationData: ChartResult | null;
     changeIds: string[];
 }
+export interface StatisticsDelta {
+    previousScore: number;
+    scoreDelta: number;
+    errorsDelta: number;
+    warningsDelta: number;
+    infosDelta: number;
+}
+export interface ChangeViolationsResponse {
+    changeId: string;
+    total: number;
+    violations: Problem[];
+}
+export interface ChangeStatisticsResponse {
+    changeId: string;
+    statistics: DrDiagnostics;
+    delta?: StatisticsDelta;
+}

package/dist/model/tree-icon-config.d.ts

@@ -0,0 +1,11 @@
+import { NodeType } from "./node_type.js";
+export interface TreeIconVisibility {
+    showOnLeaf: boolean;
+    showOnBranch: boolean;
+    onlyWithIssues?: boolean;
+}
+export type TreeIconConfig = {
+    [key in NodeType]?: TreeIconVisibility;
+};
+export declare const defaultIconConfig: TreeIconConfig;
+export declare function shouldShowIcon(nodeType: NodeType | string, isLeaf: boolean, hasIssues: boolean, config: TreeIconConfig): boolean;

package/dist/model/tree-icon-config.js

@@ -0,0 +1,46 @@
+import { NodeType } from "./node_type.js";
+export const defaultIconConfig = {
+    [NodeType.DOCUMENT]: { showOnLeaf: true, showOnBranch: true },
+    [NodeType.PATHS]: { showOnLeaf: true, showOnBranch: true },
+    [NodeType.COMPONENTS]: { showOnLeaf: true, showOnBranch: true },
+    [NodeType.INFO]: { showOnLeaf: true, showOnBranch: true },
+    [NodeType.CONTACT]: { showOnLeaf: true, showOnBranch: true },
+    [NodeType.LICENSE]: { showOnLeaf: true, showOnBranch: true },
+    [NodeType.SERVERS]: { showOnLeaf: true, showOnBranch: true },
+    [NodeType.SERVER]: { showOnLeaf: true, showOnBranch: true },
+    [NodeType.TAGS]: { showOnLeaf: true, showOnBranch: true },
+    [NodeType.TAG]: { showOnLeaf: true, showOnBranch: true },
+    [NodeType.SECURITY_SCHEMES]: { showOnLeaf: true, showOnBranch: true },
+    [NodeType.SECURITY_SCHEME]: { showOnLeaf: true, showOnBranch: true },
+    [NodeType.WEBHOOKS]: { showOnLeaf: true, showOnBranch: true },
+    [NodeType.WEBHOOK]: { showOnLeaf: true, showOnBranch: true },
+    [NodeType.EXTERNAL_DOCS]: { showOnLeaf: true, showOnBranch: true },
+    [NodeType.EXAMPLE]: { showOnLeaf: true, showOnBranch: true },
+    [NodeType.EXAMPLES]: { showOnLeaf: true, showOnBranch: true },
+    [NodeType.LINK]: { showOnLeaf: true, showOnBranch: true },
+    [NodeType.LINKS]: { showOnLeaf: true, showOnBranch: true },
+    [NodeType.CALLBACK]: { showOnLeaf: true, showOnBranch: true },
+    [NodeType.CALLBACKS]: { showOnLeaf: true, showOnBranch: true },
+    [NodeType.EXTENSIONS]: { showOnLeaf: true, showOnBranch: true },
+    [NodeType.EXTENSION]: { showOnLeaf: true, showOnBranch: true },
+    [NodeType.ROLODEX_FILE]: { showOnLeaf: true, showOnBranch: true },
+    [NodeType.ROLODEX_FOLDER]: { showOnLeaf: true, showOnBranch: true },
+    [NodeType.SECURITY]: { showOnLeaf: true, showOnBranch: true },
+    [NodeType.PARAMETERS]: { showOnLeaf: true, showOnBranch: true },
+    [NodeType.HEADERS]: { showOnLeaf: true, showOnBranch: true },
+    [NodeType.RESPONSES]: { showOnLeaf: true, showOnBranch: true },
+    [NodeType.REQUEST_BODIES]: { showOnLeaf: true, showOnBranch: true },
+    [NodeType.REQUEST_BODY]: { showOnLeaf: true, showOnBranch: true },
+    [NodeType.PATH_ITEMS]: { showOnLeaf: true, showOnBranch: true },
+    [NodeType.SCHEMAS]: { showOnLeaf: true, showOnBranch: true },
+};
+export function shouldShowIcon(nodeType, isLeaf, hasIssues, config) {
+    const visibility = config[nodeType];
+    if (!visibility) {
+        return false;
+    }
+    if (visibility.onlyWithIssues) {
+        return hasIssues;
+    }
+    return isLeaf ? visibility.showOnLeaf : visibility.showOnBranch;
+}

package/dist/model/workspace.d.ts

@@ -3,4 +3,6 @@ export interface Workspace {
     workspaceId?: string;
     active: boolean;
     default?: boolean;
+    linkedRepo?: string;
+    readOnly?: boolean;
 }

package/dist/ordinal-DfAQgscy.js

@@ -0,0 +1,61 @@
+import { i as a } from "./init-DjUOC4st.js";
+class o extends Map {
+  constructor(n, t = g) {
+    if (super(), Object.defineProperties(this, { _intern: { value: /* @__PURE__ */ new Map() }, _key: { value: t } }), n != null) for (const [r, s] of n) this.set(r, s);
+  }
+  get(n) {
+    return super.get(c(this, n));
+  }
+  has(n) {
+    return super.has(c(this, n));
+  }
+  set(n, t) {
+    return super.set(l(this, n), t);
+  }
+  delete(n) {
+    return super.delete(p(this, n));
+  }
+}
+function c({ _intern: e, _key: n }, t) {
+  const r = n(t);
+  return e.has(r) ? e.get(r) : t;
+}
+function l({ _intern: e, _key: n }, t) {
+  const r = n(t);
+  return e.has(r) ? e.get(r) : (e.set(r, t), t);
+}
+function p({ _intern: e, _key: n }, t) {
+  const r = n(t);
+  return e.has(r) && (t = e.get(r), e.delete(r)), t;
+}
+function g(e) {
+  return e !== null && typeof e == "object" ? e.valueOf() : e;
+}
+const f = Symbol("implicit");
+function h() {
+  var e = new o(), n = [], t = [], r = f;
+  function s(u) {
+    let i = e.get(u);
+    if (i === void 0) {
+      if (r !== f) return r;
+      e.set(u, i = n.push(u) - 1);
+    }
+    return t[i % t.length];
+  }
+  return s.domain = function(u) {
+    if (!arguments.length) return n.slice();
+    n = [], e = new o();
+    for (const i of u)
+      e.has(i) || e.set(i, n.push(i) - 1);
+    return s;
+  }, s.range = function(u) {
+    return arguments.length ? (t = Array.from(u), s) : t.slice();
+  }, s.unknown = function(u) {
+    return arguments.length ? (r = u, s) : r;
+  }, s.copy = function() {
+    return h(n, t).unknown(r);
+  }, a.apply(s, arguments), s;
+}
+export {
+  h as o
+};

package/dist/packet-BFZMPI3H-CXPCK9Q2.js

@@ -0,0 +1,5 @@
+import { P as c, a as r } from "./mermaid-parser.core-BPror82d.js";
+export {
+  c as PacketModule,
+  r as createPacketServices
+};

package/dist/pie-7BOR55EZ-CMcuUZ_S.js

@@ -0,0 +1,5 @@
+import { b as a, d as i } from "./mermaid-parser.core-BPror82d.js";
+export {
+  a as PieModule,
+  i as createPieServices
+};