@retikz/core 0.0.1-rc.2 → 0.1.0-alpha.0

package/dist/lib/geometry/rect.cjs

@@ -0,0 +1,121 @@
+//#region src/geometry/rect.ts
+/**
+* 矩形 9 个标准 anchor 名常量集合，对应 TikZ 节点的 9 个标准 anchor。
+* 与 `RectAnchor` 类型配对使用——值用 `RECT_ANCHORS.NORTH` 避免拼错，
+* 类型位置用 `RectAnchor`。
+*/
+var RECT_ANCHORS = {
+	/** 几何中心 */
+	CENTER: "center",
+	/** 上边中点 */
+	NORTH: "north",
+	/** 下边中点 */
+	SOUTH: "south",
+	/** 右边中点 */
+	EAST: "east",
+	/** 左边中点 */
+	WEST: "west",
+	/** 右上角 */
+	NORTH_EAST: "north-east",
+	/** 左上角 */
+	NORTH_WEST: "north-west",
+	/** 右下角 */
+	SOUTH_EAST: "south-east",
+	/** 左下角 */
+	SOUTH_WEST: "south-west"
+};
+/**
+* 把"以矩形中心为原点的本地坐标"转换为世界坐标。
+* 考虑 rect.rotate（弧度）的旋转。
+*/
+var localToWorld = (r, local) => {
+	const angle = r.rotate ?? 0;
+	if (angle === 0) return [r.x + local[0], r.y + local[1]];
+	const cos = Math.cos(angle);
+	const sin = Math.sin(angle);
+	return [r.x + local[0] * cos - local[1] * sin, r.y + local[0] * sin + local[1] * cos];
+};
+/**
+* 把世界坐标转换为"以矩形中心为原点的本地坐标"。
+* 与 localToWorld 互为逆变换。
+*/
+var worldToLocal = (r, world) => {
+	const tx = world[0] - r.x;
+	const ty = world[1] - r.y;
+	const angle = r.rotate ?? 0;
+	if (angle === 0) return [tx, ty];
+	const cos = Math.cos(angle);
+	const sin = Math.sin(angle);
+	return [tx * cos + ty * sin, -tx * sin + ty * cos];
+};
+/** 矩形相关基础工具 */
+var rect = {
+	/** 矩形几何中心点 */
+	center: (r) => [r.x, r.y],
+	/** 判断点是否落在矩形范围内（含边界，考虑旋转） */
+	contains: (r, p) => {
+		const [lx, ly] = worldToLocal(r, p);
+		const halfW = r.width / 2;
+		const halfH = r.height / 2;
+		return lx >= -halfW && lx <= halfW && ly >= -halfH && ly <= halfH;
+	},
+	/**
+	* 取矩形 9 个标准 anchor 之一的世界坐标，考虑旋转。
+	* 名字与 TikZ 节点 anchor 一致（north / south / east / west / north-east / ... / center）。
+	*/
+	anchor: (r, name) => {
+		const halfW = r.width / 2;
+		const halfH = r.height / 2;
+		let lx = 0;
+		let ly = 0;
+		switch (name) {
+			case "center": break;
+			case "north":
+				ly = -halfH;
+				break;
+			case "south":
+				ly = halfH;
+				break;
+			case "east":
+				lx = halfW;
+				break;
+			case "west":
+				lx = -halfW;
+				break;
+			case "north-east":
+				lx = halfW;
+				ly = -halfH;
+				break;
+			case "north-west":
+				lx = -halfW;
+				ly = -halfH;
+				break;
+			case "south-east":
+				lx = halfW;
+				ly = halfH;
+				break;
+			case "south-west":
+				lx = -halfW;
+				ly = halfH;
+				break;
+		}
+		return localToWorld(r, [lx, ly]);
+	},
+	/**
+	* 从矩形中心向 toward 方向画射线，求与矩形边界的交点（考虑旋转）。
+	* 用于把 Path 端点贴到 Node 边界（避免线段穿过节点内部）。
+	*/
+	boundaryPoint: (r, toward) => {
+		const [localX, localY] = worldToLocal(r, toward);
+		if (localX === 0 && localY === 0) return [r.x, r.y];
+		const halfW = r.width / 2;
+		const halfH = r.height / 2;
+		const tx = localX === 0 ? Infinity : halfW / Math.abs(localX);
+		const ty = localY === 0 ? Infinity : halfH / Math.abs(localY);
+		const t = Math.min(tx, ty);
+		return localToWorld(r, [localX * t, localY * t]);
+	}
+};
+//#endregion
+exports.RECT_ANCHORS = RECT_ANCHORS;
+exports.rect = rect;

package/dist/lib/geometry/rect.d.ts

@@ -0,0 +1,59 @@
+import { Position } from './point';
+/** 轴对齐矩形：几何中心 (x, y) + 宽高 + 可选绕中心旋转 */
+export type Rect = {
+    /** 矩形几何中心横坐标 */
+    x: number;
+    /** 矩形几何中心纵坐标 */
+    y: number;
+    /** 矩形宽度（user units） */
+    width: number;
+    /** 矩形高度（user units） */
+    height: number;
+    /** 绕几何中心的旋转角（弧度）；省略或 0 表示不旋转 */
+    rotate?: number;
+};
+/**
+ * 矩形 9 个标准 anchor 名常量集合，对应 TikZ 节点的 9 个标准 anchor。
+ * 与 `RectAnchor` 类型配对使用——值用 `RECT_ANCHORS.NORTH` 避免拼错，
+ * 类型位置用 `RectAnchor`。
+ */
+export declare const RECT_ANCHORS: {
+    /** 几何中心 */
+    readonly CENTER: "center";
+    /** 上边中点 */
+    readonly NORTH: "north";
+    /** 下边中点 */
+    readonly SOUTH: "south";
+    /** 右边中点 */
+    readonly EAST: "east";
+    /** 左边中点 */
+    readonly WEST: "west";
+    /** 右上角 */
+    readonly NORTH_EAST: "north-east";
+    /** 左上角 */
+    readonly NORTH_WEST: "north-west";
+    /** 右下角 */
+    readonly SOUTH_EAST: "south-east";
+    /** 左下角 */
+    readonly SOUTH_WEST: "south-west";
+};
+/** 矩形 anchor 名（与 TikZ 命名约定一致），由 `RECT_ANCHORS` 常量集合派生 */
+export type RectAnchor = (typeof RECT_ANCHORS)[keyof typeof RECT_ANCHORS];
+/** 矩形相关基础工具 */
+export declare const rect: {
+    /** 矩形几何中心点 */
+    center: (r: Rect) => Position;
+    /** 判断点是否落在矩形范围内（含边界，考虑旋转） */
+    contains: (r: Rect, p: Position) => boolean;
+    /**
+     * 取矩形 9 个标准 anchor 之一的世界坐标，考虑旋转。
+     * 名字与 TikZ 节点 anchor 一致（north / south / east / west / north-east / ... / center）。
+     */
+    anchor: (r: Rect, name: RectAnchor) => Position;
+    /**
+     * 从矩形中心向 toward 方向画射线，求与矩形边界的交点（考虑旋转）。
+     * 用于把 Path 端点贴到 Node 边界（避免线段穿过节点内部）。
+     */
+    boundaryPoint: (r: Rect, toward: Position) => Position;
+};
+//# sourceMappingURL=rect.d.ts.map

package/dist/lib/geometry/rect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rect.d.ts","sourceRoot":"","sources":["../../../src/geometry/rect.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAExC,uCAAuC;AACvC,MAAM,MAAM,IAAI,GAAG;IACjB,gBAAgB;IAChB,CAAC,EAAE,MAAM,CAAC;IACV,gBAAgB;IAChB,CAAC,EAAE,MAAM,CAAC;IACV,uBAAuB;IACvB,KAAK,EAAE,MAAM,CAAC;IACd,uBAAuB;IACvB,MAAM,EAAE,MAAM,CAAC;IACf,gCAAgC;IAChC,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,YAAY;IACvB,WAAW;;IAEX,WAAW;;IAEX,WAAW;;IAEX,WAAW;;IAEX,WAAW;;IAEX,UAAU;;IAEV,UAAU;;IAEV,UAAU;;IAEV,UAAU;;CAEF,CAAC;AAEX,yDAAyD;AACzD,MAAM,MAAM,UAAU,GAAG,CAAC,OAAO,YAAY,CAAC,CAAC,MAAM,OAAO,YAAY,CAAC,CAAC;AAgC1E,eAAe;AACf,eAAO,MAAM,IAAI;IACf,cAAc;gBACF,IAAI,KAAG,QAAQ;IAC3B,6BAA6B;kBACf,IAAI,KAAK,QAAQ,KAAG,OAAO;IAMzC;;;OAGG;gBACS,IAAI,QAAQ,UAAU,KAAG,QAAQ;IAuC7C;;;OAGG;uBACgB,IAAI,UAAU,QAAQ,KAAG,QAAQ;CAUrD,CAAC"}

package/dist/lib/index.cjs

@@ -1,12 +1,32 @@
-"use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const Draw = require("./components/draw/Draw.cjs");
-const Node = require("./components/node/Node.cjs");
-const PathNode = require("./components/path-node/PathNode.cjs");
-const Scope = require("./components/Scope.cjs");
-const TikZ = require("./components/TikZ.cjs");
-exports.Draw = Draw.default;
-exports.Node = Node.default;
-exports.PathNode = PathNode.default;
-exports.Scope = Scope.default;
-exports.TikZ = TikZ.default;
+const require_position = require("./ir/position/position.cjs");
+const require_polar_position = require("./ir/position/polar-position.cjs");
+const require_target = require("./ir/path/target.cjs");
+const require_step = require("./ir/path/step.cjs");
+const require_path = require("./ir/path/path.cjs");
+const require_node = require("./ir/node.cjs");
+const require_scene = require("./ir/scene.cjs");
+const require_rect = require("./geometry/rect.cjs");
+const require_text_metrics = require("./compile/text-metrics.cjs");
+const require_compile = require("./compile/compile.cjs");
+const require_parseWay = require("./parsers/parseWay.cjs");
+const require_polar = require("./geometry/polar.cjs");
+const require_point = require("./geometry/point.cjs");
+exports.CURRENT_IR_VERSION = require_scene.CURRENT_IR_VERSION;
+exports.ChildSchema = require_scene.ChildSchema;
+exports.LineStepSchema = require_step.LineStepSchema;
+exports.MoveStepSchema = require_step.MoveStepSchema;
+exports.NodeSchema = require_node.NodeSchema;
+exports.PathSchema = require_path.PathSchema;
+exports.PolarPositionSchema = require_polar_position.PolarPositionSchema;
+exports.PositionSchema = require_position.PositionSchema;
+exports.RECT_ANCHORS = require_rect.RECT_ANCHORS;
+exports.SceneSchema = require_scene.SceneSchema;
+exports.StepSchema = require_step.StepSchema;
+exports.TargetSchema = require_target.TargetSchema;
+exports.compileToScene = require_compile.compileToScene;
+exports.fallbackMeasurer = require_text_metrics.fallbackMeasurer;
+exports.parseWay = require_parseWay.parseWay;
+exports.point = require_point.point;
+exports.polar = require_polar.polar;
+exports.rect = require_rect.rect;

package/dist/lib/index.d.ts

@@ -1,10 +1,18 @@
-export { default as Draw } from './components/draw';
-export type { DrawProps } from './components/draw';
-export { default as Node } from './components/node';
-export type { NodeProps } from './components/node';
-export { default as PathNode } from './components/path-node';
-export type { PathNodeProps } from './components/path-node';
-export { default as Scope } from './components/Scope';
-export type { ScopeProps } from './components/Scope';
-export { default as TikZ } from './components/TikZ';
-export type { TikZProps } from './components/TikZ';
+/**
+ * @retikz/core 公开 API
+ *
+ * 任何 framework adapter（@retikz/react、@retikz/vue、@retikz/canvas、@retikz/ssr）
+ * 只能 import 本文件导出的内容，不准走子路径。
+ *
+ * 本包零 React、零 DOM 依赖。
+ */
+export { PositionSchema, PolarPositionSchema, TargetSchema, MoveStepSchema, LineStepSchema, StepSchema, NodeSchema, PathSchema, ChildSchema, SceneSchema, CURRENT_IR_VERSION, } from './ir';
+export type { IRPosition, IRTarget, IRMoveStep, IRLineStep, IRStep, IRNode, IRPath, IRChild, IR, } from './ir';
+export type { ScenePrimitive, RectPrim, TextPrim, PathPrim, GroupPrim, ViewBox, Scene, } from './primitive';
+export type { FontSpec, TextMetrics, TextMeasurer, CompileOptions, } from './compile';
+export { fallbackMeasurer, compileToScene } from './compile';
+export type { WayItem, WayDSL } from './parsers';
+export { parseWay } from './parsers';
+export type { Position, Rect, RectAnchor, PolarPosition } from './geometry';
+export { point, rect, RECT_ANCHORS, polar } from './geometry';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,EACL,cAAc,EACd,mBAAmB,EACnB,YAAY,EACZ,cAAc,EACd,cAAc,EACd,UAAU,EACV,UAAU,EACV,UAAU,EACV,WAAW,EACX,WAAW,EACX,kBAAkB,GACnB,MAAM,MAAM,CAAC;AACd,YAAY,EACV,UAAU,EACV,QAAQ,EACR,UAAU,EACV,UAAU,EACV,MAAM,EACN,MAAM,EACN,MAAM,EACN,OAAO,EACP,EAAE,GACH,MAAM,MAAM,CAAC;AAGd,YAAY,EACV,cAAc,EACd,QAAQ,EACR,QAAQ,EACR,QAAQ,EACR,SAAS,EACT,OAAO,EACP,KAAK,GACN,MAAM,aAAa,CAAC;AAGrB,YAAY,EACV,QAAQ,EACR,WAAW,EACX,YAAY,EACZ,cAAc,GACf,MAAM,WAAW,CAAC;AACnB,OAAO,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAG7D,YAAY,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AACjD,OAAO,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AAIrC,YAAY,EAAE,QAAQ,EAAE,IAAI,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAC5E,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC"}

package/dist/lib/ir/index.d.ts

@@ -0,0 +1,5 @@
+export * from './position';
+export * from './path';
+export * from './node';
+export * from './scene';
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/ir/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/ir/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,QAAQ,CAAC;AACvB,cAAc,QAAQ,CAAC;AACvB,cAAc,SAAS,CAAC"}

package/dist/lib/ir/node.cjs

@@ -0,0 +1,19 @@
+const require_position = require("./position/position.cjs");
+const require_polar_position = require("./position/polar-position.cjs");
+let zod = require("zod");
+//#region src/ir/node.ts
+var NodeSchema = zod.z.object({
+	type: zod.z.literal("node").describe("Discriminator marking this child as a node"),
+	id: zod.z.string().min(1).optional().describe("Optional unique id; required if any path needs to reference this node by string"),
+	position: zod.z.union([require_position.PositionSchema, require_polar_position.PolarPositionSchema]).describe("Center point of the node content box; Cartesian [x, y] or polar (resolved at compile time)"),
+	rotate: zod.z.number().optional().describe("Rotation in degrees around the node center; positive = clockwise (matches TikZ rotate=...)"),
+	text: zod.z.string().optional().describe("Text label rendered inside the node; omit for an empty node"),
+	fill: zod.z.string().optional().describe("Background color of the node rectangle; any CSS color (e.g. \"lightblue\", \"#fafafa\", \"rgba(...)\")"),
+	stroke: zod.z.string().optional().describe("Border color of the node rectangle; any CSS color. Defaults to currentColor when omitted"),
+	strokeWidth: zod.z.number().optional().describe("Border width in user units; defaults to 1 when omitted"),
+	padding: zod.z.number().optional().describe("Inner padding in user units between the text content and the node border"),
+	margin: zod.z.number().nonnegative().optional().describe("Outer margin in user units: distance between the visual border and where paths attach. Lines stop this far from the border. Defaults to 0."),
+	fontSize: zod.z.number().optional().describe("Text font size in user units; defaults to a fixed size for now (TikZ font sizes will be supported later)")
+}).describe("Rectangle node with optional text label; the basic positional drawing primitive");
+//#endregion
+exports.NodeSchema = NodeSchema;

package/dist/lib/ir/node.d.ts

@@ -0,0 +1,41 @@
+import { z } from 'zod';
+export declare const NodeSchema: z.ZodObject<{
+    type: z.ZodLiteral<"node">;
+    id: z.ZodOptional<z.ZodString>;
+    position: z.ZodUnion<[z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, z.ZodType<import('./position').PolarPosition, z.ZodTypeDef, import('./position').PolarPosition>]>;
+    rotate: z.ZodOptional<z.ZodNumber>;
+    text: z.ZodOptional<z.ZodString>;
+    fill: z.ZodOptional<z.ZodString>;
+    stroke: z.ZodOptional<z.ZodString>;
+    strokeWidth: z.ZodOptional<z.ZodNumber>;
+    padding: z.ZodOptional<z.ZodNumber>;
+    margin: z.ZodOptional<z.ZodNumber>;
+    fontSize: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    type: "node";
+    position: [number, number] | import('./position').PolarPosition;
+    fill?: string | undefined;
+    stroke?: string | undefined;
+    strokeWidth?: number | undefined;
+    id?: string | undefined;
+    rotate?: number | undefined;
+    text?: string | undefined;
+    padding?: number | undefined;
+    margin?: number | undefined;
+    fontSize?: number | undefined;
+}, {
+    type: "node";
+    position: [number, number] | import('./position').PolarPosition;
+    fill?: string | undefined;
+    stroke?: string | undefined;
+    strokeWidth?: number | undefined;
+    id?: string | undefined;
+    rotate?: number | undefined;
+    text?: string | undefined;
+    padding?: number | undefined;
+    margin?: number | undefined;
+    fontSize?: number | undefined;
+}>;
+/** 节点：矩形 + 可选文本标签，是最基础的有定位图元 */
+export type IRNode = z.infer<typeof NodeSchema>;
+//# sourceMappingURL=node.d.ts.map

package/dist/lib/ir/node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../../../src/ir/node.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiEpB,CAAC;AAEJ,gCAAgC;AAChC,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC"}

package/dist/lib/ir/path/index.d.ts

@@ -0,0 +1,4 @@
+export * from './path';
+export * from './step';
+export * from './target';
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/ir/path/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/ir/path/index.ts"],"names":[],"mappings":"AAAA,cAAc,QAAQ,CAAC;AACvB,cAAc,QAAQ,CAAC;AACvB,cAAc,UAAU,CAAC"}

package/dist/lib/ir/path/path.cjs

@@ -0,0 +1,12 @@
+const require_step = require("./step.cjs");
+let zod = require("zod");
+//#region src/ir/path/path.ts
+var PathSchema = zod.z.object({
+	type: zod.z.literal("path").describe("Discriminator marking this child as a path"),
+	stroke: zod.z.string().optional().describe("Stroke color of the path; any CSS color. Defaults to currentColor when omitted"),
+	strokeWidth: zod.z.number().optional().describe("Stroke width in user units; defaults to 1 when omitted"),
+	strokeDasharray: zod.z.string().optional().describe("SVG stroke-dasharray pattern (e.g. \"4 2\"); leave empty for solid line"),
+	children: zod.z.array(require_step.StepSchema).min(2).describe("Sequence of step actions defining the path; the first should usually be a `move`")
+}).describe("A drawn path composed of a sequence of step actions (move / line / ...)");
+//#endregion
+exports.PathSchema = PathSchema;

package/dist/lib/ir/path/path.d.ts

@@ -0,0 +1,63 @@
+import { z } from 'zod';
+export declare const PathSchema: z.ZodObject<{
+    type: z.ZodLiteral<"path">;
+    stroke: z.ZodOptional<z.ZodString>;
+    strokeWidth: z.ZodOptional<z.ZodNumber>;
+    strokeDasharray: z.ZodOptional<z.ZodString>;
+    children: z.ZodArray<z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+        type: z.ZodLiteral<"step">;
+        kind: z.ZodLiteral<"move">;
+        to: z.ZodUnion<[z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, z.ZodType<import('..').PolarPosition, z.ZodTypeDef, import('..').PolarPosition>, z.ZodString]>;
+    }, "strip", z.ZodTypeAny, {
+        type: "step";
+        kind: "move";
+        to: string | [number, number] | import('..').PolarPosition;
+    }, {
+        type: "step";
+        kind: "move";
+        to: string | [number, number] | import('..').PolarPosition;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"step">;
+        kind: z.ZodLiteral<"line">;
+        to: z.ZodUnion<[z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, z.ZodType<import('..').PolarPosition, z.ZodTypeDef, import('..').PolarPosition>, z.ZodString]>;
+    }, "strip", z.ZodTypeAny, {
+        type: "step";
+        kind: "line";
+        to: string | [number, number] | import('..').PolarPosition;
+    }, {
+        type: "step";
+        kind: "line";
+        to: string | [number, number] | import('..').PolarPosition;
+    }>]>, "many">;
+}, "strip", z.ZodTypeAny, {
+    type: "path";
+    children: ({
+        type: "step";
+        kind: "move";
+        to: string | [number, number] | import('..').PolarPosition;
+    } | {
+        type: "step";
+        kind: "line";
+        to: string | [number, number] | import('..').PolarPosition;
+    })[];
+    stroke?: string | undefined;
+    strokeWidth?: number | undefined;
+    strokeDasharray?: string | undefined;
+}, {
+    type: "path";
+    children: ({
+        type: "step";
+        kind: "move";
+        to: string | [number, number] | import('..').PolarPosition;
+    } | {
+        type: "step";
+        kind: "line";
+        to: string | [number, number] | import('..').PolarPosition;
+    })[];
+    stroke?: string | undefined;
+    strokeWidth?: number | undefined;
+    strokeDasharray?: string | undefined;
+}>;
+/** 路径：由若干 step 动作（move / line / ...）组成的绘制路径 */
+export type IRPath = z.infer<typeof PathSchema>;
+//# sourceMappingURL=path.d.ts.map

package/dist/lib/ir/path/path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"path.d.ts","sourceRoot":"","sources":["../../../../src/ir/path/path.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA8BpB,CAAC;AAEJ,+CAA+C;AAC/C,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC"}

package/dist/lib/ir/path/step.cjs

@@ -0,0 +1,18 @@
+const require_target = require("./target.cjs");
+let zod = require("zod");
+//#region src/ir/path/step.ts
+var MoveStepSchema = zod.z.object({
+	type: zod.z.literal("step").describe("Discriminator marking this as a path step node"),
+	kind: zod.z.literal("move").describe("Move the cursor to the target without drawing (like SVG path \"M\")"),
+	to: require_target.TargetSchema.describe("Destination point of the move")
+}).describe("Move action: relocate the path cursor without drawing");
+var LineStepSchema = zod.z.object({
+	type: zod.z.literal("step").describe("Discriminator marking this as a path step node"),
+	kind: zod.z.literal("line").describe("Draw a straight line from the current cursor to the target (like SVG path \"L\")"),
+	to: require_target.TargetSchema.describe("Destination point of the line segment")
+}).describe("Line action: straight-line segment from cursor to target");
+var StepSchema = zod.z.discriminatedUnion("kind", [MoveStepSchema, LineStepSchema]).describe("A single path action; the discriminator field is `kind`");
+//#endregion
+exports.LineStepSchema = LineStepSchema;
+exports.MoveStepSchema = MoveStepSchema;
+exports.StepSchema = StepSchema;

package/dist/lib/ir/path/step.d.ts

@@ -0,0 +1,62 @@
+import { z } from 'zod';
+export declare const MoveStepSchema: z.ZodObject<{
+    type: z.ZodLiteral<"step">;
+    kind: z.ZodLiteral<"move">;
+    to: z.ZodUnion<[z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, z.ZodType<import('..').PolarPosition, z.ZodTypeDef, import('..').PolarPosition>, z.ZodString]>;
+}, "strip", z.ZodTypeAny, {
+    type: "step";
+    kind: "move";
+    to: string | [number, number] | import('..').PolarPosition;
+}, {
+    type: "step";
+    kind: "move";
+    to: string | [number, number] | import('..').PolarPosition;
+}>;
+export declare const LineStepSchema: z.ZodObject<{
+    type: z.ZodLiteral<"step">;
+    kind: z.ZodLiteral<"line">;
+    to: z.ZodUnion<[z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, z.ZodType<import('..').PolarPosition, z.ZodTypeDef, import('..').PolarPosition>, z.ZodString]>;
+}, "strip", z.ZodTypeAny, {
+    type: "step";
+    kind: "line";
+    to: string | [number, number] | import('..').PolarPosition;
+}, {
+    type: "step";
+    kind: "line";
+    to: string | [number, number] | import('..').PolarPosition;
+}>;
+export declare const StepSchema: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+    type: z.ZodLiteral<"step">;
+    kind: z.ZodLiteral<"move">;
+    to: z.ZodUnion<[z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, z.ZodType<import('..').PolarPosition, z.ZodTypeDef, import('..').PolarPosition>, z.ZodString]>;
+}, "strip", z.ZodTypeAny, {
+    type: "step";
+    kind: "move";
+    to: string | [number, number] | import('..').PolarPosition;
+}, {
+    type: "step";
+    kind: "move";
+    to: string | [number, number] | import('..').PolarPosition;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"step">;
+    kind: z.ZodLiteral<"line">;
+    to: z.ZodUnion<[z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, z.ZodType<import('..').PolarPosition, z.ZodTypeDef, import('..').PolarPosition>, z.ZodString]>;
+}, "strip", z.ZodTypeAny, {
+    type: "step";
+    kind: "line";
+    to: string | [number, number] | import('..').PolarPosition;
+}, {
+    type: "step";
+    kind: "line";
+    to: string | [number, number] | import('..').PolarPosition;
+}>]>;
+/** Move step：移动游标但不绘制 */
+export type IRMoveStep = z.infer<typeof MoveStepSchema>;
+/** Line step：从游标到目标画直线 */
+export type IRLineStep = z.infer<typeof LineStepSchema>;
+/**
+ * 路径上的一个动作。v0.1.0-alpha 仅支持 'move' 与 'line'。
+ * 后续会加 'step'（折角）、'curve'、'cubic'、'rel'、'close' 等。
+ */
+export type IRStep = z.infer<typeof StepSchema>;
+//# sourceMappingURL=step.d.ts.map

package/dist/lib/ir/path/step.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"step.d.ts","sourceRoot":"","sources":["../../../../src/ir/path/step.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,cAAc;;;;;;;;;;;;EAQyC,CAAC;AAErE,eAAO,MAAM,cAAc;;;;;;;;;;;;EAQ4C,CAAC;AAExE,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;IAE+C,CAAC;AAEvE,yBAAyB;AACzB,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAExD,0BAA0B;AAC1B,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAExD;;;GAGG;AACH,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC"}

package/dist/lib/ir/path/target.cjs

@@ -0,0 +1,11 @@
+const require_position = require("../position/position.cjs");
+const require_polar_position = require("../position/polar-position.cjs");
+let zod = require("zod");
+//#region src/ir/path/target.ts
+var TargetSchema = zod.z.union([
+	require_position.PositionSchema,
+	require_polar_position.PolarPositionSchema,
+	zod.z.string().min(1)
+]).describe("Path endpoint: Cartesian [x, y], polar position (resolved at compile time), or node id reference");
+//#endregion
+exports.TargetSchema = TargetSchema;

package/dist/lib/ir/path/target.d.ts

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+export declare const TargetSchema: z.ZodUnion<[z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, z.ZodType<import('..').PolarPosition, z.ZodTypeDef, import('..').PolarPosition>, z.ZodString]>;
+/** 路径端点：直接坐标 [x, y]、极坐标，或节点 id 字符串 */
+export type IRTarget = z.infer<typeof TargetSchema>;
+//# sourceMappingURL=target.d.ts.map

package/dist/lib/ir/path/target.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"target.d.ts","sourceRoot":"","sources":["../../../../src/ir/path/target.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,YAAY,0JAItB,CAAC;AAEJ,sCAAsC;AACtC,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC"}

package/dist/lib/ir/position/index.d.ts

@@ -0,0 +1,3 @@
+export * from './position';
+export * from './polar-position';
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/ir/position/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/ir/position/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,kBAAkB,CAAC"}

package/dist/lib/ir/position/polar-position.cjs

@@ -0,0 +1,18 @@
+const require_position = require("./position.cjs");
+let zod = require("zod");
+//#region src/ir/position/polar-position.ts
+/**
+* 极坐标点 schema（递归——origin 可嵌套）。
+* 用 z.lazy 处理自引用；TS 类型从 geometry/polar 导入并 cast 到 schema。
+*/
+var PolarPositionSchema = zod.z.lazy(() => zod.z.object({
+	origin: zod.z.union([
+		zod.z.string().min(1),
+		require_position.PositionSchema,
+		PolarPositionSchema
+	]).optional().describe("Origin reference: node id string, Cartesian [x, y], or nested PolarPosition (chained); defaults to [0, 0] when omitted"),
+	angle: zod.z.number().describe("Angle in degrees, counter-clockwise positive (TikZ convention)"),
+	radius: zod.z.number().describe("Radius / distance in user units")
+}).describe("Polar coordinate position; resolved to Cartesian at Scene compile time"));
+//#endregion
+exports.PolarPositionSchema = PolarPositionSchema;

package/dist/lib/ir/position/polar-position.d.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+import { PolarPosition } from '../../geometry/polar';
+/**
+ * 极坐标点 schema（递归——origin 可嵌套）。
+ * 用 z.lazy 处理自引用；TS 类型从 geometry/polar 导入并 cast 到 schema。
+ */
+export declare const PolarPositionSchema: z.ZodType<PolarPosition>;
+export type { PolarPosition } from '../../geometry/polar';
+//# sourceMappingURL=polar-position.d.ts.map

package/dist/lib/ir/position/polar-position.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"polar-position.d.ts","sourceRoot":"","sources":["../../../../src/ir/position/polar-position.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAG1D;;;GAGG;AACH,eAAO,MAAM,mBAAmB,EAAE,CAAC,CAAC,OAAO,CAAC,aAAa,CAmBxD,CAAC;AAGF,YAAY,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC"}

package/dist/lib/ir/position/position.cjs

@@ -0,0 +1,5 @@
+let zod = require("zod");
+//#region src/ir/position/position.ts
+var PositionSchema = zod.z.tuple([zod.z.number(), zod.z.number()]).describe("Cartesian position [x, y]");
+//#endregion
+exports.PositionSchema = PositionSchema;

package/dist/lib/ir/position/position.d.ts

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+export declare const PositionSchema: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+/** 笛卡尔坐标 [x, y] */
+export type IRPosition = z.infer<typeof PositionSchema>;
+//# sourceMappingURL=position.d.ts.map

package/dist/lib/ir/position/position.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"position.d.ts","sourceRoot":"","sources":["../../../../src/ir/position/position.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,cAAc,8CAEa,CAAC;AAEzC,mBAAmB;AACnB,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC"}

package/dist/lib/ir/scene.cjs

@@ -0,0 +1,16 @@
+const require_path = require("./path/path.cjs");
+const require_node = require("./node.cjs");
+let zod = require("zod");
+//#region src/ir/scene.ts
+var ChildSchema = zod.z.discriminatedUnion("type", [require_node.NodeSchema, require_path.PathSchema]).describe("Top-level scene child: either a node or a path; discriminator field is `type`");
+var SceneSchema = zod.z.object({
+	version: zod.z.literal(1).describe("IR major version number; bump only on breaking schema changes"),
+	type: zod.z.literal("scene").describe("Discriminator marking this object as the root scene"),
+	children: zod.z.array(ChildSchema).describe("Top-level children of the scene; nodes register ids that paths can reference")
+}).describe("Top-level retikz IR scene — the canonical, JSON-serializable representation of a drawing");
+/** IR 当前主版本号；只在 schema 出现破坏性变更时递增 */
+var CURRENT_IR_VERSION = 1;
+//#endregion
+exports.CURRENT_IR_VERSION = CURRENT_IR_VERSION;
+exports.ChildSchema = ChildSchema;
+exports.SceneSchema = SceneSchema;