@flowconsole/web 0.0.0-beta-20260127184843

package/dist/components/ArchitectureDiagram.d.ts

@@ -0,0 +1,16 @@
+import { ArchitectureDiagramModel, ArchitectureEdgeTypes, ArchitectureNodeTypes } from '../diagram/types';
+import { ThemeControls } from '../types/theme';
+type ArchitectureDiagramProps = {
+    model: ArchitectureDiagramModel;
+    nodeTypes?: ArchitectureNodeTypes;
+    edgeTypes?: ArchitectureEdgeTypes;
+    editable?: boolean;
+    autoLayout?: boolean;
+    viewId?: string;
+    viewTitle?: string;
+    viewDescription?: string;
+    resolvedScheme?: 'light' | 'dark';
+    themeControls?: ThemeControls;
+};
+export declare function ArchitectureDiagram({ model, nodeTypes, edgeTypes, editable, autoLayout, viewId, viewTitle, viewDescription, themeControls, }: ArchitectureDiagramProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/FlowConsoleLogo.d.ts

@@ -0,0 +1,3 @@
+export declare const FlowConsoleLogo: ({ color }: {
+    color?: string;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/components/NavigationPanel/NavigationPanel.d.ts

@@ -0,0 +1,29 @@
+import { ArchitectureNode, ArchitectureDiagramModel, FlowDefinition } from '../../diagram/types';
+import { ThemeControls } from '../../types/theme';
+export type NavigationItem = {
+    id: string;
+    title: string;
+    description?: string;
+    badge?: string;
+    type: ArchitectureNode['type'];
+    shape?: string;
+    parentId?: string;
+    children: NavigationItem[];
+};
+type Props = {
+    model: ArchitectureDiagramModel;
+    viewId?: string;
+    viewTitle?: string;
+    viewDescription?: string;
+    flows?: FlowDefinition[];
+    activeFlowId?: string;
+    activeFlowStep?: number;
+    nodeTitles?: Map<string, string>;
+    onSelectFlow?: (id: string | undefined) => void;
+    onFlowStepChange?: (step: number) => void;
+    onNavigate?: (id: string) => void;
+    onToggleFlowPanel?: () => void;
+    themeControls?: ThemeControls;
+};
+export declare function NavigationPanel({ model, viewId, viewTitle, viewDescription, onNavigate, onToggleFlowPanel, themeControls, }: Props): import("react/jsx-runtime").JSX.Element;
+export default NavigationPanel;

package/dist/components/NavigationPanel/NavigationPanelControls.d.ts

@@ -0,0 +1,22 @@
+import { ThemeControls } from '../../types/theme';
+type Crumb = {
+    id: string;
+    title: string;
+};
+type Props = {
+    breadcrumbs: Crumb[];
+    viewTitle?: string;
+    onToggle: () => void;
+    onBack: () => void;
+    onForward: () => void;
+    canBack: boolean;
+    canForward: boolean;
+    onOpenSearch?: () => void;
+    onOpenFlows?: () => void;
+    activeId?: string;
+    onTitleHoverStart?: () => void;
+    onTitleHoverEnd?: () => void;
+    themeControls?: ThemeControls;
+};
+export declare function NavigationPanelControls({ breadcrumbs, viewTitle, onToggle, onBack, onForward, canBack, canForward, onOpenSearch, onOpenFlows, activeId, onTitleHoverStart, onTitleHoverEnd, themeControls, }: Props): import("react/jsx-runtime").JSX.Element;
+export default NavigationPanelControls;

package/dist/components/NavigationPanel/NavigationPanelDropdown.d.ts

@@ -0,0 +1,15 @@
+import { RefObject } from 'react';
+import { NavigationItem } from './NavigationPanel';
+type Props = {
+    tree: NavigationItem[];
+    flat: NavigationItem[];
+    activeId?: string;
+    search: string;
+    onSearch: (value: string) => void;
+    expanded: Set<string>;
+    onToggleExpand: (id: string) => void;
+    onSelect: (id: string) => void;
+    searchInputRef?: RefObject<HTMLInputElement | null>;
+};
+export declare function NavigationPanelDropdown({ tree, flat, activeId, search, onSearch, expanded, onToggleExpand, onSelect, searchInputRef, }: Props): import("react/jsx-runtime").JSX.Element;
+export default NavigationPanelDropdown;

package/dist/components/NavigationPanel/SearchOverlay.d.ts

@@ -0,0 +1,11 @@
+import { NavigationItem } from './NavigationPanel';
+type Props = {
+    opened: boolean;
+    onClose: () => void;
+    items: NavigationItem[];
+    tree: NavigationItem[];
+    activeId?: string;
+    onSelect: (id: string) => void;
+};
+export declare function SearchOverlay({ opened, onClose, items: _items, tree, activeId, onSelect }: Props): import("react/jsx-runtime").JSX.Element;
+export default SearchOverlay;

package/dist/components/NavigationPanel/index.d.ts

@@ -0,0 +1,2 @@
+export * from './NavigationPanel';
+export { default } from './NavigationPanel';

package/dist/components/VerticalSplit.d.ts

@@ -0,0 +1,15 @@
+import { ReactElement, ReactNode } from 'react';
+type VerticalSplitPaneProps = {
+    children: ReactNode;
+};
+type VerticalSplitComponent = ((props: VerticalSplitProps) => ReactElement | null) & {
+    Pane: (props: VerticalSplitPaneProps) => ReactElement | null;
+};
+type VerticalSplitProps = {
+    children: ReactNode;
+    initialPercent?: number;
+    minPercent?: number;
+    maxPercent?: number;
+};
+export declare const VerticalSplit: VerticalSplitComponent;
+export {};

package/dist/components/Workbench/CodeDiagramWorkbench.d.ts

@@ -0,0 +1,7 @@
+import { ThemeControls } from '../../types/theme';
+type Props = {
+    resolvedScheme?: 'light' | 'dark';
+    themeControls?: ThemeControls;
+};
+export declare function CodeDiagramWorkbench({ themeControls }: Props): import("react/jsx-runtime").JSX.Element;
+export default CodeDiagramWorkbench;

package/dist/components/ui/index.d.ts

@@ -0,0 +1,92 @@
+import { ButtonHTMLAttributes, CSSProperties, HTMLAttributes, InputHTMLAttributes, JSX, ReactNode } from 'react';
+type Spacing = number | string;
+export declare const ActionIcon: import('react').ForwardRefExoticComponent<ButtonHTMLAttributes<HTMLButtonElement> & {
+    variant?: "light" | "subtle" | "filled";
+    color?: "blue" | string;
+    size?: "sm" | "md" | number;
+} & import('react').RefAttributes<HTMLButtonElement>>;
+type BadgeProps = HTMLAttributes<HTMLSpanElement> & {
+    variant?: 'light';
+    size?: 'sm' | 'md';
+};
+export declare function Badge({ variant, size, className, ...props }: BadgeProps): import("react/jsx-runtime").JSX.Element;
+type GroupProps = HTMLAttributes<HTMLDivElement> & {
+    gap?: Spacing;
+    align?: CSSProperties['alignItems'];
+    justify?: CSSProperties['justifyContent'];
+    wrap?: CSSProperties['flexWrap'];
+};
+export declare function Group({ gap, align, justify, wrap, style, className, ...props }: GroupProps): import("react/jsx-runtime").JSX.Element;
+type TextProps = HTMLAttributes<HTMLDivElement> & {
+    size?: 'xs' | 'sm' | 'md' | 'lg';
+    fw?: number;
+    c?: 'dimmed' | string;
+    px?: Spacing;
+    py?: Spacing;
+};
+export declare function Text({ size, fw, c, px, py, style, className, ...props }: TextProps): import("react/jsx-runtime").JSX.Element;
+type InputProps = Omit<InputHTMLAttributes<HTMLInputElement>, 'size'> & {
+    size?: 'sm' | 'md';
+    leftSection?: ReactNode;
+    mb?: Spacing;
+};
+export declare const Input: import('react').ForwardRefExoticComponent<Omit<InputHTMLAttributes<HTMLInputElement>, "size"> & {
+    size?: "sm" | "md";
+    leftSection?: ReactNode;
+    mb?: Spacing;
+} & import('react').RefAttributes<HTMLInputElement>>;
+type TextInputProps = Omit<InputProps, 'leftSection'>;
+export declare const TextInput: import('react').ForwardRefExoticComponent<TextInputProps & import('react').RefAttributes<HTMLInputElement>>;
+type TooltipProps = {
+    label?: ReactNode;
+    children: ReactNode;
+    openDelay?: number;
+};
+export declare function Tooltip({ label, children }: TooltipProps): import("react/jsx-runtime").JSX.Element;
+type ScrollAreaProps = HTMLAttributes<HTMLDivElement> & {
+    h?: Spacing;
+    scrollbars?: 'x' | 'y' | 'xy';
+    type?: 'auto' | 'always';
+    styles?: {
+        viewport?: CSSProperties;
+    };
+};
+export declare function ScrollArea({ h, scrollbars, type, style, className, styles, ...props }: ScrollAreaProps): import("react/jsx-runtime").JSX.Element;
+type ModalProps = {
+    opened: boolean;
+    onClose: () => void;
+    title?: ReactNode;
+    children: ReactNode;
+    fullScreen?: boolean;
+    overlayProps?: {
+        opacity?: number;
+        blur?: number;
+    };
+    transitionProps?: {
+        duration?: number;
+    };
+    styles?: {
+        header?: CSSProperties;
+        body?: CSSProperties;
+    };
+};
+export declare function Modal({ opened, onClose, title, children, fullScreen, overlayProps, styles, }: ModalProps): import("react/jsx-runtime").JSX.Element | null;
+type PopoverProps = {
+    opened?: boolean;
+    onClose?: () => void;
+    position?: string;
+    withArrow?: boolean;
+    offset?: number;
+    className?: string;
+    children: ReactNode;
+};
+type PopoverDropdownProps = HTMLAttributes<HTMLDivElement>;
+type PopoverTargetProps = {
+    children: ReactNode;
+};
+type PopoverComponent = ((props: PopoverProps) => JSX.Element) & {
+    Target: (props: PopoverTargetProps) => JSX.Element;
+    Dropdown: (props: PopoverDropdownProps) => JSX.Element | null;
+};
+export declare const Popover: PopoverComponent;
+export {};

package/dist/csharp-BQi3szM0.js

@@ -0,0 +1,326 @@
+const e = {
+  wordPattern: /(-?\d*\.\d\w*)|([^\`\~\!\#\$\%\^\&\*\(\)\-\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g,
+  comments: {
+    lineComment: "//",
+    blockComment: ["/*", "*/"]
+  },
+  brackets: [
+    ["{", "}"],
+    ["[", "]"],
+    ["(", ")"]
+  ],
+  autoClosingPairs: [
+    { open: "{", close: "}" },
+    { open: "[", close: "]" },
+    { open: "(", close: ")" },
+    { open: "'", close: "'", notIn: ["string", "comment"] },
+    { open: '"', close: '"', notIn: ["string", "comment"] }
+  ],
+  surroundingPairs: [
+    { open: "{", close: "}" },
+    { open: "[", close: "]" },
+    { open: "(", close: ")" },
+    { open: "<", close: ">" },
+    { open: "'", close: "'" },
+    { open: '"', close: '"' }
+  ],
+  folding: {
+    markers: {
+      start: new RegExp("^\\s*#region\\b"),
+      end: new RegExp("^\\s*#endregion\\b")
+    }
+  }
+}, t = {
+  defaultToken: "",
+  tokenPostfix: ".cs",
+  brackets: [
+    { open: "{", close: "}", token: "delimiter.curly" },
+    { open: "[", close: "]", token: "delimiter.square" },
+    { open: "(", close: ")", token: "delimiter.parenthesis" },
+    { open: "<", close: ">", token: "delimiter.angle" }
+  ],
+  keywords: [
+    "extern",
+    "alias",
+    "using",
+    "bool",
+    "decimal",
+    "sbyte",
+    "byte",
+    "short",
+    "ushort",
+    "int",
+    "uint",
+    "long",
+    "ulong",
+    "char",
+    "float",
+    "double",
+    "object",
+    "dynamic",
+    "string",
+    "assembly",
+    "is",
+    "as",
+    "ref",
+    "out",
+    "this",
+    "base",
+    "new",
+    "typeof",
+    "void",
+    "checked",
+    "unchecked",
+    "default",
+    "delegate",
+    "var",
+    "const",
+    "if",
+    "else",
+    "switch",
+    "case",
+    "while",
+    "do",
+    "for",
+    "foreach",
+    "in",
+    "break",
+    "continue",
+    "goto",
+    "return",
+    "throw",
+    "try",
+    "catch",
+    "finally",
+    "lock",
+    "yield",
+    "from",
+    "let",
+    "where",
+    "join",
+    "on",
+    "equals",
+    "into",
+    "orderby",
+    "ascending",
+    "descending",
+    "select",
+    "group",
+    "by",
+    "namespace",
+    "partial",
+    "class",
+    "field",
+    "event",
+    "method",
+    "param",
+    "public",
+    "protected",
+    "internal",
+    "private",
+    "abstract",
+    "sealed",
+    "static",
+    "struct",
+    "readonly",
+    "volatile",
+    "virtual",
+    "override",
+    "params",
+    "get",
+    "set",
+    "add",
+    "remove",
+    "operator",
+    "true",
+    "false",
+    "implicit",
+    "explicit",
+    "interface",
+    "enum",
+    "null",
+    "async",
+    "await",
+    "fixed",
+    "sizeof",
+    "stackalloc",
+    "unsafe",
+    "nameof",
+    "when"
+  ],
+  namespaceFollows: ["namespace", "using"],
+  parenFollows: ["if", "for", "while", "switch", "foreach", "using", "catch", "when"],
+  operators: [
+    "=",
+    "??",
+    "||",
+    "&&",
+    "|",
+    "^",
+    "&",
+    "==",
+    "!=",
+    "<=",
+    ">=",
+    "<<",
+    "+",
+    "-",
+    "*",
+    "/",
+    "%",
+    "!",
+    "~",
+    "++",
+    "--",
+    "+=",
+    "-=",
+    "*=",
+    "/=",
+    "%=",
+    "&=",
+    "|=",
+    "^=",
+    "<<=",
+    ">>=",
+    ">>",
+    "=>"
+  ],
+  symbols: /[=><!~?:&|+\-*\/\^%]+/,
+  // escape sequences
+  escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+  // The main tokenizer for our languages
+  tokenizer: {
+    root: [
+      // identifiers and keywords
+      [
+        /\@?[a-zA-Z_]\w*/,
+        {
+          cases: {
+            "@namespaceFollows": {
+              token: "keyword.$0",
+              next: "@namespace"
+            },
+            "@keywords": {
+              token: "keyword.$0",
+              next: "@qualified"
+            },
+            "@default": { token: "identifier", next: "@qualified" }
+          }
+        }
+      ],
+      // whitespace
+      { include: "@whitespace" },
+      // delimiters and operators
+      [
+        /}/,
+        {
+          cases: {
+            "$S2==interpolatedstring": {
+              token: "string.quote",
+              next: "@pop"
+            },
+            "$S2==litinterpstring": {
+              token: "string.quote",
+              next: "@pop"
+            },
+            "@default": "@brackets"
+          }
+        }
+      ],
+      [/[{}()\[\]]/, "@brackets"],
+      [/[<>](?!@symbols)/, "@brackets"],
+      [
+        /@symbols/,
+        {
+          cases: {
+            "@operators": "delimiter",
+            "@default": ""
+          }
+        }
+      ],
+      // numbers
+      [/[0-9_]*\.[0-9_]+([eE][\-+]?\d+)?[fFdD]?/, "number.float"],
+      [/0[xX][0-9a-fA-F_]+/, "number.hex"],
+      [/0[bB][01_]+/, "number.hex"],
+      // binary: use same theme style as hex
+      [/[0-9_]+/, "number"],
+      // delimiter: after number because of .\d floats
+      [/[;,.]/, "delimiter"],
+      // strings
+      [/"([^"\\]|\\.)*$/, "string.invalid"],
+      // non-teminated string
+      [/"/, { token: "string.quote", next: "@string" }],
+      [/\$\@"/, { token: "string.quote", next: "@litinterpstring" }],
+      [/\@"/, { token: "string.quote", next: "@litstring" }],
+      [/\$"/, { token: "string.quote", next: "@interpolatedstring" }],
+      // characters
+      [/'[^\\']'/, "string"],
+      [/(')(@escapes)(')/, ["string", "string.escape", "string"]],
+      [/'/, "string.invalid"]
+    ],
+    qualified: [
+      [
+        /[a-zA-Z_][\w]*/,
+        {
+          cases: {
+            "@keywords": { token: "keyword.$0" },
+            "@default": "identifier"
+          }
+        }
+      ],
+      [/\./, "delimiter"],
+      ["", "", "@pop"]
+    ],
+    namespace: [
+      { include: "@whitespace" },
+      [/[A-Z]\w*/, "namespace"],
+      [/[\.=]/, "delimiter"],
+      ["", "", "@pop"]
+    ],
+    comment: [
+      [/[^\/*]+/, "comment"],
+      // [/\/\*/,    'comment', '@push' ],    // no nested comments :-(
+      ["\\*/", "comment", "@pop"],
+      [/[\/*]/, "comment"]
+    ],
+    string: [
+      [/[^\\"]+/, "string"],
+      [/@escapes/, "string.escape"],
+      [/\\./, "string.escape.invalid"],
+      [/"/, { token: "string.quote", next: "@pop" }]
+    ],
+    litstring: [
+      [/[^"]+/, "string"],
+      [/""/, "string.escape"],
+      [/"/, { token: "string.quote", next: "@pop" }]
+    ],
+    litinterpstring: [
+      [/[^"{]+/, "string"],
+      [/""/, "string.escape"],
+      [/{{/, "string.escape"],
+      [/}}/, "string.escape"],
+      [/{/, { token: "string.quote", next: "root.litinterpstring" }],
+      [/"/, { token: "string.quote", next: "@pop" }]
+    ],
+    interpolatedstring: [
+      [/[^\\"{]+/, "string"],
+      [/@escapes/, "string.escape"],
+      [/\\./, "string.escape.invalid"],
+      [/{{/, "string.escape"],
+      [/}}/, "string.escape"],
+      [/{/, { token: "string.quote", next: "root.interpolatedstring" }],
+      [/"/, { token: "string.quote", next: "@pop" }]
+    ],
+    whitespace: [
+      [/^[ \t\v\f]*#((r)|(load))(?=\s)/, "directive.csx"],
+      [/^[ \t\v\f]*#\w.*$/, "namespace.cpp"],
+      [/[ \t\v\f\r\n]+/, ""],
+      [/\/\*/, "comment", "@comment"],
+      [/\/\/.*$/, "comment"]
+    ]
+  }
+};
+export {
+  e as conf,
+  t as language
+};

package/dist/csharp.contribution-Er9Y3QJk.js

@@ -0,0 +1,7 @@
+import { r as s } from "./_.contribution-CNMVP3ek.js";
+s({
+  id: "csharp",
+  extensions: [".cs", ".csx", ".cake"],
+  aliases: ["C#", "csharp"],
+  loader: () => import("./csharp-BQi3szM0.js")
+});

package/dist/diagram/graphvizLayoutService.d.ts

@@ -0,0 +1,2 @@
+import { ArchitectureDiagramModel } from './types';
+export declare function layoutWithGraphviz(model: ArchitectureDiagramModel): Promise<ArchitectureDiagramModel>;

package/dist/diagram/registry.d.ts

@@ -0,0 +1,3 @@
+import { ArchitectureEdgeTypes, ArchitectureNodeTypes } from './types';
+export declare const architectureNodeTypes: ArchitectureNodeTypes;
+export declare const architectureEdgeTypes: ArchitectureEdgeTypes;

package/dist/diagram/theme.d.ts

@@ -0,0 +1,9 @@
+import { ElementTone, RelationshipKind } from './types';
+export declare function toneToColor(tone?: ElementTone): "var(--diagram-success)" | "var(--diagram-warning)" | "var(--diagram-danger)" | "var(--diagram-muted)" | "var(--diagram-primary)";
+export declare function relationshipStroke(kind?: RelationshipKind): {
+    stroke: string;
+    strokeDasharray: undefined;
+} | {
+    stroke: string;
+    strokeDasharray: string;
+};

package/dist/diagram/types.d.ts

@@ -0,0 +1,89 @@
+import { Edge, EdgeTypes, Node, NodeTypes, Position } from '@xyflow/react';
+export type ElementShape = 'person' | 'service' | 'database' | 'queue' | 'storage' | 'boundary';
+export type ElementTone = 'primary' | 'muted' | 'success' | 'warning' | 'danger';
+export type ElementStatus = 'operational' | 'degraded' | 'down';
+type BaseNodeData = {
+    title: string;
+    subtitle?: string;
+    description?: string;
+    tags?: string[];
+    badge?: string;
+    tone?: ElementTone;
+    status?: ElementStatus;
+    flowHighlighted?: boolean;
+    flowCurrent?: 'source' | 'target';
+};
+export type ElementNodeData = BaseNodeData & {
+    shape?: ElementShape;
+    icon?: string;
+    clickable?: boolean;
+};
+export type ContainerNodeData = BaseNodeData & {
+    shape?: 'container';
+    footer?: string;
+    muted?: boolean;
+    expanded?: boolean;
+    childCount?: number;
+    showOpenButton?: boolean;
+};
+export type ArchitectureNodeData = ElementNodeData | ContainerNodeData;
+export type RelationshipKind = 'sync' | 'async' | 'event' | 'dependency';
+export type RelationshipEdgeData = {
+    label?: string;
+    detail?: string;
+    kind?: RelationshipKind;
+    muted?: boolean;
+    hovered?: boolean;
+    direction?: 'forward' | 'both' | 'none';
+    icon?: string;
+    labelSide?: 'above' | 'below' | 'left' | 'right';
+    layoutPoints?: {
+        x: number;
+        y: number;
+    }[];
+    labelPos?: {
+        x: number;
+        y: number;
+    };
+    controlPoints?: {
+        x: number;
+        y: number;
+    }[];
+    sourceAnchor?: {
+        position: Position;
+        offset: number;
+    };
+    targetAnchor?: {
+        position: Position;
+        offset: number;
+    };
+    flowHighlighted?: boolean;
+    flowCurrent?: boolean;
+    originalEdgeIds?: string[];
+    flowTick?: number;
+};
+export type ElementNodeType = Node<ElementNodeData, 'element'>;
+export type ContainerNodeType = Node<ContainerNodeData, 'container'>;
+export type RelationshipEdgeType = Edge<RelationshipEdgeData, 'relationship'>;
+export type ArchitectureNode = ElementNodeType | ContainerNodeType;
+export type ArchitectureEdge = RelationshipEdgeType;
+export type FlowStep = {
+    id: string;
+    edgeId: string;
+    sourceId: string;
+    targetId: string;
+    label?: string;
+};
+export type FlowDefinition = {
+    id: string;
+    name?: string;
+    steps: FlowStep[];
+};
+export type ArchitectureNodeTypes = NodeTypes;
+export type ArchitectureEdgeTypes = EdgeTypes;
+export type ArchitectureDiagramModel = {
+    nodes: ArchitectureNode[];
+    edges: ArchitectureEdge[];
+    flows?: FlowDefinition[];
+};
+export {};

package/dist/diagram/utils/scopedModel.d.ts

@@ -0,0 +1,3 @@
+import { ArchitectureDiagramModel, ArchitectureNode } from '../types';
+export declare function buildScopedModel(model: ArchitectureDiagramModel, scopeId?: string): ArchitectureDiagramModel;
+export declare function scopeTrail(model: ArchitectureDiagramModel, scopeId?: string): ArchitectureNode[];