@svfig/core 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from './serdes';
+export * from './types';
+export { CanvasView, ElementView, generate, type Image, ImageView, type Polygon, PolygonView, type Polyline, PolylineView, resolve, type Textbox, TextboxView, } from './view';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,SAAS,CAAC;AACxB,OAAO,EACL,UAAU,EACV,WAAW,EACX,QAAQ,EACR,KAAK,KAAK,EACV,SAAS,EACT,KAAK,OAAO,EACZ,WAAW,EACX,KAAK,QAAQ,EACb,YAAY,EACZ,OAAO,EACP,KAAK,OAAO,EACZ,WAAW,GACZ,MAAM,QAAQ,CAAC"}

package/dist/index.js

@@ -0,0 +1,286 @@
+// src/serdes.ts
+var parse = (src, filename = "<input>") => {
+  try {
+    return JSON.parse(src);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to parse SVFIG document at ${filename}: ${message}`);
+  }
+};
+var serialize = (doc) => {
+  return `${JSON.stringify(doc, null, 2)}
+`;
+};
+
+// src/view/elem/image.tsx
+import { jsx } from "react/jsx-runtime";
+var ImageView = ({ elem }) => {
+  const [w, h] = elem.size;
+  const [x, y] = elem.pos;
+  const cx = x + w / 2;
+  const cy = y + h / 2;
+  const transform = elem.rot ? `rotate(${elem.rot} ${cx} ${cy})` : void 0;
+  return /* @__PURE__ */ jsx(
+    "image",
+    {
+      x,
+      y,
+      width: w,
+      height: h,
+      href: elem.path,
+      transform,
+      preserveAspectRatio: "xMidYMid meet"
+    }
+  );
+};
+var resolveImage = (p, d) => ({
+  path: p.path ?? d.path,
+  size: p.size ?? d.size,
+  pos: p.pos ?? d.pos,
+  rot: p.rot ?? d.rot,
+  round: p.round ?? d.round
+});
+
+// src/view/elem/polygon.tsx
+import { jsx as jsx2 } from "react/jsx-runtime";
+var PolygonView = ({ elem }) => {
+  const points = elem.points.map(([x, y]) => `${x},${y}`).join(" ");
+  return /* @__PURE__ */ jsx2(
+    "polygon",
+    {
+      points,
+      fill: elem.fill.color,
+      fillOpacity: elem.fill.opacity,
+      stroke: elem.line.color,
+      strokeWidth: elem.line.width
+    }
+  );
+};
+var resolvePolygon = (p, d) => {
+  const merged = {
+    ...d,
+    ...p,
+    fill: { ...d.fill, ...p.fill },
+    line: { ...d.line, ...p.line }
+  };
+  return {
+    points: merged.points,
+    line: merged.line,
+    fill: merged.fill
+  };
+};
+
+// src/view/elem/polyline.tsx
+import { useId } from "react";
+import { jsx as jsx3, jsxs } from "react/jsx-runtime";
+var unitDir = (from, to) => {
+  const dx = to[0] - from[0];
+  const dy = to[1] - from[1];
+  const len = Math.hypot(dx, dy);
+  if (len === 0) return [0, 0];
+  return [dx / len, dy / len];
+};
+var EdgeMark = ({ at, dir, edge, color }) => {
+  if (edge.type === "none" || edge.size <= 0) return null;
+  if (edge.type === "circle") {
+    return /* @__PURE__ */ jsx3("circle", { cx: at[0], cy: at[1], r: edge.size / 2, fill: color });
+  }
+  const [dx, dy] = dir;
+  const baseX = at[0] - dx * edge.size;
+  const baseY = at[1] - dy * edge.size;
+  const halfW = edge.size / 2;
+  const lx = baseX - dy * halfW;
+  const ly = baseY + dx * halfW;
+  const rx = baseX + dy * halfW;
+  const ry = baseY - dx * halfW;
+  return /* @__PURE__ */ jsx3("polygon", { points: `${at[0]},${at[1]} ${lx},${ly} ${rx},${ry}`, fill: color });
+};
+var ArrowMaskCut = ({ at, dir, edge }) => {
+  if (edge.type !== "arrow" || edge.size <= 0) return null;
+  const [dx, dy] = dir;
+  const bx = at[0] - dx * edge.size;
+  const by = at[1] - dy * edge.size;
+  const L = 1e5;
+  const px = -dy;
+  const py = dx;
+  const p1 = [bx + px * L, by + py * L];
+  const p2 = [bx - px * L, by - py * L];
+  const p3 = [p2[0] + dx * L, p2[1] + dy * L];
+  const p4 = [p1[0] + dx * L, p1[1] + dy * L];
+  return /* @__PURE__ */ jsx3("polygon", { points: `${p1[0]},${p1[1]} ${p2[0]},${p2[1]} ${p3[0]},${p3[1]} ${p4[0]},${p4[1]}`, fill: "black" });
+};
+var hasArrowEdge = (edge) => edge.type === "arrow" && edge.size > 0;
+var PolylineView = ({ elem }) => {
+  const rawId = useId();
+  const maskId = `m${rawId.replace(/[^a-zA-Z0-9_-]/g, "_")}`;
+  const points = elem.points.map(([x, y]) => `${x},${y}`).join(" ");
+  const n = elem.points.length;
+  const [beginEdge, endEdge] = elem.edge;
+  const beginPt = n > 0 ? elem.points[0] : null;
+  const beginDir = n >= 2 ? unitDir(elem.points[1], elem.points[0]) : null;
+  const endPt = n > 0 ? elem.points[n - 1] : null;
+  const endDir = n >= 2 ? unitDir(elem.points[n - 2], elem.points[n - 1]) : null;
+  const useMask = !!beginPt && !!beginDir && hasArrowEdge(beginEdge) || !!endPt && !!endDir && hasArrowEdge(endEdge);
+  return /* @__PURE__ */ jsxs("g", { children: [
+    useMask && /* @__PURE__ */ jsx3("defs", { children: /* @__PURE__ */ jsxs("mask", { id: maskId, maskUnits: "userSpaceOnUse", children: [
+      /* @__PURE__ */ jsx3("rect", { x: -1e5, y: -1e5, width: 2e5, height: 2e5, fill: "white" }),
+      beginPt && beginDir && /* @__PURE__ */ jsx3(ArrowMaskCut, { at: beginPt, dir: beginDir, edge: beginEdge }),
+      endPt && endDir && /* @__PURE__ */ jsx3(ArrowMaskCut, { at: endPt, dir: endDir, edge: endEdge })
+    ] }) }),
+    /* @__PURE__ */ jsx3(
+      "polyline",
+      {
+        points,
+        fill: "none",
+        stroke: elem.line.color,
+        strokeWidth: elem.line.width,
+        strokeLinejoin: "round",
+        strokeLinecap: "round",
+        mask: useMask ? `url(#${maskId})` : void 0
+      }
+    ),
+    beginPt && beginDir && /* @__PURE__ */ jsx3(EdgeMark, { at: beginPt, dir: beginDir, edge: beginEdge, color: elem.line.color }),
+    endPt && endDir && /* @__PURE__ */ jsx3(EdgeMark, { at: endPt, dir: endDir, edge: endEdge, color: elem.line.color })
+  ] });
+};
+var DEFAULT_EDGE = { type: "none", size: 0 };
+var resolvePolyline = (p, d) => {
+  const dBegin = d.edge?.[0] ?? DEFAULT_EDGE;
+  const dEnd = d.edge?.[1] ?? DEFAULT_EDGE;
+  const pBegin = p.edge?.[0];
+  const pEnd = p.edge?.[1];
+  const merged = {
+    ...d,
+    ...p,
+    line: { ...d.line, ...p.line },
+    edge: [
+      { ...dBegin, ...pBegin },
+      { ...dEnd, ...pEnd }
+    ]
+  };
+  return {
+    points: merged.points,
+    line: merged.line,
+    edge: merged.edge
+  };
+};
+
+// src/view/elem/textbox.tsx
+import { jsx as jsx4, jsxs as jsxs2 } from "react/jsx-runtime";
+var TextboxView = ({ elem }) => {
+  const [w, h] = elem.size;
+  const [x, y] = elem.pos;
+  const cx = x + w / 2;
+  const cy = y + h / 2;
+  const transform = elem.rot ? `rotate(${elem.rot} ${cx} ${cy})` : void 0;
+  return /* @__PURE__ */ jsxs2("g", { transform, children: [
+    /* @__PURE__ */ jsx4(
+      "rect",
+      {
+        x,
+        y,
+        width: w,
+        height: h,
+        rx: elem.round || void 0,
+        ry: elem.round || void 0,
+        fill: elem.fill.color,
+        fillOpacity: elem.fill.opacity,
+        stroke: elem.line.color,
+        strokeWidth: elem.line.width
+      }
+    ),
+    elem.text.text && /* @__PURE__ */ jsx4(
+      "text",
+      {
+        x: cx,
+        y: cy,
+        fontFamily: elem.text.font,
+        fontSize: elem.text.size,
+        textAnchor: "middle",
+        dominantBaseline: "central",
+        fill: elem.line.color,
+        children: elem.text.text
+      }
+    )
+  ] });
+};
+var resolveTextbox = (p, d) => {
+  const merged = {
+    ...d,
+    ...p,
+    fill: { ...d.fill, ...p.fill },
+    line: { ...d.line, ...p.line },
+    text: { ...d.text, ...p.text }
+  };
+  return {
+    size: merged.size,
+    pos: merged.pos,
+    rot: merged.rot,
+    round: merged.round,
+    fill: merged.fill,
+    line: merged.line,
+    text: merged.text
+  };
+};
+
+// src/view/elem/canvas.tsx
+import { jsx as jsx5, jsxs as jsxs3 } from "react/jsx-runtime";
+var CanvasView = ({ canvas, children }) => {
+  const [w, h] = canvas.size;
+  return (
+    // biome-ignore lint/a11y/noSvgWithoutTitle: SVFIG canvases are caller-described.
+    /* @__PURE__ */ jsxs3("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: `0 0 ${w} ${h}`, width: w, height: h, children: [
+      canvas.color && canvas.color !== "none" && /* @__PURE__ */ jsx5("rect", { x: 0, y: 0, width: w, height: h, fill: canvas.color }),
+      children
+    ] })
+  );
+};
+
+// src/view/generate.tsx
+import { jsx as jsx6 } from "react/jsx-runtime";
+var generate = async (doc) => {
+  const elements = doc.elements.map((el) => resolve(el, doc.default));
+  return /* @__PURE__ */ jsx6(CanvasView, { canvas: doc.canvas, children: elements.map((elem, i) => (
+    // biome-ignore lint/suspicious/noArrayIndexKey: static SVG, no client state.
+    /* @__PURE__ */ jsx6(ElementView, { elem }, i)
+  )) });
+};
+
+// src/view/index.tsx
+import { jsx as jsx7 } from "react/jsx-runtime";
+var resolve = (elem, d) => {
+  switch (elem.kind) {
+    case "image":
+      return { kind: "image", ...resolveImage(elem, d.image) };
+    case "textbox":
+      return { kind: "textbox", ...resolveTextbox(elem, d.textbox) };
+    case "polygon":
+      return { kind: "polygon", ...resolvePolygon(elem, d.polygon) };
+    case "polyline":
+      return { kind: "polyline", ...resolvePolyline(elem, d.polyline) };
+  }
+};
+var ElementView = ({ elem }) => {
+  switch (elem.kind) {
+    case "image":
+      return /* @__PURE__ */ jsx7(ImageView, { elem });
+    case "textbox":
+      return /* @__PURE__ */ jsx7(TextboxView, { elem });
+    case "polygon":
+      return /* @__PURE__ */ jsx7(PolygonView, { elem });
+    case "polyline":
+      return /* @__PURE__ */ jsx7(PolylineView, { elem });
+  }
+};
+export {
+  CanvasView,
+  ElementView,
+  ImageView,
+  PolygonView,
+  PolylineView,
+  TextboxView,
+  generate,
+  parse,
+  resolve,
+  serialize
+};

package/dist/serdes.d.ts

@@ -0,0 +1,4 @@
+import type { Document } from './types';
+export declare const parse: (src: string, filename?: string) => Document;
+export declare const serialize: (doc: Document) => string;
+//# sourceMappingURL=serdes.d.ts.map

package/dist/serdes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serdes.d.ts","sourceRoot":"","sources":["../src/serdes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAExC,eAAO,MAAM,KAAK,GAAI,KAAK,MAAM,EAAE,iBAAoB,KAAG,QAOzD,CAAC;AAEF,eAAO,MAAM,SAAS,GAAI,KAAK,QAAQ,KAAG,MAEzC,CAAC"}

package/dist/types.d.ts

@@ -0,0 +1,95 @@
+export type Element = ({
+    kind: 'image';
+} & Image) | ({
+    kind: 'textbox';
+} & Textbox) | ({
+    kind: 'polygon';
+} & Polygon) | ({
+    kind: 'polyline';
+} & Polyline);
+export type ElementKind = Element['kind'];
+export type PartialElement = ({
+    kind: 'image';
+} & Partial<Image>) | ({
+    kind: 'textbox';
+} & Partial<Textbox>) | ({
+    kind: 'polygon';
+} & Partial<Polygon>) | ({
+    kind: 'polyline';
+} & Partial<Polyline>);
+export interface Document {
+    version: 1;
+    canvas: Canvas;
+    default: Default;
+    elements: PartialElement[];
+}
+export interface Canvas {
+    size: [number, number];
+    color: string;
+}
+export interface Default {
+    image: Image;
+    textbox: Textbox;
+    polygon: Polygon;
+    polyline: Polyline;
+}
+export interface Image {
+    path: string;
+    size: [number, number];
+    pos: [number, number];
+    rot: number;
+    round: number;
+}
+export interface Textbox {
+    size: [number, number];
+    pos: [number, number];
+    rot: number;
+    round: number;
+    fill: Fill;
+    line: Line;
+    text: Text;
+}
+export interface Polygon {
+    points: [number, number][];
+    line: Line;
+    fill: Fill;
+}
+export interface Polyline {
+    points: [number, number][];
+    line: Line;
+    edge: [Edge, Edge];
+}
+export interface Fill {
+    color: string;
+    opacity: number;
+}
+export interface Line {
+    color: string;
+    width: number;
+}
+export interface Text {
+    text: string;
+    color: string;
+    font: Font;
+    size: number;
+    align: TextAlign;
+    vert: TextVert;
+}
+export type Font = 'sans' | 'serif' | 'mono';
+export type TextAlign = 'left' | 'center' | 'right';
+export type TextVert = 'top' | 'middle' | 'bottom';
+export interface Edge {
+    type: 'none' | 'arrow' | 'circle';
+    size: number;
+}
+export interface Point {
+    x: number;
+    y: number;
+}
+export interface Box {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}
+//# 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.zod.d.ts

@@ -0,0 +1,441 @@
+import { z } from 'zod';
+export declare const fillSchema: z.ZodObject<{
+    color: z.ZodString;
+    opacity: z.ZodNumber;
+}, z.core.$strip>;
+export declare const lineSchema: z.ZodObject<{
+    color: z.ZodString;
+    width: z.ZodNumber;
+}, z.core.$strip>;
+export declare const edgeSchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        none: "none";
+        arrow: "arrow";
+        circle: "circle";
+    }>;
+    size: z.ZodNumber;
+}, z.core.$strip>;
+export declare const textSchema: z.ZodObject<{
+    str: z.ZodString;
+    align: z.ZodEnum<{
+        left: "left";
+        center: "center";
+        right: "right";
+    }>;
+    vert: z.ZodEnum<{
+        top: "top";
+        middle: "middle";
+        bottom: "bottom";
+    }>;
+    font: z.ZodEnum<{
+        sans: "sans";
+        serif: "serif";
+        mono: "mono";
+    }>;
+    size: z.ZodNumber;
+}, z.core.$strip>;
+export declare const canvasSchema: z.ZodObject<{
+    size: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+    color: z.ZodString;
+}, z.core.$strip>;
+export declare const pointSchema: z.ZodObject<{
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+}, z.core.$strip>;
+export declare const boxSchema: z.ZodObject<{
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+    w: z.ZodNumber;
+    h: z.ZodNumber;
+}, z.core.$strip>;
+export declare const imageSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"image">;
+    path: z.ZodString;
+    size: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+    pos: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+    rot: z.ZodNumber;
+    round: z.ZodNumber;
+}, z.core.$strip>;
+export declare const textboxSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"textbox">;
+    size: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+    pos: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+    rot: z.ZodNumber;
+    round: z.ZodNumber;
+    fill: z.ZodObject<{
+        color: z.ZodString;
+        opacity: z.ZodNumber;
+    }, z.core.$strip>;
+    line: z.ZodObject<{
+        color: z.ZodString;
+        width: z.ZodNumber;
+    }, z.core.$strip>;
+    text: z.ZodObject<{
+        str: z.ZodString;
+        align: z.ZodEnum<{
+            left: "left";
+            center: "center";
+            right: "right";
+        }>;
+        vert: z.ZodEnum<{
+            top: "top";
+            middle: "middle";
+            bottom: "bottom";
+        }>;
+        font: z.ZodEnum<{
+            sans: "sans";
+            serif: "serif";
+            mono: "mono";
+        }>;
+        size: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const polygonSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"polygon">;
+    points: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+    line: z.ZodObject<{
+        color: z.ZodString;
+        width: z.ZodNumber;
+    }, z.core.$strip>;
+    fill: z.ZodObject<{
+        color: z.ZodString;
+        opacity: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const polylineSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"polyline">;
+    points: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+    line: z.ZodObject<{
+        color: z.ZodString;
+        width: z.ZodNumber;
+    }, z.core.$strip>;
+    edge: z.ZodTuple<[z.ZodObject<{
+        type: z.ZodEnum<{
+            none: "none";
+            arrow: "arrow";
+            circle: "circle";
+        }>;
+        size: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodEnum<{
+            none: "none";
+            arrow: "arrow";
+            circle: "circle";
+        }>;
+        size: z.ZodNumber;
+    }, z.core.$strip>], null>;
+}, z.core.$strip>;
+export declare const elementSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"image">;
+    path: z.ZodString;
+    size: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+    pos: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+    rot: z.ZodNumber;
+    round: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"textbox">;
+    size: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+    pos: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+    rot: z.ZodNumber;
+    round: z.ZodNumber;
+    fill: z.ZodObject<{
+        color: z.ZodString;
+        opacity: z.ZodNumber;
+    }, z.core.$strip>;
+    line: z.ZodObject<{
+        color: z.ZodString;
+        width: z.ZodNumber;
+    }, z.core.$strip>;
+    text: z.ZodObject<{
+        str: z.ZodString;
+        align: z.ZodEnum<{
+            left: "left";
+            center: "center";
+            right: "right";
+        }>;
+        vert: z.ZodEnum<{
+            top: "top";
+            middle: "middle";
+            bottom: "bottom";
+        }>;
+        font: z.ZodEnum<{
+            sans: "sans";
+            serif: "serif";
+            mono: "mono";
+        }>;
+        size: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"polygon">;
+    points: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+    line: z.ZodObject<{
+        color: z.ZodString;
+        width: z.ZodNumber;
+    }, z.core.$strip>;
+    fill: z.ZodObject<{
+        color: z.ZodString;
+        opacity: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"polyline">;
+    points: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+    line: z.ZodObject<{
+        color: z.ZodString;
+        width: z.ZodNumber;
+    }, z.core.$strip>;
+    edge: z.ZodTuple<[z.ZodObject<{
+        type: z.ZodEnum<{
+            none: "none";
+            arrow: "arrow";
+            circle: "circle";
+        }>;
+        size: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodEnum<{
+            none: "none";
+            arrow: "arrow";
+            circle: "circle";
+        }>;
+        size: z.ZodNumber;
+    }, z.core.$strip>], null>;
+}, z.core.$strip>], "kind">;
+export declare const defaultSchema: z.ZodObject<{
+    image: z.ZodObject<{
+        kind: z.ZodLiteral<"image">;
+        path: z.ZodString;
+        size: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+        pos: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+        rot: z.ZodNumber;
+        round: z.ZodNumber;
+    }, z.core.$strip>;
+    textbox: z.ZodObject<{
+        kind: z.ZodLiteral<"textbox">;
+        size: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+        pos: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+        rot: z.ZodNumber;
+        round: z.ZodNumber;
+        fill: z.ZodObject<{
+            color: z.ZodString;
+            opacity: z.ZodNumber;
+        }, z.core.$strip>;
+        line: z.ZodObject<{
+            color: z.ZodString;
+            width: z.ZodNumber;
+        }, z.core.$strip>;
+        text: z.ZodObject<{
+            str: z.ZodString;
+            align: z.ZodEnum<{
+                left: "left";
+                center: "center";
+                right: "right";
+            }>;
+            vert: z.ZodEnum<{
+                top: "top";
+                middle: "middle";
+                bottom: "bottom";
+            }>;
+            font: z.ZodEnum<{
+                sans: "sans";
+                serif: "serif";
+                mono: "mono";
+            }>;
+            size: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    polygon: z.ZodObject<{
+        kind: z.ZodLiteral<"polygon">;
+        points: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+        line: z.ZodObject<{
+            color: z.ZodString;
+            width: z.ZodNumber;
+        }, z.core.$strip>;
+        fill: z.ZodObject<{
+            color: z.ZodString;
+            opacity: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    polyline: z.ZodObject<{
+        kind: z.ZodLiteral<"polyline">;
+        points: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+        line: z.ZodObject<{
+            color: z.ZodString;
+            width: z.ZodNumber;
+        }, z.core.$strip>;
+        edge: z.ZodTuple<[z.ZodObject<{
+            type: z.ZodEnum<{
+                none: "none";
+                arrow: "arrow";
+                circle: "circle";
+            }>;
+            size: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodEnum<{
+                none: "none";
+                arrow: "arrow";
+                circle: "circle";
+            }>;
+            size: z.ZodNumber;
+        }, z.core.$strip>], null>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const documentSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    canvas: z.ZodObject<{
+        size: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+        color: z.ZodString;
+    }, z.core.$strip>;
+    default: z.ZodObject<{
+        image: z.ZodObject<{
+            kind: z.ZodLiteral<"image">;
+            path: z.ZodString;
+            size: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+            pos: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+            rot: z.ZodNumber;
+            round: z.ZodNumber;
+        }, z.core.$strip>;
+        textbox: z.ZodObject<{
+            kind: z.ZodLiteral<"textbox">;
+            size: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+            pos: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+            rot: z.ZodNumber;
+            round: z.ZodNumber;
+            fill: z.ZodObject<{
+                color: z.ZodString;
+                opacity: z.ZodNumber;
+            }, z.core.$strip>;
+            line: z.ZodObject<{
+                color: z.ZodString;
+                width: z.ZodNumber;
+            }, z.core.$strip>;
+            text: z.ZodObject<{
+                str: z.ZodString;
+                align: z.ZodEnum<{
+                    left: "left";
+                    center: "center";
+                    right: "right";
+                }>;
+                vert: z.ZodEnum<{
+                    top: "top";
+                    middle: "middle";
+                    bottom: "bottom";
+                }>;
+                font: z.ZodEnum<{
+                    sans: "sans";
+                    serif: "serif";
+                    mono: "mono";
+                }>;
+                size: z.ZodNumber;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+        polygon: z.ZodObject<{
+            kind: z.ZodLiteral<"polygon">;
+            points: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+            line: z.ZodObject<{
+                color: z.ZodString;
+                width: z.ZodNumber;
+            }, z.core.$strip>;
+            fill: z.ZodObject<{
+                color: z.ZodString;
+                opacity: z.ZodNumber;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+        polyline: z.ZodObject<{
+            kind: z.ZodLiteral<"polyline">;
+            points: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+            line: z.ZodObject<{
+                color: z.ZodString;
+                width: z.ZodNumber;
+            }, z.core.$strip>;
+            edge: z.ZodTuple<[z.ZodObject<{
+                type: z.ZodEnum<{
+                    none: "none";
+                    arrow: "arrow";
+                    circle: "circle";
+                }>;
+                size: z.ZodNumber;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodEnum<{
+                    none: "none";
+                    arrow: "arrow";
+                    circle: "circle";
+                }>;
+                size: z.ZodNumber;
+            }, z.core.$strip>], null>;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    elements: z.ZodArray<z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodObject<{
+        kind: z.ZodOptional<z.ZodLiteral<"image">>;
+        path: z.ZodOptional<z.ZodString>;
+        size: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+        pos: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+        rot: z.ZodOptional<z.ZodNumber>;
+        round: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodOptional<z.ZodLiteral<"textbox">>;
+        size: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+        pos: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+        rot: z.ZodOptional<z.ZodNumber>;
+        round: z.ZodOptional<z.ZodNumber>;
+        fill: z.ZodOptional<z.ZodObject<{
+            color: z.ZodString;
+            opacity: z.ZodNumber;
+        }, z.core.$strip>>;
+        line: z.ZodOptional<z.ZodObject<{
+            color: z.ZodString;
+            width: z.ZodNumber;
+        }, z.core.$strip>>;
+        text: z.ZodOptional<z.ZodObject<{
+            str: z.ZodString;
+            align: z.ZodEnum<{
+                left: "left";
+                center: "center";
+                right: "right";
+            }>;
+            vert: z.ZodEnum<{
+                top: "top";
+                middle: "middle";
+                bottom: "bottom";
+            }>;
+            font: z.ZodEnum<{
+                sans: "sans";
+                serif: "serif";
+                mono: "mono";
+            }>;
+            size: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>]>, z.ZodObject<{
+        kind: z.ZodOptional<z.ZodLiteral<"polygon">>;
+        points: z.ZodOptional<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>;
+        line: z.ZodOptional<z.ZodObject<{
+            color: z.ZodString;
+            width: z.ZodNumber;
+        }, z.core.$strip>>;
+        fill: z.ZodOptional<z.ZodObject<{
+            color: z.ZodString;
+            opacity: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>]>, z.ZodObject<{
+        kind: z.ZodOptional<z.ZodLiteral<"polyline">>;
+        points: z.ZodOptional<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>;
+        line: z.ZodOptional<z.ZodObject<{
+            color: z.ZodString;
+            width: z.ZodNumber;
+        }, z.core.$strip>>;
+        edge: z.ZodOptional<z.ZodTuple<[z.ZodObject<{
+            type: z.ZodEnum<{
+                none: "none";
+                arrow: "arrow";
+                circle: "circle";
+            }>;
+            size: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodEnum<{
+                none: "none";
+                arrow: "arrow";
+                circle: "circle";
+            }>;
+            size: z.ZodNumber;
+        }, z.core.$strip>], null>>;
+    }, z.core.$strip>]>>;
+}, z.core.$strip>;
+//# sourceMappingURL=types.zod.d.ts.map

package/dist/types.zod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.zod.d.ts","sourceRoot":"","sources":["../src/types.zod.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,UAAU;;;iBAGrB,CAAC;AAEH,eAAO,MAAM,UAAU;;;iBAGrB,CAAC;AAEH,eAAO,MAAM,UAAU;;;;;;;iBAGrB,CAAC;AAEH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;iBAMrB,CAAC;AAEH,eAAO,MAAM,YAAY;;;iBAGvB,CAAC;AAEH,eAAO,MAAM,WAAW;;;iBAGtB,CAAC;AAEH,eAAO,MAAM,SAAS;;;;;iBAKpB,CAAC;AAEH,eAAO,MAAM,WAAW;;;;;;;iBAOtB,CAAC;AAEH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBASxB,CAAC;AAEH,eAAO,MAAM,aAAa;;;;;;;;;;;iBAKxB,CAAC;AAEH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;iBAKzB,CAAC;AAEH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAA4F,CAAC;AAEvH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAKxB,CAAC;AAEH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAOzB,CAAC"}

package/dist/view/elem/canvas.d.ts

@@ -0,0 +1,7 @@
+import type { FC, ReactNode } from 'react';
+import type { Canvas } from '../../types';
+export declare const CanvasView: FC<{
+    canvas: Canvas;
+    children?: ReactNode;
+}>;
+//# sourceMappingURL=canvas.d.ts.map

package/dist/view/elem/canvas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"canvas.d.ts","sourceRoot":"","sources":["../../../src/view/elem/canvas.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAC3C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAE1C,eAAO,MAAM,UAAU,EAAE,EAAE,CAAC;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,SAAS,CAAA;CAAE,CAUnE,CAAC"}

package/dist/view/elem/image.d.ts

@@ -0,0 +1,7 @@
+import type { FC } from 'react';
+import type { Image } from '../../types';
+export declare const ImageView: FC<{
+    elem: Image;
+}>;
+export declare const resolveImage: (p: Partial<Image>, d: Image) => Image;
+//# sourceMappingURL=image.d.ts.map

package/dist/view/elem/image.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"image.d.ts","sourceRoot":"","sources":["../../../src/view/elem/image.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC;AAChC,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAEzC,eAAO,MAAM,SAAS,EAAE,EAAE,CAAC;IAAE,IAAI,EAAE,KAAK,CAAA;CAAE,CAkBzC,CAAC;AAEF,eAAO,MAAM,YAAY,GAAI,GAAG,OAAO,CAAC,KAAK,CAAC,EAAE,GAAG,KAAK,KAAG,KAMzD,CAAC"}

package/dist/view/elem/polygon.d.ts

@@ -0,0 +1,7 @@
+import type { FC } from 'react';
+import type { Polygon } from '../../types';
+export declare const PolygonView: FC<{
+    elem: Polygon;
+}>;
+export declare const resolvePolygon: (p: Partial<Polygon>, d: Polygon) => Polygon;
+//# sourceMappingURL=polygon.d.ts.map

package/dist/view/elem/polygon.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"polygon.d.ts","sourceRoot":"","sources":["../../../src/view/elem/polygon.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC;AAChC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAE3C,eAAO,MAAM,WAAW,EAAE,EAAE,CAAC;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,CAW7C,CAAC;AAEF,eAAO,MAAM,cAAc,GAAI,GAAG,OAAO,CAAC,OAAO,CAAC,EAAE,GAAG,OAAO,KAAG,OAahE,CAAC"}

package/dist/view/elem/polyline.d.ts

@@ -0,0 +1,7 @@
+import { type FC } from 'react';
+import type { Polyline } from '../../types';
+export declare const PolylineView: FC<{
+    elem: Polyline;
+}>;
+export declare const resolvePolyline: (p: Partial<Polyline>, d: Polyline) => Polyline;
+//# sourceMappingURL=polyline.d.ts.map

package/dist/view/elem/polyline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"polyline.d.ts","sourceRoot":"","sources":["../../../src/view/elem/polyline.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,EAAS,MAAM,OAAO,CAAC;AACvC,OAAO,KAAK,EAAQ,QAAQ,EAAE,MAAM,aAAa,CAAC;AAgDlD,eAAO,MAAM,YAAY,EAAE,EAAE,CAAC;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,CAsC/C,CAAC;AAIF,eAAO,MAAM,eAAe,GAAI,GAAG,OAAO,CAAC,QAAQ,CAAC,EAAE,GAAG,QAAQ,KAAG,QAoBnE,CAAC"}

package/dist/view/elem/textbox.d.ts

@@ -0,0 +1,7 @@
+import type { FC } from 'react';
+import type { Textbox } from '../../types';
+export declare const TextboxView: FC<{
+    elem: Textbox;
+}>;
+export declare const resolveTextbox: (p: Partial<Textbox>, d: Textbox) => Textbox;
+//# sourceMappingURL=textbox.d.ts.map

package/dist/view/elem/textbox.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"textbox.d.ts","sourceRoot":"","sources":["../../../src/view/elem/textbox.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC;AAChC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAE3C,eAAO,MAAM,WAAW,EAAE,EAAE,CAAC;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,CAoC7C,CAAC;AAEF,eAAO,MAAM,cAAc,GAAI,GAAG,OAAO,CAAC,OAAO,CAAC,EAAE,GAAG,OAAO,KAAG,OAkBhE,CAAC"}

package/dist/view/generate.d.ts

@@ -0,0 +1,4 @@
+import type { ReactElement } from 'react';
+import type { Document } from '../types';
+export declare const generate: (doc: Document) => Promise<ReactElement>;
+//# sourceMappingURL=generate.d.ts.map

package/dist/view/generate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate.d.ts","sourceRoot":"","sources":["../../src/view/generate.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,OAAO,CAAC;AAC1C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAIzC,eAAO,MAAM,QAAQ,GAAU,KAAK,QAAQ,KAAG,OAAO,CAAC,YAAY,CAUlE,CAAC"}

package/dist/view/index.d.ts

@@ -0,0 +1,14 @@
+import type { FC } from 'react';
+import type { Default, Element, PartialElement } from '../types';
+export type { Edge, Image, Polygon, Polyline, Textbox } from '../types';
+export { CanvasView } from './elem/canvas';
+export { ImageView } from './elem/image';
+export { PolygonView } from './elem/polygon';
+export { PolylineView } from './elem/polyline';
+export { TextboxView } from './elem/textbox';
+export { generate } from './generate';
+export declare const resolve: (elem: PartialElement, d: Default) => Element;
+export declare const ElementView: FC<{
+    elem: Element;
+}>;
+//# sourceMappingURL=index.d.ts.map

package/dist/view/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/view/index.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC;AAChC,OAAO,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAMjE,YAAY,EAAE,IAAI,EAAE,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AACxE,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AACzC,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7C,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7C,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAEtC,eAAO,MAAM,OAAO,GAAI,MAAM,cAAc,EAAE,GAAG,OAAO,KAAG,OAW1D,CAAC;AAEF,eAAO,MAAM,WAAW,EAAE,EAAE,CAAC;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,CAW7C,CAAC"}

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@svfig/core",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "sideEffects": false,
+  "peerDependencies": {
+    "react": "^19.0.0"
+  },
+  "dependencies": {
+    "zod": "^4.4.3"
+  },
+  "devDependencies": {
+    "@types/react": "^19.1.0",
+    "esbuild": "^0.27.0",
+    "react": "^19.1.0"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json --emitDeclarationOnly && pnpm exec esbuild src/index.ts --bundle --format=esm --platform=neutral --outfile=dist/index.js --external:react --external:react/jsx-runtime --external:zod",
+    "typecheck": "tsc -p tsconfig.json --noEmit"
+  }
+}