@modudraft/core 0.1.4 → 0.1.5

package/dist/mermaid-import.js

@@ -0,0 +1,102 @@
+import { getArchetype } from "./catalog";
+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) => {
+    const t = s.trim();
+    return t.startsWith('"') && t.endsWith('"') ? t.slice(1, -1) : t;
+};
+function parseNodeToken(token) {
+    const t = token.trim();
+    const shapes = [
+        [/^(\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) {
+    let direction = "LR";
+    const nodesById = new Map();
+    const explicitIds = new Set();
+    const edges = [];
+    const ensureNode = (token) => {
+        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/dist/sysdraw-file.d.ts

@@ -0,0 +1,123 @@
+import { z } from "zod";
+import type { AppNode, SysEdge, ViewMode, NodeStyle } from "./types";
+export declare const SYSDRAW_VERSION = "1.3.0";
+export declare const sysdrawFileSchema: z.ZodObject<{
+    version: z.ZodString;
+    meta: z.ZodDefault<z.ZodCatch<z.ZodObject<{
+        title: z.ZodOptional<z.ZodString>;
+        lastModified: z.ZodOptional<z.ZodString>;
+        viewMode: z.ZodOptional<z.ZodEnum<{
+            minimalist: "minimalist";
+            real: "real";
+        }>>;
+        nodeStyle: z.ZodOptional<z.ZodEnum<{
+            symbol: "symbol";
+            card: "card";
+            plate: "plate";
+        }>>;
+        locked: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+    nodes: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodCatch<z.ZodLiteral<"sysNode">>;
+        position: z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+        }, z.core.$strip>;
+        data: z.ZodObject<{
+            archetype: z.ZodString;
+            concreteTool: z.ZodString;
+            label: z.ZodString;
+            customProperties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"noteNode">;
+        position: z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+        }, z.core.$strip>;
+        data: z.ZodObject<{
+            text: z.ZodString;
+            color: z.ZodOptional<z.ZodString>;
+            size: z.ZodOptional<z.ZodEnum<{
+                normal: "normal";
+                small: "small";
+                title: "title";
+            }>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"boundaryNode">;
+        position: z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+        }, z.core.$strip>;
+        width: z.ZodOptional<z.ZodNumber>;
+        height: z.ZodOptional<z.ZodNumber>;
+        data: z.ZodObject<{
+            label: z.ZodString;
+            color: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"stepNode">;
+        position: z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+        }, z.core.$strip>;
+        data: z.ZodObject<{
+            n: z.ZodOptional<z.ZodNumber>;
+            label: z.ZodOptional<z.ZodString>;
+            color: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"arrowNode">;
+        position: z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+        }, z.core.$strip>;
+        data: z.ZodObject<{
+            dx: z.ZodNumber;
+            dy: z.ZodNumber;
+            color: z.ZodOptional<z.ZodString>;
+            lineStyle: z.ZodOptional<z.ZodEnum<{
+                solid: "solid";
+                dashed: "dashed";
+                dotted: "dotted";
+            }>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>]>>;
+    edges: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        source: z.ZodString;
+        target: z.ZodString;
+        type: z.ZodCatch<z.ZodLiteral<"sysEdge">>;
+        animated: z.ZodOptional<z.ZodBoolean>;
+        data: z.ZodOptional<z.ZodObject<{
+            label: z.ZodOptional<z.ZodString>;
+            protocol: z.ZodOptional<z.ZodString>;
+            color: z.ZodOptional<z.ZodString>;
+            customProperties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type SysdrawFile = z.infer<typeof sysdrawFileSchema>;
+export declare function serializeSysdraw(state: {
+    nodes: AppNode[];
+    edges: SysEdge[];
+    viewMode: ViewMode;
+    nodeStyle: NodeStyle;
+    title?: string;
+    locked?: boolean;
+}): string;
+export type ParseResult = {
+    ok: true;
+    data: SysdrawFile;
+} | {
+    ok: false;
+    error: string;
+};
+export declare function parseSysdraw(text: string): ParseResult;
+//# sourceMappingURL=sysdraw-file.d.ts.map

package/dist/sysdraw-file.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sysdraw-file.d.ts","sourceRoot":"","sources":["../src/sysdraw-file.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EACV,OAAO,EACP,OAAO,EACP,QAAQ,EACR,SAAS,EAIV,MAAM,SAAS,CAAC;AAGjB,eAAO,MAAM,eAAe,UAAU,CAAC;AAgGvC,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAK5B,CAAC;AAEH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAE5D,wBAAgB,gBAAgB,CAAC,KAAK,EAAE;IACtC,KAAK,EAAE,OAAO,EAAE,CAAC;IACjB,KAAK,EAAE,OAAO,EAAE,CAAC;IACjB,QAAQ,EAAE,QAAQ,CAAC;IACnB,SAAS,EAAE,SAAS,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB,GAAG,MAAM,CAuGT;AAED,MAAM,MAAM,WAAW,GACnB;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,IAAI,EAAE,WAAW,CAAA;CAAE,GAC/B;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAEjC,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,CAgBtD"}

package/dist/sysdraw-file.js

@@ -0,0 +1,215 @@
+import { z } from "zod";
+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 function serializeSysdraw(state) {
+    const sourceNodes = absolutizeAll(state.nodes);
+    const serializedNodes = sourceNodes.map((n) => {
+        if (n.type === "noteNode") {
+            return {
+                id: n.id,
+                type: "noteNode",
+                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",
+                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;
+            return {
+                id: sn.id,
+                type: "stepNode",
+                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;
+            return {
+                id: an.id,
+                type: "arrowNode",
+                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;
+        return {
+            id: sn.id,
+            type: "sysNode",
+            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",
+            ...(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 function parseSysdraw(text) {
+    let json;
+    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/dist/types.d.ts

@@ -0,0 +1,70 @@
+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>;
+};
+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;
+};
+export {};
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}

package/dist/types.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@modudraft/core",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "Modudraft scene model, shape ops, and serialization — no React",
   "type": "module",
   "main": "./dist/index.js",
@@ -23,6 +23,9 @@
   "devDependencies": {
     "typescript": "~6.0.2"
   },
+  "files": [
+    "dist"
+  ],
   "publishConfig": {
     "access": "public"
   }