@modudraft/core 0.1.1

package/src/mermaid-import.ts

@@ -0,0 +1,118 @@
+import type { SysNode, SysEdge, LayoutDirection } from "./types";
+import { getArchetype } from "./catalog";
+
+export type MermaidParseResult =
+  | { ok: true; nodes: SysNode[]; edges: SysEdge[]; direction: LayoutDirection }
+  | { ok: false; error: string };
+
+const HEADER_RE = /^(?:flowchart|graph)\s+(LR|RL|TD|TB|BT)\s*;?\s*$/i;
+const IGNORED_RE =
+  /^(?:subgraph\b|end\b|classDef\b|class\b|style\b|linkStyle\b|click\b|%%)/;
+const ARROW_RE = /\s*(?:--\s+([^>]+?)\s+-->|-->\|([^|]*)\||-->)\s*/;
+
+const stripQuotes = (s: string): string => {
+  const t = s.trim();
+  return t.startsWith('"') && t.endsWith('"') ? t.slice(1, -1) : t;
+};
+
+type ParsedToken = {
+  id: string;
+  label: string;
+  archetype: string;
+  explicit: boolean;
+};
+
+function parseNodeToken(token: string): ParsedToken | null {
+  const t = token.trim();
+  const shapes: [RegExp, string][] = [
+    [/^(\w[\w-]*)\[\((.+)\)\]$/, "database"],
+    [/^(\w[\w-]*)\{\{(.+)\}\}$/, "gateway"],
+    [/^(\w[\w-]*)\(\[(.+)\]\)$/, "compute"],
+    [/^(\w[\w-]*)\[\/(.+)\/\]$/, "compute"],
+    [/^(\w[\w-]*)\(\((.+)\)\)$/, "cache"],
+    [/^(\w[\w-]*)>(.+)\]$/, "queue"],
+    [/^(\w[\w-]*)\[(.+)\]$/, "compute"],
+    [/^(\w[\w-]*)\{(.+)\}$/, "compute"],
+    [/^(\w[\w-]*)\((.+)\)$/, "compute"],
+  ];
+  for (const [re, archetype] of shapes) {
+    const m = t.match(re);
+    if (m)
+      return { id: m[1], label: stripQuotes(m[2]), archetype, explicit: true };
+  }
+  const bare = t.match(/^(\w[\w-]*)$/);
+  if (bare)
+    return {
+      id: bare[1],
+      label: bare[1],
+      archetype: "compute",
+      explicit: false,
+    };
+  return null;
+}
+
+export function parseMermaid(text: string): MermaidParseResult {
+  let direction: LayoutDirection = "LR";
+  const nodesById = new Map<string, SysNode>();
+  const explicitIds = new Set<string>();
+  const edges: SysEdge[] = [];
+
+  const ensureNode = (token: string): string | null => {
+    const parsed = parseNodeToken(token);
+    if (!parsed) return null;
+    const existing = nodesById.get(parsed.id);
+    if (!existing || (parsed.explicit && !explicitIds.has(parsed.id))) {
+      const archetype = parsed.archetype;
+      nodesById.set(parsed.id, {
+        id: parsed.id,
+        type: "sysNode",
+        position: { x: 0, y: 0 },
+        data: {
+          archetype,
+          concreteTool: getArchetype(archetype)?.defaultTool ?? "",
+          label: parsed.label,
+        },
+      });
+      if (parsed.explicit) explicitIds.add(parsed.id);
+    }
+    return parsed.id;
+  };
+
+  for (const raw of text.split(/\r?\n/)) {
+    const line = raw.trim();
+    if (!line) continue;
+    const header = line.match(HEADER_RE);
+    if (header) {
+      const dir = header[1].toUpperCase();
+      direction = dir === "LR" || dir === "RL" ? "LR" : "TB";
+      continue;
+    }
+    if (IGNORED_RE.test(line)) continue;
+    const normalized = line.replace(/-\.+->/g, "-->").replace(/==>/g, "-->");
+    const parts = normalized.split(ARROW_RE);
+    if (parts.length === 1) {
+      ensureNode(line);
+      continue;
+    }
+    let prevId = ensureNode(parts[0]);
+    for (let i = 1; i < parts.length - 1; i += 3) {
+      const label = parts[i] ?? parts[i + 1];
+      const nextId = ensureNode(parts[i + 2]);
+      if (prevId && nextId) {
+        edges.push({
+          id: `mermaid-e${edges.length}`,
+          source: prevId,
+          target: nextId,
+          type: "sysEdge",
+          data: label !== undefined ? { label: label.trim() } : {},
+        });
+      }
+      prevId = nextId ?? prevId;
+    }
+  }
+
+  if (nodesById.size === 0) {
+    return { ok: false, error: "No nodes found — check your Mermaid syntax." };
+  }
+  return { ok: true, nodes: [...nodesById.values()], edges, direction };
+}

package/src/sysdraw-file.ts

@@ -0,0 +1,250 @@
+import { z } from "zod";
+import type {
+  AppNode,
+  SysEdge,
+  ViewMode,
+  NodeStyle,
+  SysNode,
+  StepNode,
+  ArrowNode,
+} from "./types";
+import { absolutizeAll } from "./grouping";
+
+export const SYSDRAW_VERSION = "1.3.0";
+
+const positionSchema = z.object({ x: z.number(), y: z.number() });
+
+const sysNodeSchema = z.object({
+  id: z.string().min(1),
+  type: z.literal("sysNode").catch("sysNode"),
+  position: positionSchema,
+  data: z.object({
+    archetype: z.string().min(1),
+    concreteTool: z.string().min(1),
+    label: z.string(),
+    customProperties: z.record(z.string(), z.string()).optional(),
+  }),
+});
+
+const noteNodeSchema = z.object({
+  id: z.string().min(1),
+  type: z.literal("noteNode"),
+  position: positionSchema,
+  data: z.object({
+    text: z.string(),
+    color: z.string().optional(),
+    size: z.enum(["small", "normal", "title"]).optional(),
+  }),
+});
+
+const boundaryNodeSchema = z.object({
+  id: z.string().min(1),
+  type: z.literal("boundaryNode"),
+  position: positionSchema,
+  width: z.number().optional(),
+  height: z.number().optional(),
+  data: z.object({
+    label: z.string(),
+    color: z.string().optional(),
+  }),
+});
+
+const stepNodeSchema = z.object({
+  id: z.string().min(1),
+  type: z.literal("stepNode"),
+  position: positionSchema,
+  data: z.object({
+    n: z.number().optional(),
+    label: z.string().optional(),
+    color: z.string().optional(),
+  }),
+});
+
+const arrowNodeSchema = z.object({
+  id: z.string().min(1),
+  type: z.literal("arrowNode"),
+  position: positionSchema,
+  data: z.object({
+    dx: z.number(),
+    dy: z.number(),
+    color: z.string().optional(),
+    lineStyle: z.enum(["solid", "dashed", "dotted"]).optional(),
+  }),
+});
+
+const anyNodeSchema = z.union([
+  sysNodeSchema,
+  noteNodeSchema,
+  boundaryNodeSchema,
+  stepNodeSchema,
+  arrowNodeSchema,
+]);
+
+const edgeSchema = z.object({
+  id: z.string().min(1),
+  source: z.string().min(1),
+  target: z.string().min(1),
+  type: z.literal("sysEdge").catch("sysEdge"),
+  animated: z.boolean().optional(),
+  data: z
+    .object({
+      label: z.string().optional(),
+      protocol: z.string().optional(),
+      color: z.string().optional(),
+      customProperties: z.record(z.string(), z.string()).optional(),
+    })
+    .optional(),
+});
+
+const metaSchema = z
+  .object({
+    title: z.string().optional(),
+    lastModified: z.string().optional(),
+    viewMode: z.enum(["minimalist", "real"]).optional(),
+    nodeStyle: z.enum(["symbol", "card", "plate"]).optional(),
+    locked: z.boolean().optional(),
+  })
+  .catch({});
+
+export const sysdrawFileSchema = z.object({
+  version: z.string(),
+  meta: metaSchema.default({}),
+  nodes: z.array(anyNodeSchema),
+  edges: z.array(edgeSchema),
+});
+
+export type SysdrawFile = z.infer<typeof sysdrawFileSchema>;
+
+export function serializeSysdraw(state: {
+  nodes: AppNode[];
+  edges: SysEdge[];
+  viewMode: ViewMode;
+  nodeStyle: NodeStyle;
+  title?: string;
+  locked?: boolean;
+}): string {
+  const sourceNodes = absolutizeAll(state.nodes);
+  const serializedNodes = sourceNodes.map((n) => {
+    if (n.type === "noteNode") {
+      return {
+        id: n.id,
+        type: "noteNode" as const,
+        position: n.position,
+        data: {
+          text: n.data.text,
+          ...(n.data.color !== undefined ? { color: n.data.color } : {}),
+          ...(n.data.size !== undefined ? { size: n.data.size } : {}),
+        },
+      };
+    }
+    if (n.type === "boundaryNode") {
+      return {
+        id: n.id,
+        type: "boundaryNode" as const,
+        position: n.position,
+        ...(n.width !== undefined ? { width: n.width } : {}),
+        ...(n.height !== undefined ? { height: n.height } : {}),
+        data: {
+          label: n.data.label,
+          ...(n.data.color !== undefined ? { color: n.data.color } : {}),
+        },
+      };
+    }
+    if (n.type === "stepNode") {
+      const sn = n as StepNode;
+      return {
+        id: sn.id,
+        type: "stepNode" as const,
+        position: sn.position,
+        data: {
+          n: sn.data.n ?? 0,
+          ...(sn.data.label !== undefined ? { label: sn.data.label } : {}),
+          ...(sn.data.color !== undefined ? { color: sn.data.color } : {}),
+        },
+      };
+    }
+    if (n.type === "arrowNode") {
+      const an = n as ArrowNode;
+      return {
+        id: an.id,
+        type: "arrowNode" as const,
+        position: an.position,
+        data: {
+          dx: an.data.dx,
+          dy: an.data.dy,
+          ...(an.data.color !== undefined ? { color: an.data.color } : {}),
+          ...(an.data.lineStyle !== undefined
+            ? { lineStyle: an.data.lineStyle }
+            : {}),
+        },
+      };
+    }
+    // sysNode
+    const sn = n as SysNode;
+    return {
+      id: sn.id,
+      type: "sysNode" as const,
+      position: sn.position,
+      data: {
+        archetype: sn.data.archetype,
+        concreteTool: sn.data.concreteTool,
+        label: sn.data.label,
+        ...(sn.data.customProperties
+          ? { customProperties: sn.data.customProperties }
+          : {}),
+      },
+    };
+  });
+
+  const file = {
+    version: SYSDRAW_VERSION,
+    meta: {
+      title: state.title ?? "architecture",
+      lastModified: new Date().toISOString(),
+      viewMode: state.viewMode,
+      nodeStyle: state.nodeStyle,
+      ...(state.locked ? { locked: true } : {}),
+    },
+    nodes: serializedNodes,
+    edges: state.edges.map((e) => ({
+      id: e.id,
+      source: e.source,
+      target: e.target,
+      type: "sysEdge" as const,
+      ...(e.animated ? { animated: true } : {}),
+      data: {
+        ...(e.data?.label !== undefined ? { label: e.data.label } : {}),
+        ...(e.data?.protocol !== undefined
+          ? { protocol: e.data.protocol }
+          : {}),
+        ...(e.data?.color !== undefined ? { color: e.data.color } : {}),
+        ...(e.data?.customProperties !== undefined
+          ? { customProperties: e.data.customProperties }
+          : {}),
+      },
+    })),
+  };
+  return JSON.stringify(file, null, 2);
+}
+
+export type ParseResult =
+  | { ok: true; data: SysdrawFile }
+  | { ok: false; error: string };
+
+export function parseSysdraw(text: string): ParseResult {
+  let json: unknown;
+  try {
+    json = JSON.parse(text);
+  } catch {
+    return { ok: false, error: "File is not valid JSON." };
+  }
+  const result = sysdrawFileSchema.safeParse(json);
+  if (!result.success) {
+    const issue = result.error.issues[0];
+    return {
+      ok: false,
+      error: `Invalid file — ${issue.path.join(".") || "root"}: ${issue.message}`,
+    };
+  }
+  return { ok: true, data: result.data };
+}

package/src/types.ts

@@ -0,0 +1,75 @@
+export type ViewMode = "minimalist" | "real";
+export type NodeStyle = "symbol" | "card" | "plate";
+export type LayoutDirection = "LR" | "TB";
+
+export type SysNodeData = {
+  archetype: string;
+  concreteTool: string;
+  label: string;
+  customProperties?: Record<string, string>;
+};
+
+export type NoteNodeData = {
+  text: string;
+  color?: string;
+  size?: "small" | "normal" | "title";
+};
+
+export type BoundaryNodeData = {
+  label: string;
+  color?: string;
+};
+
+export type StepNodeData = {
+  n?: number;
+  label?: string;
+  color?: string;
+};
+
+export type ArrowNodeData = {
+  dx: number;
+  dy: number;
+  color?: string;
+  lineStyle?: "solid" | "dashed" | "dotted";
+};
+
+export type SysEdgeData = {
+  label?: string;
+  protocol?: string;
+  color?: string;
+  customProperties?: Record<string, string>;
+};
+
+// Structural subset of @xyflow/react Node<TData, TType> — no React dep.
+// type is required so core return values are directly assignable to RF's
+// discriminated AppNode union (required→optional is valid structurally;
+// when RF nodes go IN to core functions the call site casts with "as").
+type CoreNode<TData, TType extends string = string> = {
+  id: string;
+  type: TType;
+  position: { x: number; y: number };
+  data: TData;
+  parentId?: string;
+  width?: number;
+  height?: number;
+  measured?: { width?: number; height?: number };
+  zIndex?: number;
+  selected?: boolean;
+};
+
+export type SysNode = CoreNode<SysNodeData, "sysNode">;
+export type NoteNode = CoreNode<NoteNodeData, "noteNode">;
+export type BoundaryNode = CoreNode<BoundaryNodeData, "boundaryNode">;
+export type StepNode = CoreNode<StepNodeData, "stepNode">;
+export type ArrowNode = CoreNode<ArrowNodeData, "arrowNode">;
+export type AppNode = SysNode | NoteNode | BoundaryNode | StepNode | ArrowNode;
+
+export type SysEdge = {
+  id: string;
+  source: string;
+  target: string;
+  type?: string;
+  animated?: boolean;
+  selected?: boolean;
+  data?: SysEdgeData;
+};

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "declaration": true,
+    "declarationMap": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "verbatimModuleSyntax": true,
+    "resolveJsonModule": true,
+    "skipLibCheck": true,
+    "composite": true
+  },
+  "include": ["src/**/*.ts", "src/**/*.json"]
+}