state sync

app/basepak/static/js/mermaid/diagrams/architecture/architecture.spec.d.ts

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

app/basepak/static/js/mermaid/diagrams/architecture/architectureDb.d.ts

@@ -0,0 +1,45 @@
+import type { ArchitectureDiagramConfig } from '../../config.type.js';
+import type { DiagramDB } from '../../diagram-api/types.js';
+import type { D3Element } from '../../types.js';
+import type { ArchitectureEdge, ArchitectureGroup, ArchitectureJunction, ArchitectureNode, ArchitectureService } from './architectureTypes.js';
+export declare class ArchitectureDB implements DiagramDB {
+    private nodes;
+    private groups;
+    private edges;
+    private registeredIds;
+    private dataStructures?;
+    private elements;
+    constructor();
+    clear(): void;
+    addService({ id, icon, in: parent, title, iconText, }: Omit<ArchitectureService, 'edges'>): void;
+    getServices(): ArchitectureService[];
+    addJunction({ id, in: parent }: Omit<ArchitectureJunction, 'edges'>): void;
+    getJunctions(): ArchitectureJunction[];
+    getNodes(): ArchitectureNode[];
+    getNode(id: string): ArchitectureNode | null;
+    addGroup({ id, icon, in: parent, title }: ArchitectureGroup): void;
+    getGroups(): ArchitectureGroup[];
+    addEdge({ lhsId, rhsId, lhsDir, rhsDir, lhsInto, rhsInto, lhsGroup, rhsGroup, title, }: ArchitectureEdge): void;
+    getEdges(): ArchitectureEdge[];
+    /**
+     * Returns the current diagram's adjacency list, spatial map, & group alignments.
+     * If they have not been created, run the algorithms to generate them.
+     * @returns
+     */
+    getDataStructures(): import("./architectureTypes.js").ArchitectureDataStructures;
+    setElementForId(id: string, element: D3Element): void;
+    getElementById(id: string): D3Element;
+    getConfig(): Required<ArchitectureDiagramConfig>;
+    getConfigField<T extends keyof ArchitectureDiagramConfig>(field: T): Required<ArchitectureDiagramConfig>[T];
+    setAccTitle: (txt: string) => void;
+    getAccTitle: () => string;
+    setDiagramTitle: (txt: string) => void;
+    getDiagramTitle: () => string;
+    getAccDescription: () => string;
+    setAccDescription: (txt: string) => void;
+}
+/**
+ * Typed wrapper for resolving an architecture diagram's config fields. Returns the default value if undefined
+ * @param field - the config field to access
+ * @returns
+ */

app/basepak/static/js/mermaid/diagrams/architecture/architectureDetector.d.ts

@@ -0,0 +1,3 @@
+import type { ExternalDiagramDefinition } from '../../diagram-api/types.js';
+declare const architecture: ExternalDiagramDefinition;
+export default architecture;

app/basepak/static/js/mermaid/diagrams/architecture/architectureDiagram.d.ts

@@ -0,0 +1,2 @@
+import type { DiagramDefinition } from '../../diagram-api/types.js';
+export declare const diagram: DiagramDefinition;

app/basepak/static/js/mermaid/diagrams/architecture/architectureIcons.d.ts

@@ -0,0 +1,2 @@
+import type { IconifyJSON } from '@iconify/types';
+export declare const architectureIcons: IconifyJSON;

app/basepak/static/js/mermaid/diagrams/architecture/architectureParser.d.ts

@@ -0,0 +1,2 @@
+import type { ParserDefinition } from '../../diagram-api/types.js';
+export declare const parser: ParserDefinition;

app/basepak/static/js/mermaid/diagrams/architecture/architectureRenderer.d.ts

@@ -0,0 +1,5 @@
+import type { DrawDefinition } from '../../diagram-api/types.js';
+export declare const draw: DrawDefinition;
+export declare const renderer: {
+    draw: DrawDefinition;
+};

app/basepak/static/js/mermaid/diagrams/architecture/architectureStyles.d.ts

@@ -0,0 +1,3 @@
+import type { DiagramStylesProvider } from '../../diagram-api/types.js';
+declare const getStyles: DiagramStylesProvider;
+export default getStyles;

app/basepak/static/js/mermaid/diagrams/architecture/architectureTypes.d.ts

@@ -0,0 +1,227 @@
+import type { DiagramDBBase } from '../../diagram-api/types.js';
+import type { ArchitectureDiagramConfig } from '../../config.type.js';
+import type { D3Element } from '../../types.js';
+import type cytoscape from 'cytoscape';
+export type ArchitectureAlignment = 'vertical' | 'horizontal' | 'bend';
+export type ArchitectureDirection = 'L' | 'R' | 'T' | 'B';
+export type ArchitectureDirectionX = Extract<ArchitectureDirection, 'L' | 'R'>;
+export type ArchitectureDirectionY = Extract<ArchitectureDirection, 'T' | 'B'>;
+/**
+ * Contains LL, RR, TT, BB which are impossible connections
+ */
+export type InvalidArchitectureDirectionPair = `${ArchitectureDirection}${ArchitectureDirection}`;
+export type ArchitectureDirectionPair = Exclude<InvalidArchitectureDirectionPair, 'LL' | 'RR' | 'TT' | 'BB'>;
+export type ArchitectureDirectionPairXY = Exclude<InvalidArchitectureDirectionPair, 'LL' | 'RR' | 'TT' | 'BB' | 'LR' | 'RL' | 'TB' | 'BT'>;
+export declare const ArchitectureDirectionName: {
+    readonly L: "left";
+    readonly R: "right";
+    readonly T: "top";
+    readonly B: "bottom";
+};
+export declare const ArchitectureDirectionArrow: {
+    readonly L: (scale: number) => string;
+    readonly R: (scale: number) => string;
+    readonly T: (scale: number) => string;
+    readonly B: (scale: number) => string;
+};
+export declare const ArchitectureDirectionArrowShift: {
+    readonly L: (orig: number, arrowSize: number) => number;
+    readonly R: (orig: number, _arrowSize: number) => number;
+    readonly T: (orig: number, arrowSize: number) => number;
+    readonly B: (orig: number, _arrowSize: number) => number;
+};
+export declare const getOppositeArchitectureDirection: (x: ArchitectureDirection) => ArchitectureDirection;
+export declare const isArchitectureDirection: (x: unknown) => x is ArchitectureDirection;
+export declare const isArchitectureDirectionX: (x: ArchitectureDirection) => x is ArchitectureDirectionX;
+export declare const isArchitectureDirectionY: (x: ArchitectureDirection) => x is ArchitectureDirectionY;
+export declare const isArchitectureDirectionXY: (a: ArchitectureDirection, b: ArchitectureDirection) => boolean;
+export declare const isArchitecturePairXY: (pair: ArchitectureDirectionPair) => pair is ArchitectureDirectionPairXY;
+/**
+ * Verifies that the architecture direction pair does not contain an invalid match (LL, RR, TT, BB)
+ * @param x - architecture direction pair which could potentially be invalid
+ * @returns true if the pair is not LL, RR, TT, or BB
+ */
+export declare const isValidArchitectureDirectionPair: (x: InvalidArchitectureDirectionPair) => x is ArchitectureDirectionPair;
+export type ArchitectureDirectionPairMap = Partial<Record<ArchitectureDirectionPair, string>>;
+/**
+ * Creates a pair of the directions of each side of an edge. This function should be used instead of manually creating it to ensure that the source is always the first character.
+ *
+ * Note: Undefined is returned when sourceDir and targetDir are the same. In theory this should never happen since the diagram parser throws an error if a user defines it as such.
+ * @param sourceDir - source direction
+ * @param targetDir - target direction
+ * @returns
+ */
+export declare const getArchitectureDirectionPair: (sourceDir: ArchitectureDirection, targetDir: ArchitectureDirection) => ArchitectureDirectionPair | undefined;
+/**
+ * Given an x,y position for an arrow and the direction of the edge it belongs to, return a factor for slightly shifting the edge
+ * @param param0 - [x, y] coordinate pair
+ * @param pair - architecture direction pair
+ * @returns a new [x, y] coordinate pair
+ */
+export declare const shiftPositionByArchitectureDirectionPair: ([x, y]: number[], pair: ArchitectureDirectionPair) => number[];
+/**
+ * Given the directional pair of an XY edge, get the scale factors necessary to shift the coordinates inwards towards the edge
+ * @param pair - XY pair of an edge
+ * @returns - number[] containing [+/- 1, +/- 1]
+ */
+export declare const getArchitectureDirectionXYFactors: (pair: ArchitectureDirectionPairXY) => number[];
+export declare const getArchitectureDirectionAlignment: (a: ArchitectureDirection, b: ArchitectureDirection) => ArchitectureAlignment;
+export interface ArchitectureStyleOptions {
+    archEdgeColor: string;
+    archEdgeArrowColor: string;
+    archEdgeWidth: string;
+    archGroupBorderColor: string;
+    archGroupBorderWidth: string;
+}
+export interface ArchitectureService {
+    id: string;
+    type: 'service';
+    edges: ArchitectureEdge[];
+    icon?: string;
+    iconText?: string;
+    title?: string;
+    in?: string;
+    width?: number;
+    height?: number;
+}
+export interface ArchitectureJunction {
+    id: string;
+    type: 'junction';
+    edges: ArchitectureEdge[];
+    in?: string;
+    width?: number;
+    height?: number;
+}
+export type ArchitectureNode = ArchitectureService | ArchitectureJunction;
+export declare const isArchitectureService: (x: ArchitectureNode) => x is ArchitectureService;
+export declare const isArchitectureJunction: (x: ArchitectureNode) => x is ArchitectureJunction;
+export interface ArchitectureGroup {
+    id: string;
+    icon?: string;
+    title?: string;
+    in?: string;
+}
+export interface ArchitectureEdge<DT = ArchitectureDirection> {
+    lhsId: string;
+    lhsDir: DT;
+    lhsInto?: boolean;
+    lhsGroup?: boolean;
+    rhsId: string;
+    rhsDir: DT;
+    rhsInto?: boolean;
+    rhsGroup?: boolean;
+    title?: string;
+}
+export interface ArchitectureDB extends DiagramDBBase<ArchitectureDiagramConfig> {
+    clear: () => void;
+    addService: (service: Omit<ArchitectureService, 'edges'>) => void;
+    getServices: () => ArchitectureService[];
+    addJunction: (service: Omit<ArchitectureJunction, 'edges'>) => void;
+    getJunctions: () => ArchitectureJunction[];
+    getNodes: () => ArchitectureNode[];
+    getNode: (id: string) => ArchitectureNode | null;
+    addGroup: (group: ArchitectureGroup) => void;
+    getGroups: () => ArchitectureGroup[];
+    addEdge: (edge: ArchitectureEdge) => void;
+    getEdges: () => ArchitectureEdge[];
+    setElementForId: (id: string, element: D3Element) => void;
+    getElementById: (id: string) => D3Element;
+    getDataStructures: () => ArchitectureDataStructures;
+}
+export type ArchitectureAdjacencyList = Record<string, ArchitectureDirectionPairMap>;
+export type ArchitectureSpatialMap = Record<string, number[]>;
+/**
+ * Maps the direction that groups connect from.
+ *
+ * **Outer key**: ID of group A
+ *
+ * **Inner key**: ID of group B
+ *
+ * **Value**: 'vertical' or 'horizontal'
+ *
+ * Note: tmp[groupA][groupB] == tmp[groupB][groupA]
+ */
+export type ArchitectureGroupAlignments = Record<string, Record<string, Exclude<ArchitectureAlignment, 'bend'>>>;
+export interface ArchitectureDataStructures {
+    adjList: ArchitectureAdjacencyList;
+    spatialMaps: ArchitectureSpatialMap[];
+    groupAlignments: ArchitectureGroupAlignments;
+}
+export interface ArchitectureState extends Record<string, unknown> {
+    nodes: Record<string, ArchitectureNode>;
+    groups: Record<string, ArchitectureGroup>;
+    edges: ArchitectureEdge[];
+    registeredIds: Record<string, 'node' | 'group'>;
+    dataStructures?: ArchitectureDataStructures;
+    elements: Record<string, D3Element>;
+    config: ArchitectureDiagramConfig;
+}
+export interface EdgeSingularData {
+    id: string;
+    label?: string;
+    source: string;
+    sourceDir: ArchitectureDirection;
+    sourceArrow?: boolean;
+    sourceGroup?: boolean;
+    target: string;
+    targetDir: ArchitectureDirection;
+    targetArrow?: boolean;
+    targetGroup?: boolean;
+    [key: string]: any;
+}
+export declare const edgeData: (edge: cytoscape.EdgeSingular) => EdgeSingularData;
+export interface EdgeSingular extends cytoscape.EdgeSingular {
+    _private: {
+        bodyBounds: unknown;
+        rscratch: {
+            startX: number;
+            startY: number;
+            midX: number;
+            midY: number;
+            endX: number;
+            endY: number;
+        };
+    };
+    data(): EdgeSingularData;
+    data<T extends keyof EdgeSingularData>(key: T): EdgeSingularData[T];
+}
+export type NodeSingularData = {
+    type: 'service';
+    id: string;
+    icon?: string;
+    label?: string;
+    parent?: string;
+    width: number;
+    height: number;
+    [key: string]: any;
+} | {
+    type: 'junction';
+    id: string;
+    parent?: string;
+    width: number;
+    height: number;
+    [key: string]: any;
+} | {
+    type: 'group';
+    id: string;
+    icon?: string;
+    label?: string;
+    parent?: string;
+    [key: string]: any;
+};
+export declare const nodeData: (node: cytoscape.NodeSingular) => NodeSingularData;
+export interface NodeSingular extends cytoscape.NodeSingular {
+    _private: {
+        bodyBounds: {
+            h: number;
+            w: number;
+            x1: number;
+            x2: number;
+            y1: number;
+            y2: number;
+        };
+        children: cytoscape.NodeSingular[];
+    };
+    data(): NodeSingularData;
+    data<T extends keyof NodeSingularData>(key: T): NodeSingularData[T];
+}

app/basepak/static/js/mermaid/diagrams/architecture/svgDraw.d.ts

@@ -0,0 +1,8 @@
+import type cytoscape from 'cytoscape';
+import type { D3Element } from '../../types.js';
+import type { ArchitectureDB } from './architectureDb.js';
+import { type ArchitectureJunction, type ArchitectureService } from './architectureTypes.js';
+export declare const drawEdges: (edgesEl: D3Element, cy: cytoscape.Core, db: ArchitectureDB) => Promise<void>;
+export declare const drawGroups: (groupsEl: D3Element, cy: cytoscape.Core, db: ArchitectureDB) => Promise<void>;
+export declare const drawServices: (db: ArchitectureDB, elem: D3Element, services: ArchitectureService[]) => Promise<number>;
+export declare const drawJunctions: (db: ArchitectureDB, elem: D3Element, junctions: ArchitectureJunction[]) => void;

app/basepak/static/js/mermaid/diagrams/architecture/svgDraw.spec.d.ts

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