@crazyhappyone/auto-graph 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,514 @@
+type JsonPrimitive = string | number | boolean | null;
+type JsonValue = JsonPrimitive | JsonObject | JsonValue[];
+interface JsonObject {
+    [key: string]: JsonValue;
+}
+type DiagramDirection = "TB" | "LR" | "BT" | "RL";
+interface Point {
+    x: number;
+    y: number;
+}
+interface Size {
+    width: number;
+    height: number;
+}
+interface Box extends Point, Size {
+}
+interface Insets {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+}
+type AnchorName = "center" | "top" | "right" | "bottom" | "left" | "top-left" | "top-right" | "bottom-right" | "bottom-left";
+interface AnchorPoint {
+    name: AnchorName;
+    point: Point;
+}
+
+type ConstraintTargetKind = "node" | "group";
+interface ConstraintTarget {
+    id: string;
+    kind?: ConstraintTargetKind;
+}
+interface ConstraintBase {
+    id?: string;
+    targetId?: string;
+    target?: ConstraintTarget;
+}
+interface ExactPositionConstraint extends ConstraintBase {
+    kind: "exact-position";
+    position: Point;
+}
+type RelativePositionRelation = "above" | "right-of" | "below" | "left-of";
+interface RelativePositionConstraint extends ConstraintBase {
+    kind: "relative-position";
+    sourceId: string;
+    referenceId: string;
+    relation: RelativePositionRelation;
+    offset?: Point;
+}
+type AlignmentAxis = "x" | "y" | "center-x" | "center-y" | "top" | "right" | "bottom" | "left";
+interface AlignConstraint extends ConstraintBase {
+    kind: "align";
+    axis: AlignmentAxis;
+    targetIds: string[];
+}
+type DistributionAxis = "horizontal" | "vertical";
+interface DistributeConstraint extends ConstraintBase {
+    kind: "distribute";
+    axis: DistributionAxis;
+    targetIds: string[];
+    spacing?: number;
+}
+interface ContainmentConstraint extends ConstraintBase {
+    kind: "containment";
+    containerId: string;
+    childIds: string[];
+    padding?: Insets;
+}
+type Constraint = ExactPositionConstraint | RelativePositionConstraint | AlignConstraint | DistributeConstraint | ContainmentConstraint;
+
+type DiagnosticSeverity = "info" | "warning" | "error";
+type DiagnosticPathSegment = string | number;
+interface Diagnostic {
+    severity: DiagnosticSeverity;
+    code: string;
+    message: string;
+    path?: DiagnosticPathSegment[];
+    detail?: JsonObject;
+}
+
+interface TextStyleOptions {
+    fontFamily: string;
+    fontSize: number;
+    fontWeight?: number | string;
+    fontStyle?: "normal" | "italic";
+    lineHeight?: number;
+    letterSpacing?: number;
+    whiteSpace?: "normal" | "pre-wrap";
+    wordBreak?: "normal" | "keep-all";
+}
+type TextMeasurementBackend = "deterministic" | "pretext";
+interface PreparedText {
+    text: string;
+    font: string;
+    style: TextStyleOptions;
+    backend: TextMeasurementBackend;
+}
+interface TextCursor {
+    segmentIndex: number;
+    graphemeIndex: number;
+}
+interface TextLayoutLine {
+    text: string;
+    width: number;
+    start: TextCursor;
+    end: TextCursor;
+}
+interface TextLayout {
+    width: number;
+    height: number;
+    lineHeight: number;
+    lineCount: number;
+    lines: TextLayoutLine[];
+    diagnostics: Diagnostic[];
+}
+interface TextMeasurer {
+    prepare(text: string, style: TextStyleOptions): PreparedText;
+    layout(prepared: PreparedText, maxWidth: number, lineHeight?: number): TextLayout;
+    naturalWidth(prepared: PreparedText): number;
+}
+declare function assertFinitePositive(value: number, label: string): void;
+declare function assertFiniteNonNegative(value: number, label: string): void;
+declare function validateTextStyle(style: TextStyleOptions): void;
+declare function resolveLineHeight(style: TextStyleOptions): number;
+declare function toCanvasFont(style: TextStyleOptions): string;
+
+declare class DeterministicTextMeasurer implements TextMeasurer {
+    prepare(text: string, style: TextStyleOptions): PreparedText;
+    layout(prepared: PreparedText, maxWidth: number, lineHeight?: number): TextLayout;
+    naturalWidth(prepared: PreparedText): number;
+    private wrap;
+}
+
+declare function isPretextRuntimeAvailable(): boolean;
+declare class PretextTextMeasurer implements TextMeasurer {
+    prepare(text: string, style: TextStyleOptions): PreparedText;
+    layout(prepared: PreparedText, maxWidth: number, lineHeight?: number): TextLayout;
+    naturalWidth(prepared: PreparedText): number;
+}
+
+interface LabelLineLayout {
+    text: string;
+    box: Box;
+    baselineY: number;
+    width: number;
+    lineIndex: number;
+    sourceStart?: TextCursor;
+    sourceEnd?: TextCursor;
+}
+interface LabelLayout {
+    text: string;
+    box: Box;
+    contentBox: Box;
+    naturalSize: Size;
+    fittedSize: Size;
+    padding: Insets;
+    font: TextStyleOptions;
+    lineHeight: number;
+    lines: LabelLineLayout[];
+    overflow: {
+        horizontal: boolean;
+        vertical: boolean;
+        truncated: boolean;
+    };
+    diagnostics: Diagnostic[];
+}
+
+type NodeShape = "rectangle" | "rounded-rectangle" | "ellipse" | "diamond" | "parallelogram" | "hexagon" | "cylinder";
+interface Label {
+    text: string;
+    id?: string;
+    maxWidth?: number;
+    metadata?: JsonObject;
+}
+interface NodeBase {
+    id: string;
+    label?: Label;
+    shape?: NodeShape;
+    metadata?: JsonObject;
+}
+interface IntentNode extends NodeBase {
+    parentId?: string;
+    position?: Point;
+    size?: Size;
+    padding?: Insets;
+}
+interface NormalizedNode extends NodeBase {
+    shape: NodeShape;
+    parentId?: string;
+    position?: Point;
+    size: Size;
+    padding: Insets;
+    labelLayout?: LabelLayout;
+}
+interface CoordinatedNode extends NodeBase {
+    shape: NodeShape;
+    box: Box;
+    anchors: AnchorPoint[];
+    parentId?: string;
+    labelLayout?: LabelLayout;
+}
+interface EdgeEndpoint {
+    nodeId: string;
+    anchor?: AnchorName;
+}
+interface IntentEdge {
+    id?: string;
+    sourceId: string;
+    targetId: string;
+    label?: Label;
+    metadata?: JsonObject;
+}
+interface NormalizedEdge {
+    id: string;
+    source: EdgeEndpoint;
+    target: EdgeEndpoint;
+    label?: Label;
+    metadata?: JsonObject;
+}
+interface CoordinatedEdge extends NormalizedEdge {
+    points: Point[];
+    labelPosition?: Point;
+}
+interface IntentGroup {
+    id: string;
+    label?: Label;
+    nodeIds?: string[];
+    groupIds?: string[];
+    padding?: Insets;
+    metadata?: JsonObject;
+}
+interface NormalizedGroup {
+    id: string;
+    label?: Label;
+    nodeIds: string[];
+    groupIds: string[];
+    padding: Insets;
+    metadata?: JsonObject;
+    labelLayout?: LabelLayout;
+}
+interface CoordinatedGroup extends NormalizedGroup {
+    box: Box;
+}
+
+type LayoutLockSource = "fixed-position" | "exact-position";
+interface LayoutLock {
+    nodeId: string;
+    source: LayoutLockSource;
+}
+interface ConstraintSolverInput {
+    direction: DiagramDirection;
+    overlapSpacing?: number;
+    boxes: ReadonlyMap<string, Box>;
+    nodes: readonly NormalizedNode[];
+    groups: readonly NormalizedGroup[];
+    constraints: readonly Constraint[];
+}
+interface ConstraintSolverResult {
+    boxes: Map<string, Box>;
+    locks: Map<string, LayoutLock>;
+    diagnostics: Diagnostic[];
+}
+
+declare function applyLayoutConstraints(input: ConstraintSolverInput): ConstraintSolverResult;
+
+type DiagramStage = "intent" | "normalized" | "coordinated";
+type DiagramMetadata = JsonObject;
+interface IntentDiagram {
+    id?: string;
+    title?: string;
+    direction?: DiagramDirection;
+    nodes: IntentNode[];
+    edges?: IntentEdge[];
+    groups?: IntentGroup[];
+    constraints?: Constraint[];
+    metadata?: DiagramMetadata;
+}
+interface NormalizedDiagram {
+    id: string;
+    title?: string;
+    direction: DiagramDirection;
+    nodes: NormalizedNode[];
+    edges: NormalizedEdge[];
+    groups: NormalizedGroup[];
+    constraints: Constraint[];
+    diagnostics: Diagnostic[];
+    metadata?: DiagramMetadata;
+}
+interface CoordinatedDiagram {
+    id: string;
+    title?: string;
+    direction: DiagramDirection;
+    nodes: CoordinatedNode[];
+    edges: CoordinatedEdge[];
+    groups: CoordinatedGroup[];
+    diagnostics: Diagnostic[];
+    bounds: Box;
+    metadata?: DiagramMetadata;
+}
+
+type DslDiagnosticLayer = "parse" | "validate" | "solve" | "export" | "io";
+type DslOutputFormat = "svg" | "excalidraw";
+interface DslDiagnostic extends Diagnostic {
+    layer: DslDiagnosticLayer;
+    hint?: string;
+}
+interface ParseDiagramDslResult {
+    value?: unknown;
+    diagnostics: DslDiagnostic[];
+}
+interface ParseDiagramDslOptions {
+    sourcePath?: string;
+    sourceFormat?: "yaml" | "json";
+    maxBytes?: number;
+}
+interface NormalizeDiagramDslResult {
+    diagram?: NormalizedDiagram;
+    diagnostics: DslDiagnostic[];
+    output?: {
+        format?: DslOutputFormat;
+    };
+}
+interface RenderDiagramDslOptions {
+    sourcePath?: string;
+    sourceFormat?: "yaml" | "json";
+    format?: string;
+    textMeasurer?: TextMeasurer;
+}
+interface RenderDiagramDslResult {
+    format?: DslOutputFormat;
+    content?: string;
+    diagnostics: DslDiagnostic[];
+    diagram?: CoordinatedDiagram;
+    metadata?: JsonObject;
+}
+
+declare function sortDslDiagnostics(diagnostics: DslDiagnostic[]): DslDiagnostic[];
+
+interface ParsedEdgeShorthand {
+    sourceId: string;
+    targetId: string;
+    label?: {
+        text: string;
+    };
+}
+declare function parseEdgeShorthand(value: string, path: Array<string | number>): {
+    edge?: ParsedEdgeShorthand;
+    diagnostics: DslDiagnostic[];
+};
+
+interface NormalizeDiagramDslOptions {
+    id?: string;
+    textMeasurer?: TextMeasurer;
+}
+declare function normalizeDiagramDsl(dslValue: unknown, options?: NormalizeDiagramDslOptions): NormalizeDiagramDslResult;
+
+declare const DEFAULT_DSL_MAX_BYTES = 1000000;
+declare function parseDiagramDsl(source: string, options?: ParseDiagramDslOptions): ParseDiagramDslResult;
+
+type ExportFormat = "svg" | "excalidraw";
+interface ExportResult {
+    format: ExportFormat;
+    content: string;
+    diagnostics: Diagnostic[];
+}
+interface ExportOptions {
+    title?: string;
+}
+
+declare function resolveOutputFormat(cliFormat?: string, dslFormat?: DslOutputFormat): {
+    format?: DslOutputFormat;
+    diagnostics: DslDiagnostic[];
+};
+declare function renderDiagramDsl(source: string, options?: RenderDiagramDslOptions): RenderDiagramDslResult;
+
+interface Arrowhead {
+    tip: Point;
+    left: Point;
+    right: Point;
+    direction: Point;
+}
+declare function computeArrowhead(points: readonly Point[], options?: {
+    length?: number;
+    width?: number;
+}): Arrowhead;
+
+declare function exportExcalidraw(diagram: CoordinatedDiagram, options?: ExportOptions): string;
+
+declare function exportSvg(diagram: CoordinatedDiagram, options?: ExportOptions): string;
+
+declare function normalizeInsets(input?: Insets | number): Insets;
+declare function validateBox(box: Box, label?: string): void;
+declare function boxCenter(box: Box): Point;
+declare function expandBox(box: Box, margin: number | Insets): Box;
+declare function unionBoxes(boxes: readonly Box[]): Box;
+declare function intersectsAabb(a: Box, b: Box): boolean;
+
+interface LabelFitOptions {
+    font: TextStyleOptions;
+    padding: Insets | number;
+    minSize?: Partial<Size>;
+    maxWidth?: number;
+    overflow?: "allow" | "diagnose" | "truncate";
+}
+
+declare function fitLabel(text: string, options: LabelFitOptions, measurer: TextMeasurer): LabelLayout;
+declare class LabelFitter {
+    private readonly measurer;
+    constructor(measurer: TextMeasurer);
+    fit(text: string, options: LabelFitOptions): LabelLayout;
+}
+
+interface ContainerGeometryInput {
+    id: string;
+    childBoxes: readonly Box[];
+    padding: Insets | number;
+    labelLayout?: LabelLayout;
+    minSize?: Partial<Size>;
+    obstacleMargin?: number | Insets;
+}
+interface ContainerGeometry {
+    id: string;
+    box: Box;
+    contentBox: Box;
+    childBounds: Box;
+    labelLayout?: LabelLayout;
+    anchors: AnchorPoint[];
+    obstacleBox: Box;
+    diagnostics: Diagnostic[];
+}
+declare function computeContainerGeometry(input: ContainerGeometryInput): ContainerGeometry;
+
+interface ShapeGeometryInput {
+    shape: NodeShape;
+    box: Box;
+    obstacleMargin?: number | Insets;
+}
+interface ShapeGeometry {
+    shape: NodeShape;
+    box: Box;
+    center: Point;
+    anchors: AnchorPoint[];
+    obstacleBox: Box;
+}
+declare function computeShapeGeometry(input: ShapeGeometryInput): ShapeGeometry;
+declare function getEdgePort(geometry: ShapeGeometry, toward: Point, preferredAnchor?: AnchorName): Point;
+
+interface DagreLayoutOptions {
+    nodesep: number;
+    ranksep: number;
+    edgesep: number;
+    marginx: number;
+    marginy: number;
+    ranker: "network-simplex" | "tight-tree" | "longest-path";
+}
+interface DagreLayoutNode {
+    id: string;
+    size: Size;
+}
+interface DagreLayoutEdge {
+    id: string;
+    sourceId: string;
+    targetId: string;
+}
+interface DagreLayoutInput {
+    direction: DiagramDirection;
+    nodes: readonly DagreLayoutNode[];
+    edges: readonly DagreLayoutEdge[];
+    options?: Partial<DagreLayoutOptions>;
+}
+interface InitialLayoutResult {
+    boxes: Map<string, Box>;
+    diagnostics: Diagnostic[];
+}
+
+declare function runDagreInitialLayout(input: DagreLayoutInput): InitialLayoutResult;
+
+type RouteKind = "orthogonal" | "straight";
+interface RouteEdgeInput {
+    kind?: RouteKind;
+    direction: DiagramDirection;
+    source: ShapeGeometry;
+    target: ShapeGeometry;
+    sourceAnchor?: AnchorName;
+    targetAnchor?: AnchorName;
+    obstacles?: readonly Box[];
+}
+interface RouteEdgeResult {
+    points: Point[];
+    diagnostics: Diagnostic[];
+}
+
+declare function routeEdge(input: RouteEdgeInput): RouteEdgeResult;
+declare function simplifyRoute(points: readonly Point[]): Point[];
+
+declare const DEFAULT_CANONICAL_PRECISION = 3;
+interface CanonicalizeOptions {
+    precision?: number;
+}
+type CanonicalJson = null | boolean | number | string | CanonicalJson[] | {
+    [key: string]: CanonicalJson;
+};
+declare function canonicalize(value: unknown, options?: CanonicalizeOptions): CanonicalJson;
+declare function stringifyCanonical(value: unknown, precision?: number): string;
+
+interface SolveDiagramOptions {
+    routeKind?: RouteKind;
+    obstacleMargin?: number | Insets;
+    overlapSpacing?: number;
+}
+declare function solveDiagram(diagram: NormalizedDiagram, options?: SolveDiagramOptions): CoordinatedDiagram;
+
+export { type AlignConstraint, type AlignmentAxis, type AnchorName, type AnchorPoint, type Arrowhead, type Box, type CanonicalJson, type CanonicalizeOptions, type Constraint, type ConstraintBase, type ConstraintSolverInput, type ConstraintSolverResult, type ConstraintTarget, type ConstraintTargetKind, type ContainerGeometry, type ContainerGeometryInput, type ContainmentConstraint, type CoordinatedDiagram, type CoordinatedEdge, type CoordinatedGroup, type CoordinatedNode, DEFAULT_CANONICAL_PRECISION, DEFAULT_DSL_MAX_BYTES, type DagreLayoutEdge, type DagreLayoutInput, type DagreLayoutNode, type DagreLayoutOptions, DeterministicTextMeasurer, type Diagnostic, type DiagnosticPathSegment, type DiagnosticSeverity, type DiagramDirection, type DiagramMetadata, type DiagramStage, type DistributeConstraint, type DistributionAxis, type DslDiagnostic, type DslDiagnosticLayer, type DslOutputFormat, type EdgeEndpoint, type ExactPositionConstraint, type ExportFormat, type ExportOptions, type ExportResult, type InitialLayoutResult, type Insets, type IntentDiagram, type IntentEdge, type IntentGroup, type IntentNode, type JsonObject, type JsonPrimitive, type JsonValue, type Label, type LabelFitOptions, LabelFitter, type LabelLayout, type LabelLineLayout, type LayoutLock, type LayoutLockSource, type NodeBase, type NodeShape, type NormalizeDiagramDslOptions, type NormalizeDiagramDslResult, type NormalizedDiagram, type NormalizedEdge, type NormalizedGroup, type NormalizedNode, type ParseDiagramDslOptions, type ParseDiagramDslResult, type ParsedEdgeShorthand, type Point, type PreparedText, PretextTextMeasurer, type RelativePositionConstraint, type RelativePositionRelation, type RenderDiagramDslOptions, type RenderDiagramDslResult, type RouteEdgeInput, type RouteEdgeResult, type RouteKind, type ShapeGeometry, type ShapeGeometryInput, type Size, type SolveDiagramOptions, type TextCursor, type TextLayout, type TextLayoutLine, type TextMeasurementBackend, type TextMeasurer, type TextStyleOptions, applyLayoutConstraints, assertFiniteNonNegative, assertFinitePositive, boxCenter, canonicalize, computeArrowhead, computeContainerGeometry, computeShapeGeometry, expandBox, exportExcalidraw, exportSvg, fitLabel, getEdgePort, intersectsAabb, isPretextRuntimeAvailable, normalizeDiagramDsl, normalizeInsets, parseDiagramDsl, parseEdgeShorthand, renderDiagramDsl, resolveLineHeight, resolveOutputFormat, routeEdge, runDagreInitialLayout, simplifyRoute, solveDiagram, sortDslDiagnostics, stringifyCanonical, toCanvasFont, unionBoxes, validateBox, validateTextStyle };