@retikz/core 0.0.1-rc.3 → 0.1.0-alpha.1

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;

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

@@ -0,0 +1,424 @@
+import { z } from 'zod';
+export declare const ChildSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    type: z.ZodLiteral<"node">;
+    id: z.ZodOptional<z.ZodString>;
+    shape: z.ZodOptional<z.ZodNativeEnum<{
+        readonly rectangle: "rectangle";
+        readonly circle: "circle";
+        readonly ellipse: "ellipse";
+        readonly diamond: "diamond";
+    }>>;
+    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;
+    shape?: "diamond" | "circle" | "rectangle" | "ellipse" | 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;
+    shape?: "diamond" | "circle" | "rectangle" | "ellipse" | 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;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"path">;
+    stroke: z.ZodOptional<z.ZodString>;
+    strokeWidth: z.ZodOptional<z.ZodNumber>;
+    strokeDasharray: z.ZodOptional<z.ZodString>;
+    arrow: z.ZodOptional<z.ZodEnum<["none", "->", "<-", "<->"]>>;
+    arrowShape: z.ZodOptional<z.ZodNativeEnum<{
+        readonly normal: "normal";
+        readonly open: "open";
+        readonly stealth: "stealth";
+        readonly diamond: "diamond";
+        readonly openDiamond: "openDiamond";
+        readonly circle: "circle";
+        readonly openCircle: "openCircle";
+    }>>;
+    fill: z.ZodOptional<z.ZodString>;
+    fillRule: z.ZodOptional<z.ZodEnum<["nonzero", "evenodd"]>>;
+    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('./position').PolarPosition, z.ZodTypeDef, import('./position').PolarPosition>, z.ZodString]>;
+    }, "strip", z.ZodTypeAny, {
+        type: "step";
+        kind: "move";
+        to: string | [number, number] | import('./position').PolarPosition;
+    }, {
+        type: "step";
+        kind: "move";
+        to: string | [number, number] | import('./position').PolarPosition;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"step">;
+        kind: z.ZodLiteral<"line">;
+        to: z.ZodUnion<[z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, z.ZodType<import('./position').PolarPosition, z.ZodTypeDef, import('./position').PolarPosition>, z.ZodString]>;
+    }, "strip", z.ZodTypeAny, {
+        type: "step";
+        kind: "line";
+        to: string | [number, number] | import('./position').PolarPosition;
+    }, {
+        type: "step";
+        kind: "line";
+        to: string | [number, number] | import('./position').PolarPosition;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"step">;
+        kind: z.ZodLiteral<"step">;
+        via: z.ZodEnum<["-|", "|-"]>;
+        to: z.ZodUnion<[z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, z.ZodType<import('./position').PolarPosition, z.ZodTypeDef, import('./position').PolarPosition>, z.ZodString]>;
+    }, "strip", z.ZodTypeAny, {
+        type: "step";
+        kind: "step";
+        to: string | [number, number] | import('./position').PolarPosition;
+        via: "-|" | "|-";
+    }, {
+        type: "step";
+        kind: "step";
+        to: string | [number, number] | import('./position').PolarPosition;
+        via: "-|" | "|-";
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"step">;
+        kind: z.ZodLiteral<"cycle">;
+    }, "strip", z.ZodTypeAny, {
+        type: "step";
+        kind: "cycle";
+    }, {
+        type: "step";
+        kind: "cycle";
+    }>]>, "many">;
+}, "strip", z.ZodTypeAny, {
+    type: "path";
+    children: ({
+        type: "step";
+        kind: "move";
+        to: string | [number, number] | import('./position').PolarPosition;
+    } | {
+        type: "step";
+        kind: "line";
+        to: string | [number, number] | import('./position').PolarPosition;
+    } | {
+        type: "step";
+        kind: "step";
+        to: string | [number, number] | import('./position').PolarPosition;
+        via: "-|" | "|-";
+    } | {
+        type: "step";
+        kind: "cycle";
+    })[];
+    fill?: string | undefined;
+    stroke?: string | undefined;
+    strokeWidth?: number | undefined;
+    strokeDasharray?: string | undefined;
+    arrow?: "none" | "->" | "<-" | "<->" | undefined;
+    arrowShape?: "normal" | "open" | "stealth" | "diamond" | "openDiamond" | "circle" | "openCircle" | undefined;
+    fillRule?: "nonzero" | "evenodd" | undefined;
+}, {
+    type: "path";
+    children: ({
+        type: "step";
+        kind: "move";
+        to: string | [number, number] | import('./position').PolarPosition;
+    } | {
+        type: "step";
+        kind: "line";
+        to: string | [number, number] | import('./position').PolarPosition;
+    } | {
+        type: "step";
+        kind: "step";
+        to: string | [number, number] | import('./position').PolarPosition;
+        via: "-|" | "|-";
+    } | {
+        type: "step";
+        kind: "cycle";
+    })[];
+    fill?: string | undefined;
+    stroke?: string | undefined;
+    strokeWidth?: number | undefined;
+    strokeDasharray?: string | undefined;
+    arrow?: "none" | "->" | "<-" | "<->" | undefined;
+    arrowShape?: "normal" | "open" | "stealth" | "diamond" | "openDiamond" | "circle" | "openCircle" | undefined;
+    fillRule?: "nonzero" | "evenodd" | undefined;
+}>]>;
+/** 顶层 Scene 的子节点：node 或 path */
+export type IRChild = z.infer<typeof ChildSchema>;
+export declare const SceneSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    type: z.ZodLiteral<"scene">;
+    children: z.ZodArray<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+        type: z.ZodLiteral<"node">;
+        id: z.ZodOptional<z.ZodString>;
+        shape: z.ZodOptional<z.ZodNativeEnum<{
+            readonly rectangle: "rectangle";
+            readonly circle: "circle";
+            readonly ellipse: "ellipse";
+            readonly diamond: "diamond";
+        }>>;
+        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;
+        shape?: "diamond" | "circle" | "rectangle" | "ellipse" | 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;
+        shape?: "diamond" | "circle" | "rectangle" | "ellipse" | 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;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"path">;
+        stroke: z.ZodOptional<z.ZodString>;
+        strokeWidth: z.ZodOptional<z.ZodNumber>;
+        strokeDasharray: z.ZodOptional<z.ZodString>;
+        arrow: z.ZodOptional<z.ZodEnum<["none", "->", "<-", "<->"]>>;
+        arrowShape: z.ZodOptional<z.ZodNativeEnum<{
+            readonly normal: "normal";
+            readonly open: "open";
+            readonly stealth: "stealth";
+            readonly diamond: "diamond";
+            readonly openDiamond: "openDiamond";
+            readonly circle: "circle";
+            readonly openCircle: "openCircle";
+        }>>;
+        fill: z.ZodOptional<z.ZodString>;
+        fillRule: z.ZodOptional<z.ZodEnum<["nonzero", "evenodd"]>>;
+        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('./position').PolarPosition, z.ZodTypeDef, import('./position').PolarPosition>, z.ZodString]>;
+        }, "strip", z.ZodTypeAny, {
+            type: "step";
+            kind: "move";
+            to: string | [number, number] | import('./position').PolarPosition;
+        }, {
+            type: "step";
+            kind: "move";
+            to: string | [number, number] | import('./position').PolarPosition;
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"step">;
+            kind: z.ZodLiteral<"line">;
+            to: z.ZodUnion<[z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, z.ZodType<import('./position').PolarPosition, z.ZodTypeDef, import('./position').PolarPosition>, z.ZodString]>;
+        }, "strip", z.ZodTypeAny, {
+            type: "step";
+            kind: "line";
+            to: string | [number, number] | import('./position').PolarPosition;
+        }, {
+            type: "step";
+            kind: "line";
+            to: string | [number, number] | import('./position').PolarPosition;
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"step">;
+            kind: z.ZodLiteral<"step">;
+            via: z.ZodEnum<["-|", "|-"]>;
+            to: z.ZodUnion<[z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, z.ZodType<import('./position').PolarPosition, z.ZodTypeDef, import('./position').PolarPosition>, z.ZodString]>;
+        }, "strip", z.ZodTypeAny, {
+            type: "step";
+            kind: "step";
+            to: string | [number, number] | import('./position').PolarPosition;
+            via: "-|" | "|-";
+        }, {
+            type: "step";
+            kind: "step";
+            to: string | [number, number] | import('./position').PolarPosition;
+            via: "-|" | "|-";
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"step">;
+            kind: z.ZodLiteral<"cycle">;
+        }, "strip", z.ZodTypeAny, {
+            type: "step";
+            kind: "cycle";
+        }, {
+            type: "step";
+            kind: "cycle";
+        }>]>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        type: "path";
+        children: ({
+            type: "step";
+            kind: "move";
+            to: string | [number, number] | import('./position').PolarPosition;
+        } | {
+            type: "step";
+            kind: "line";
+            to: string | [number, number] | import('./position').PolarPosition;
+        } | {
+            type: "step";
+            kind: "step";
+            to: string | [number, number] | import('./position').PolarPosition;
+            via: "-|" | "|-";
+        } | {
+            type: "step";
+            kind: "cycle";
+        })[];
+        fill?: string | undefined;
+        stroke?: string | undefined;
+        strokeWidth?: number | undefined;
+        strokeDasharray?: string | undefined;
+        arrow?: "none" | "->" | "<-" | "<->" | undefined;
+        arrowShape?: "normal" | "open" | "stealth" | "diamond" | "openDiamond" | "circle" | "openCircle" | undefined;
+        fillRule?: "nonzero" | "evenodd" | undefined;
+    }, {
+        type: "path";
+        children: ({
+            type: "step";
+            kind: "move";
+            to: string | [number, number] | import('./position').PolarPosition;
+        } | {
+            type: "step";
+            kind: "line";
+            to: string | [number, number] | import('./position').PolarPosition;
+        } | {
+            type: "step";
+            kind: "step";
+            to: string | [number, number] | import('./position').PolarPosition;
+            via: "-|" | "|-";
+        } | {
+            type: "step";
+            kind: "cycle";
+        })[];
+        fill?: string | undefined;
+        stroke?: string | undefined;
+        strokeWidth?: number | undefined;
+        strokeDasharray?: string | undefined;
+        arrow?: "none" | "->" | "<-" | "<->" | undefined;
+        arrowShape?: "normal" | "open" | "stealth" | "diamond" | "openDiamond" | "circle" | "openCircle" | undefined;
+        fillRule?: "nonzero" | "evenodd" | undefined;
+    }>]>, "many">;
+}, "strip", z.ZodTypeAny, {
+    type: "scene";
+    children: ({
+        type: "path";
+        children: ({
+            type: "step";
+            kind: "move";
+            to: string | [number, number] | import('./position').PolarPosition;
+        } | {
+            type: "step";
+            kind: "line";
+            to: string | [number, number] | import('./position').PolarPosition;
+        } | {
+            type: "step";
+            kind: "step";
+            to: string | [number, number] | import('./position').PolarPosition;
+            via: "-|" | "|-";
+        } | {
+            type: "step";
+            kind: "cycle";
+        })[];
+        fill?: string | undefined;
+        stroke?: string | undefined;
+        strokeWidth?: number | undefined;
+        strokeDasharray?: string | undefined;
+        arrow?: "none" | "->" | "<-" | "<->" | undefined;
+        arrowShape?: "normal" | "open" | "stealth" | "diamond" | "openDiamond" | "circle" | "openCircle" | undefined;
+        fillRule?: "nonzero" | "evenodd" | undefined;
+    } | {
+        type: "node";
+        position: [number, number] | import('./position').PolarPosition;
+        fill?: string | undefined;
+        shape?: "diamond" | "circle" | "rectangle" | "ellipse" | 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;
+    })[];
+    version: 1;
+}, {
+    type: "scene";
+    children: ({
+        type: "path";
+        children: ({
+            type: "step";
+            kind: "move";
+            to: string | [number, number] | import('./position').PolarPosition;
+        } | {
+            type: "step";
+            kind: "line";
+            to: string | [number, number] | import('./position').PolarPosition;
+        } | {
+            type: "step";
+            kind: "step";
+            to: string | [number, number] | import('./position').PolarPosition;
+            via: "-|" | "|-";
+        } | {
+            type: "step";
+            kind: "cycle";
+        })[];
+        fill?: string | undefined;
+        stroke?: string | undefined;
+        strokeWidth?: number | undefined;
+        strokeDasharray?: string | undefined;
+        arrow?: "none" | "->" | "<-" | "<->" | undefined;
+        arrowShape?: "normal" | "open" | "stealth" | "diamond" | "openDiamond" | "circle" | "openCircle" | undefined;
+        fillRule?: "nonzero" | "evenodd" | undefined;
+    } | {
+        type: "node";
+        position: [number, number] | import('./position').PolarPosition;
+        fill?: string | undefined;
+        shape?: "diamond" | "circle" | "rectangle" | "ellipse" | 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;
+    })[];
+    version: 1;
+}>;
+/** retikz IR 顶层 Scene——可序列化 JSON 形式的绘制描述 */
+export type IR = z.infer<typeof SceneSchema>;
+/** IR 当前主版本号；只在 schema 出现破坏性变更时递增 */
+export declare const CURRENT_IR_VERSION: 1;
+//# sourceMappingURL=scene.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"scene.d.ts","sourceRoot":"","sources":["../../../src/ir/scene.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAIrB,CAAC;AAEJ,gCAAgC;AAChC,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAElD,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkBrB,CAAC;AAEJ,4CAA4C;AAC5C,MAAM,MAAM,EAAE,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAE7C,qCAAqC;AACrC,eAAO,MAAM,kBAAkB,EAAG,CAAU,CAAC"}

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

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

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

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

package/dist/lib/parsers/parseWay.cjs

@@ -0,0 +1,93 @@
+//#region src/parsers/parseWay.ts
+/**
+* Sugar 层 way 数组的"关键字常量"。
+*
+* - `DrawWay.cycle`：闭合到 way 起点（way 元素位置）。**底层字符串故意取得很丑**
+*   （`'retikz-keyword_cycle'`），保证不会与任何合理的节点 id 冲突；用户应当
+*   只通过 `DrawWay.cycle` 引用，不要直接写裸字面量。
+* - `DrawWay.hv`：折角算子，先水平后垂直（裸字面量 `'-|'`）。
+* - `DrawWay.vh`：折角算子，先垂直后水平（裸字面量 `'|-'`）。
+*
+* 折角值（`-|` / `|-`）含特殊字符，与节点 id 不会冲突，因此**保留字面量与
+* 常量两种写法都合法**。way 数组里直接放 `'-|'` 或 `'|-'`（infix 算子）
+* 即把"上一项 → 下一项"那一段改成折角。
+*
+* 这里**故意不用 TS enum**——enum 在数值场景下生成 reverse-mapping 表、
+* 在 string 场景下与字面量类型不互通，而 const + `as const` 的字面量联合
+* 既可枚举也可与字面量字符串无缝混用。
+*/
+var DrawWay = {
+	/**
+	* 闭合 way 到起点，等价于 `<Step kind="cycle" />`（TikZ 同名保留字 / SVG `Z`）。
+	* 底层字符串值刻意写丑以避开节点 id 冲突；不要硬编码这个字符串。
+	*/
+	cycle: "retikz-keyword_cycle",
+	/** 折角：先水平后垂直（TikZ `-|`） */
+	hv: "-|",
+	/** 折角：先垂直后水平（TikZ `|-`） */
+	vh: "|-"
+};
+var isWayCycle = (item) => item === DrawWay.cycle;
+var isWayVia = (item) => item === DrawWay.hv || item === DrawWay.vh;
+/** 把 WayItem 归约为它的"目标点"——target 直接返回；算子/关键字返回 null */
+var targetOf = (item) => {
+	if (isWayCycle(item) || isWayVia(item)) return null;
+	return item;
+};
+/**
+* 把 way 数组翻译为 IRStep 序列。
+*
+* - 第一个元素始终是 move：取 way[0] 的目标点；若 way[0] 是 cycle / via 算子等
+*   非 target 项，则降级到原点 `[0, 0]`（容错）。
+* - 后续元素：
+*   - 普通 target → line
+*   - `DrawWay.cycle` → cycle 步
+*   - `'-|'` / `'|-'` → 与**下一项**合并成 fold 步；操作符在 way 末尾或后
+*     接非 target 项时抛错
+*
+* 这是纯函数，住在 core，被各框架 adapter 的 Sugar 组件复用。
+*/
+var parseWay = (way) => {
+	if (way.length < 2) throw new Error("parseWay: way must contain at least 2 items");
+	const out = [];
+	const moveStep = {
+		type: "step",
+		kind: "move",
+		to: targetOf(way[0]) ?? [0, 0]
+	};
+	out.push(moveStep);
+	for (let i = 1; i < way.length; i++) {
+		const item = way[i];
+		if (isWayCycle(item)) {
+			out.push({
+				type: "step",
+				kind: "cycle"
+			});
+			continue;
+		}
+		if (isWayVia(item)) {
+			if (i + 1 >= way.length) throw new Error(`parseWay: via operator '${item}' at end of way must be followed by a target`);
+			const next = way[i + 1];
+			if (isWayCycle(next) || isWayVia(next)) throw new Error(`parseWay: via operator '${item}' must be followed by a target, got '${String(next)}'`);
+			const fold = {
+				type: "step",
+				kind: "step",
+				via: item,
+				to: next
+			};
+			out.push(fold);
+			i++;
+			continue;
+		}
+		const lineStep = {
+			type: "step",
+			kind: "line",
+			to: item
+		};
+		out.push(lineStep);
+	}
+	return out;
+};
+//#endregion
+exports.DrawWay = DrawWay;
+exports.parseWay = parseWay;

package/dist/lib/parsers/parseWay.d.ts

@@ -0,0 +1,71 @@
+import { IRStep, IRTarget } from '../ir';
+/**
+ * Sugar 层 way 数组的"关键字常量"。
+ *
+ * - `DrawWay.cycle`：闭合到 way 起点（way 元素位置）。**底层字符串故意取得很丑**
+ *   （`'retikz-keyword_cycle'`），保证不会与任何合理的节点 id 冲突；用户应当
+ *   只通过 `DrawWay.cycle` 引用，不要直接写裸字面量。
+ * - `DrawWay.hv`：折角算子，先水平后垂直（裸字面量 `'-|'`）。
+ * - `DrawWay.vh`：折角算子，先垂直后水平（裸字面量 `'|-'`）。
+ *
+ * 折角值（`-|` / `|-`）含特殊字符，与节点 id 不会冲突，因此**保留字面量与
+ * 常量两种写法都合法**。way 数组里直接放 `'-|'` 或 `'|-'`（infix 算子）
+ * 即把"上一项 → 下一项"那一段改成折角。
+ *
+ * 这里**故意不用 TS enum**——enum 在数值场景下生成 reverse-mapping 表、
+ * 在 string 场景下与字面量类型不互通，而 const + `as const` 的字面量联合
+ * 既可枚举也可与字面量字符串无缝混用。
+ */
+export declare const DrawWay: {
+    /**
+     * 闭合 way 到起点，等价于 `<Step kind="cycle" />`（TikZ 同名保留字 / SVG `Z`）。
+     * 底层字符串值刻意写丑以避开节点 id 冲突；不要硬编码这个字符串。
+     */
+    readonly cycle: "retikz-keyword_cycle";
+    /** 折角：先水平后垂直（TikZ `-|`） */
+    readonly hv: "-|";
+    /** 折角：先垂直后水平（TikZ `|-`） */
+    readonly vh: "|-";
+};
+/**
+ * way 折角算子的字面量类型。`DrawWay.hv` / `DrawWay.vh` 与裸字面量等价。
+ */
+export type WayVia = typeof DrawWay.hv | typeof DrawWay.vh;
+/**
+ * way 闭合关键字的字面量类型，由 `DrawWay.cycle` 派生。
+ */
+export type WayCycle = typeof DrawWay.cycle;
+/**
+ * Sugar 层的 way 数组 DSL 元素。
+ *
+ * v0.1.0-alpha.1 接受五种形态：
+ * - 节点 id 字符串：`'A'` → line（首项时为 move）
+ * - 笛卡尔坐标：`[x, y]` → line
+ * - 极坐标：`{ origin?, angle, radius }` → line
+ * - 折角算子：`'-|'` / `'|-'`（或 `DrawWay.hv` / `DrawWay.vh`）→ 当前项 +
+ *   **下一项**合并成一个折角 step（与 TikZ 的 `(A) -| (B)` infix 写法对齐）
+ * - 闭合关键字：`DrawWay.cycle` → cycle（闭合到起点）
+ *
+ * 后续会加：相对位移（`{ rel: [x, y] }`）、curve / cubic 等。
+ *
+ * 注意：闭合刻意只走 `DrawWay.cycle`（底层字符串是 `'retikz-keyword_cycle'`），
+ * 这样裸字符串 `'cycle'` 仍可作为正常节点 id 使用。
+ */
+export type WayItem = IRTarget | WayVia | WayCycle;
+/** way DSL 数组：sugar `<Draw way={...}>` 接受的输入形态 */
+export type WayDSL = Array<WayItem>;
+/**
+ * 把 way 数组翻译为 IRStep 序列。
+ *
+ * - 第一个元素始终是 move：取 way[0] 的目标点；若 way[0] 是 cycle / via 算子等
+ *   非 target 项，则降级到原点 `[0, 0]`（容错）。
+ * - 后续元素：
+ *   - 普通 target → line
+ *   - `DrawWay.cycle` → cycle 步
+ *   - `'-|'` / `'|-'` → 与**下一项**合并成 fold 步；操作符在 way 末尾或后
+ *     接非 target 项时抛错
+ *
+ * 这是纯函数，住在 core，被各框架 adapter 的 Sugar 组件复用。
+ */
+export declare const parseWay: (way: WayDSL) => Array<IRStep>;
+//# sourceMappingURL=parseWay.d.ts.map