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

package/dist/es/ir/path/arrow.d.ts

@@ -0,0 +1,26 @@
+import { ValueOf } from '../../types';
+/**
+ * 箭头形状常量。值就是 IR / Scene 中 arrow 字段的字面字符串；
+ * 用 const 而不是 TS enum——避免 enum 在数值场景生成 reverse-mapping、
+ * 在 string 场景与字面量类型不互通的两个坑。
+ *
+ * - `normal`：实心三角（默认；最常见）
+ * - `open`：空心三角（UML 泛化 / 继承）
+ * - `stealth`：尖锐倒钩三角（流图常见、视觉锐利）
+ * - `diamond`：实心菱形（UML 组合）
+ * - `openDiamond`：空心菱形（UML 聚合）
+ * - `circle`：实心圆点（连接点 / dot end）
+ * - `openCircle`：空心圆点（白圈 / o-end）
+ */
+export declare const ARROW_SHAPES: {
+    readonly normal: "normal";
+    readonly open: "open";
+    readonly stealth: "stealth";
+    readonly diamond: "diamond";
+    readonly openDiamond: "openDiamond";
+    readonly circle: "circle";
+    readonly openCircle: "openCircle";
+};
+/** 箭头形状字面量类型，由 `ARROW_SHAPES` 派生 */
+export type ArrowShape = ValueOf<typeof ARROW_SHAPES>;
+//# sourceMappingURL=arrow.d.ts.map

package/dist/es/ir/path/arrow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arrow.d.ts","sourceRoot":"","sources":["../../../../src/ir/path/arrow.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAE3C;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,YAAY;;;;;;;;CAQf,CAAC;AAEX,oCAAoC;AACpC,MAAM,MAAM,UAAU,GAAG,OAAO,CAAC,OAAO,YAAY,CAAC,CAAC"}

package/dist/es/ir/path/arrow.js

@@ -0,0 +1,25 @@
+//#region src/ir/path/arrow.ts
+/**
+* 箭头形状常量。值就是 IR / Scene 中 arrow 字段的字面字符串；
+* 用 const 而不是 TS enum——避免 enum 在数值场景生成 reverse-mapping、
+* 在 string 场景与字面量类型不互通的两个坑。
+*
+* - `normal`：实心三角（默认；最常见）
+* - `open`：空心三角（UML 泛化 / 继承）
+* - `stealth`：尖锐倒钩三角（流图常见、视觉锐利）
+* - `diamond`：实心菱形（UML 组合）
+* - `openDiamond`：空心菱形（UML 聚合）
+* - `circle`：实心圆点（连接点 / dot end）
+* - `openCircle`：空心圆点（白圈 / o-end）
+*/
+var ARROW_SHAPES = {
+	normal: "normal",
+	open: "open",
+	stealth: "stealth",
+	diamond: "diamond",
+	openDiamond: "openDiamond",
+	circle: "circle",
+	openCircle: "openCircle"
+};
+//#endregion
+export { ARROW_SHAPES };

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

@@ -1,3 +1,4 @@
+export * from './arrow';
 export * from './path';
 export * from './step';
 export * from './target';

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

@@ -1 +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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/ir/path/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,QAAQ,CAAC;AACvB,cAAc,QAAQ,CAAC;AACvB,cAAc,UAAU,CAAC"}

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

@@ -4,6 +4,18 @@ export declare const PathSchema: z.ZodObject<{
     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">;
@@ -28,6 +40,30 @@ export declare const PathSchema: z.ZodObject<{
         type: "step";
         kind: "line";
         to: string | [number, number] | import('..').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('..').PolarPosition, z.ZodTypeDef, import('..').PolarPosition>, z.ZodString]>;
+    }, "strip", z.ZodTypeAny, {
+        type: "step";
+        kind: "step";
+        to: string | [number, number] | import('..').PolarPosition;
+        via: "-|" | "|-";
+    }, {
+        type: "step";
+        kind: "step";
+        to: string | [number, number] | import('..').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";
@@ -39,10 +75,22 @@ export declare const PathSchema: z.ZodObject<{
         type: "step";
         kind: "line";
         to: string | [number, number] | import('..').PolarPosition;
+    } | {
+        type: "step";
+        kind: "step";
+        to: string | [number, number] | import('..').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: ({
@@ -53,10 +101,22 @@ export declare const PathSchema: z.ZodObject<{
         type: "step";
         kind: "line";
         to: string | [number, number] | import('..').PolarPosition;
+    } | {
+        type: "step";
+        kind: "step";
+        to: string | [number, number] | import('..').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;
 }>;
 /** 路径：由若干 step 动作（move / line / ...）组成的绘制路径 */
 export type IRPath = z.infer<typeof PathSchema>;

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

@@ -1 +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"}
+{"version":3,"file":"path.d.ts","sourceRoot":"","sources":["../../../../src/ir/path/path.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsDpB,CAAC;AAEJ,+CAA+C;AAC/C,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC"}

package/dist/es/ir/path/path.js

@@ -1,3 +1,4 @@
+import { ARROW_SHAPES } from "./arrow.js";
 import { StepSchema } from "./step.js";
 import { z } from "zod";
 //#region src/ir/path/path.ts
@@ -6,6 +7,15 @@ var PathSchema = z.object({
 	stroke: z.string().optional().describe("Stroke color of the path; any CSS color. Defaults to currentColor when omitted"),
 	strokeWidth: z.number().optional().describe("Stroke width in user units; defaults to 1 when omitted"),
 	strokeDasharray: z.string().optional().describe("SVG stroke-dasharray pattern (e.g. \"4 2\"); leave empty for solid line"),
+	arrow: z.enum([
+		"none",
+		"->",
+		"<-",
+		"<->"
+	]).optional().describe("Path-level arrow direction. omitted/`none` = no arrows; `->` = arrow at end; `<-` = at start; `<->` = both."),
+	arrowShape: z.nativeEnum(ARROW_SHAPES).optional().describe("Arrow tip shape; default `normal` (filled triangle). Other values: `open` (hollow triangle), `stealth` (sharp barb), `diamond`, `circle`."),
+	fill: z.string().optional().describe("Fill color of the closed region; any CSS color. Omitted = no fill (stroke only). Pairs with `cycle` step for filled shapes."),
+	fillRule: z.enum(["nonzero", "evenodd"]).optional().describe("How self-intersecting / nested sub-paths are filled. `nonzero` (default, SVG default) winds-by-direction; `evenodd` toggles fill on each crossing — useful for ring / donut shapes."),
 	children: z.array(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

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

@@ -25,6 +25,32 @@ export declare const LineStepSchema: z.ZodObject<{
     kind: "line";
     to: string | [number, number] | import('..').PolarPosition;
 }>;
+export declare const FoldStepSchema: 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('..').PolarPosition, z.ZodTypeDef, import('..').PolarPosition>, z.ZodString]>;
+}, "strip", z.ZodTypeAny, {
+    type: "step";
+    kind: "step";
+    to: string | [number, number] | import('..').PolarPosition;
+    via: "-|" | "|-";
+}, {
+    type: "step";
+    kind: "step";
+    to: string | [number, number] | import('..').PolarPosition;
+    via: "-|" | "|-";
+}>;
+export declare const CycleStepSchema: z.ZodObject<{
+    type: z.ZodLiteral<"step">;
+    kind: z.ZodLiteral<"cycle">;
+}, "strip", z.ZodTypeAny, {
+    type: "step";
+    kind: "cycle";
+}, {
+    type: "step";
+    kind: "cycle";
+}>;
 export declare const StepSchema: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
     type: z.ZodLiteral<"step">;
     kind: z.ZodLiteral<"move">;
@@ -49,14 +75,42 @@ export declare const StepSchema: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
     type: "step";
     kind: "line";
     to: string | [number, number] | import('..').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('..').PolarPosition, z.ZodTypeDef, import('..').PolarPosition>, z.ZodString]>;
+}, "strip", z.ZodTypeAny, {
+    type: "step";
+    kind: "step";
+    to: string | [number, number] | import('..').PolarPosition;
+    via: "-|" | "|-";
+}, {
+    type: "step";
+    kind: "step";
+    to: string | [number, number] | import('..').PolarPosition;
+    via: "-|" | "|-";
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"step">;
+    kind: z.ZodLiteral<"cycle">;
+}, "strip", z.ZodTypeAny, {
+    type: "step";
+    kind: "cycle";
+}, {
+    type: "step";
+    kind: "cycle";
 }>]>;
 /** Move step：移动游标但不绘制 */
 export type IRMoveStep = z.infer<typeof MoveStepSchema>;
 /** Line step：从游标到目标画直线 */
 export type IRLineStep = z.infer<typeof LineStepSchema>;
+/** Fold step：折角段，从游标到目标经一个直角中间点（TikZ `-|` / `|-`） */
+export type IRFoldStep = z.infer<typeof FoldStepSchema>;
+/** Cycle step：把当前子路径闭合回起点（TikZ `cycle` / SVG `Z`） */
+export type IRCycleStep = z.infer<typeof CycleStepSchema>;
 /**
- * 路径上的一个动作。v0.1.0-alpha 仅支持 'move' 与 'line'。
- * 后续会加 'step'（折角）、'curve'、'cubic'、'rel'、'close' 等。
+ * 路径上的一个动作。v0.1.0-alpha.1 支持 'move' / 'line' / 'step'（折角）/ 'cycle'（闭合）。
+ * 后续会加 'curve'、'cubic'、'rel' 等。
  */
 export type IRStep = z.infer<typeof StepSchema>;
 //# sourceMappingURL=step.d.ts.map

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

@@ -1 +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"}
+{"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,cAAc;;;;;;;;;;;;;;;EAiBxB,CAAC;AAEJ,eAAO,MAAM,eAAe;;;;;;;;;EAWzB,CAAC;AAEJ,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,qDAAqD;AACrD,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAExD,qDAAqD;AACrD,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAE1D;;;GAGG;AACH,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC"}

package/dist/es/ir/path/step.js

@@ -11,6 +11,21 @@ var LineStepSchema = z.object({
 	kind: z.literal("line").describe("Draw a straight line from the current cursor to the target (like SVG path \"L\")"),
 	to: TargetSchema.describe("Destination point of the line segment")
 }).describe("Line action: straight-line segment from cursor to target");
-var StepSchema = z.discriminatedUnion("kind", [MoveStepSchema, LineStepSchema]).describe("A single path action; the discriminator field is `kind`");
+var FoldStepSchema = z.object({
+	type: z.literal("step").describe("Discriminator marking this as a path step node"),
+	kind: z.literal("step").describe("Folded right-angle segment from cursor to target through one intermediate point (TikZ `-|` / `|-`)"),
+	via: z.enum(["-|", "|-"]).describe("Folding direction: `-|` first horizontal then vertical; `|-` first vertical then horizontal"),
+	to: TargetSchema.describe("Destination point of the folded segment")
+}).describe("Fold action: TikZ-style right-angle fold with a single intermediate point chosen by `via`");
+var CycleStepSchema = z.object({
+	type: z.literal("step").describe("Discriminator marking this as a path step node"),
+	kind: z.literal("cycle").describe("Close the path back to the most recent move target (TikZ `cycle` / SVG path \"Z\")")
+}).describe("Cycle action: close the current sub-path back to its starting point; carries no `to` field");
+var StepSchema = z.discriminatedUnion("kind", [
+	MoveStepSchema,
+	LineStepSchema,
+	FoldStepSchema,
+	CycleStepSchema
+]).describe("A single path action; the discriminator field is `kind`");
 //#endregion
-export { LineStepSchema, MoveStepSchema, StepSchema };
+export { CycleStepSchema, FoldStepSchema, LineStepSchema, MoveStepSchema, StepSchema };