@retikz/core 0.1.0 → 0.2.0-alpha.1

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

@@ -1 +1 @@
-{"version":3,"file":"scene.d.ts","sourceRoot":"","sources":["../../../src/ir/scene.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAIrB,CAAC;AAEJ,6CAA6C;AAC7C,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"}
+{"version":3,"file":"scene.d.ts","sourceRoot":"","sources":["../../../src/ir/scene.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAoB,KAAK,YAAY,EAAE,MAAM,cAAc,CAAC;AACnE,OAAO,EAAE,KAAK,MAAM,EAAc,MAAM,QAAQ,CAAC;AACjD,OAAO,EAAE,KAAK,MAAM,EAAc,MAAM,QAAQ,CAAC;AACjD,OAAO,EAAE,KAAK,OAAO,EAAsC,MAAM,SAAS,CAAC;AAE3E;;;GAGG;AACH,MAAM,MAAM,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,YAAY,GAAG,OAAO,CAAC;AAE/D;;;;GAIG;AACH,eAAO,MAAM,WAAW,EAAE,CAAC,CAAC,OAAO,CAAC,OAAO,CAM1C,CAAC;AAKF,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/es/ir/scene.js

@@ -1,13 +1,21 @@
 import { PathSchema } from "./path/path.js";
 import { NodeSchema } from "./node.js";
 import { CoordinateSchema } from "./coordinate.js";
+import { ScopeSchema, __registerChildSchema } from "./scope.js";
 import { z } from "zod";
 //#region src/ir/scene.ts
-var ChildSchema = z.discriminatedUnion("type", [
+/**
+* ChildSchema：4 类 IR 子节点的 discriminated union
+* @description 用 `z.ZodType<IRChild>` + `z.lazy` 包裹整个 union 让 ScopeSchema.children 能递归引用自己；
+* scope 内嵌 scope 无深度限制（与 polar/offset 嵌套规则一致）
+*/
+var ChildSchema = z.lazy(() => z.discriminatedUnion("type", [
 	NodeSchema,
 	PathSchema,
-	CoordinateSchema
-]).describe("Top-level scene child: a node, a path, or a coordinate placeholder; discriminator field is `type`");
+	CoordinateSchema,
+	ScopeSchema
+]).describe("Top-level scene child: a node, a path, a coordinate placeholder, or a scope container; discriminator field is `type`"));
+__registerChildSchema(ChildSchema);
 var SceneSchema = z.object({
 	version: z.literal(1).describe("IR major version number; bump only on breaking schema changes"),
 	type: z.literal("scene").describe("Discriminator marking this object as the root scene"),

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

@@ -0,0 +1,190 @@
+import { z } from 'zod';
+import { IRCoordinate } from './coordinate';
+import { IRNode } from './node';
+import { IRPath } from './path';
+import { IRTransform } from './transform';
+/**
+ * Scope IR 类型——手写而非 z.infer 派生
+ * @description ChildSchema 通过 z.lazy 延迟回灌，z.infer 推断 children 元素时拿不到精确的 IRNode | IRPath | IRCoordinate | IRScope union；手写让 children 类型显式表达递归 union
+ */
+export type IRScope = {
+    type: 'scope';
+    id?: string;
+    localNamespace?: boolean;
+    transforms?: Array<IRTransform>;
+    children: Array<IRNode | IRPath | IRCoordinate | IRScope>;
+};
+/**
+ * 注册 ChildSchema 引用——由 scene.ts 在定义 ChildSchema 后调用一次
+ * @description 解决 scope.children 用 ChildSchema 与 scene.ChildSchema discriminatedUnion 用 ScopeSchema 的双向依赖
+ */
+export declare const __registerChildSchema: (schema: z.ZodTypeAny) => void;
+/**
+ * Scope schema：4 IRScope 字段
+ * @description 直接 `z.object` 让 ChildSchema discriminatedUnion 能识别 `type` 鉴别字段；
+ * children 字段内部用 z.lazy 引用 ChildSchema 实现递归，避免直接 `z.lazy(() => z.object(...))` 让外层 union 拒识 type
+ */
+export declare const ScopeSchema: z.ZodObject<{
+    type: z.ZodLiteral<"scope">;
+    id: z.ZodOptional<z.ZodString>;
+    localNamespace: z.ZodOptional<z.ZodBoolean>;
+    transforms: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+        kind: z.ZodLiteral<"translate">;
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        kind: "translate";
+        x: number;
+        y: number;
+    }, {
+        kind: "translate";
+        x: number;
+        y: number;
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"polar-translate">;
+        origin: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, z.ZodType<import('./position').PolarPosition, z.ZodTypeDef, import('./position').PolarPosition>]>>;
+        angle: z.ZodNumber;
+        radius: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        angle: number;
+        radius: number;
+        kind: "polar-translate";
+        origin?: string | [number, number] | import('./position').PolarPosition | undefined;
+    }, {
+        angle: number;
+        radius: number;
+        kind: "polar-translate";
+        origin?: string | [number, number] | import('./position').PolarPosition | undefined;
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"at-translate">;
+        direction: z.ZodNativeEnum<{
+            readonly above: "above";
+            readonly below: "below";
+            readonly left: "left";
+            readonly right: "right";
+            readonly 'above-left': "above-left";
+            readonly 'above-right': "above-right";
+            readonly 'below-left': "below-left";
+            readonly 'below-right': "below-right";
+        }>;
+        of: z.ZodString;
+        distance: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        direction: "above" | "below" | "left" | "right" | "above-left" | "above-right" | "below-left" | "below-right";
+        of: string;
+        kind: "at-translate";
+        distance?: number | undefined;
+    }, {
+        direction: "above" | "below" | "left" | "right" | "above-left" | "above-right" | "below-left" | "below-right";
+        of: string;
+        kind: "at-translate";
+        distance?: number | undefined;
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"offset-translate">;
+        of: z.ZodUnion<[z.ZodString, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, z.ZodType<import('./position').PolarPosition, z.ZodTypeDef, import('./position').PolarPosition>]>;
+        offset: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+    }, "strip", z.ZodTypeAny, {
+        of: string | [number, number] | import('./position').PolarPosition;
+        kind: "offset-translate";
+        offset?: [number, number] | undefined;
+    }, {
+        of: string | [number, number] | import('./position').PolarPosition;
+        kind: "offset-translate";
+        offset?: [number, number] | undefined;
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"rotate">;
+        degrees: z.ZodNumber;
+        cx: z.ZodOptional<z.ZodNumber>;
+        cy: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        kind: "rotate";
+        degrees: number;
+        cx?: number | undefined;
+        cy?: number | undefined;
+    }, {
+        kind: "rotate";
+        degrees: number;
+        cx?: number | undefined;
+        cy?: number | undefined;
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"scale">;
+        x: z.ZodNumber;
+        y: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        kind: "scale";
+        x: number;
+        y?: number | undefined;
+    }, {
+        kind: "scale";
+        x: number;
+        y?: number | undefined;
+    }>]>, "many">>;
+    children: z.ZodArray<z.ZodLazy<z.ZodTypeAny>, "many">;
+}, "strip", z.ZodTypeAny, {
+    type: "scope";
+    children: any[];
+    id?: string | undefined;
+    localNamespace?: boolean | undefined;
+    transforms?: ({
+        kind: "translate";
+        x: number;
+        y: number;
+    } | {
+        angle: number;
+        radius: number;
+        kind: "polar-translate";
+        origin?: string | [number, number] | import('./position').PolarPosition | undefined;
+    } | {
+        direction: "above" | "below" | "left" | "right" | "above-left" | "above-right" | "below-left" | "below-right";
+        of: string;
+        kind: "at-translate";
+        distance?: number | undefined;
+    } | {
+        of: string | [number, number] | import('./position').PolarPosition;
+        kind: "offset-translate";
+        offset?: [number, number] | undefined;
+    } | {
+        kind: "rotate";
+        degrees: number;
+        cx?: number | undefined;
+        cy?: number | undefined;
+    } | {
+        kind: "scale";
+        x: number;
+        y?: number | undefined;
+    })[] | undefined;
+}, {
+    type: "scope";
+    children: any[];
+    id?: string | undefined;
+    localNamespace?: boolean | undefined;
+    transforms?: ({
+        kind: "translate";
+        x: number;
+        y: number;
+    } | {
+        angle: number;
+        radius: number;
+        kind: "polar-translate";
+        origin?: string | [number, number] | import('./position').PolarPosition | undefined;
+    } | {
+        direction: "above" | "below" | "left" | "right" | "above-left" | "above-right" | "below-left" | "below-right";
+        of: string;
+        kind: "at-translate";
+        distance?: number | undefined;
+    } | {
+        of: string | [number, number] | import('./position').PolarPosition;
+        kind: "offset-translate";
+        offset?: [number, number] | undefined;
+    } | {
+        kind: "rotate";
+        degrees: number;
+        cx?: number | undefined;
+        cy?: number | undefined;
+    } | {
+        kind: "scale";
+        x: number;
+        y?: number | undefined;
+    })[] | undefined;
+}>;
+//# sourceMappingURL=scope.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"scope.d.ts","sourceRoot":"","sources":["../../../src/ir/scope.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AACjD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AACrC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AACrC,OAAO,EAAE,KAAK,WAAW,EAAmB,MAAM,aAAa,CAAC;AAEhE;;;GAGG;AACH,MAAM,MAAM,OAAO,GAAG;IACpB,IAAI,EAAE,OAAO,CAAC;IACd,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,UAAU,CAAC,EAAE,KAAK,CAAC,WAAW,CAAC,CAAC;IAChC,QAAQ,EAAE,KAAK,CAAC,MAAM,GAAG,MAAM,GAAG,YAAY,GAAG,OAAO,CAAC,CAAC;CAC3D,CAAC;AAOF;;;GAGG;AACH,eAAO,MAAM,qBAAqB,GAAI,QAAQ,CAAC,CAAC,UAAU,KAAG,IAE5D,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyCrB,CAAC"}

package/dist/es/ir/scope.js

@@ -0,0 +1,29 @@
+import { TransformSchema } from "./transform.js";
+import { z } from "zod";
+//#region src/ir/scope.ts
+/** schema 注册顺序：scene.ts import 时由 __registerChildSchema 一次性回灌；之后只读 */
+var childSchemaRef = null;
+/**
+* 注册 ChildSchema 引用——由 scene.ts 在定义 ChildSchema 后调用一次
+* @description 解决 scope.children 用 ChildSchema 与 scene.ChildSchema discriminatedUnion 用 ScopeSchema 的双向依赖
+*/
+var __registerChildSchema = (schema) => {
+	childSchemaRef = schema;
+};
+/**
+* Scope schema：4 IRScope 字段
+* @description 直接 `z.object` 让 ChildSchema discriminatedUnion 能识别 `type` 鉴别字段；
+* children 字段内部用 z.lazy 引用 ChildSchema 实现递归，避免直接 `z.lazy(() => z.object(...))` 让外层 union 拒识 type
+*/
+var ScopeSchema = z.object({
+	type: z.literal("scope").describe("Discriminator marking this child as a scope container."),
+	id: z.string().min(1).optional().describe("Optional reference id; when set, the scope registers a synthetic rectangle bbox node in the **parent** namespace frame so paths / positions can target the scope as a whole. scope.id always registers in the parent frame, regardless of `localNamespace` (it is the external handle)."),
+	localNamespace: z.boolean().optional().describe("When true, the scope creates a local namespace boundary — child node / coordinate / nested-scope ids registered inside do NOT propagate to the parent namespace; external lookups cannot see them. Default false (matches TikZ pgf default: child ids flow up to global). scope.id itself always registers in the parent frame regardless of this flag."),
+	transforms: z.array(TransformSchema).optional().describe("Local transforms applied to all scope children; array order = application order (first element applied innermost, matching Scene `GroupPrim.transforms` / SVG transform list). Supports 6 variants; the 4 translate variants are lowered to Cartesian translate at compile time."),
+	children: z.array(z.lazy(() => {
+		if (!childSchemaRef) throw new Error("ScopeSchema: ChildSchema not registered yet; ensure scene.ts loaded");
+		return childSchemaRef;
+	})).describe("Scope children: nested nodes / paths / coordinates / scopes. Recursive via the parent ChildSchema (registered late to break the IRChild <-> IRScope cycle).")
+}).describe("Scope container: groups child IR elements and applies local transforms. Corresponds to TikZ `\\begin{scope}` (with optional `local bounding box=id` when id is set, and `name prefix`-like isolation when localNamespace is true).");
+//#endregion
+export { ScopeSchema, __registerChildSchema };

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

@@ -0,0 +1,204 @@
+import { z } from 'zod';
+declare const TranslateSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"translate">;
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    kind: "translate";
+    x: number;
+    y: number;
+}, {
+    kind: "translate";
+    x: number;
+    y: number;
+}>;
+declare const PolarTranslateSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"polar-translate">;
+    origin: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, z.ZodType<import('./position').PolarPosition, z.ZodTypeDef, import('./position').PolarPosition>]>>;
+    angle: z.ZodNumber;
+    radius: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    angle: number;
+    radius: number;
+    kind: "polar-translate";
+    origin?: string | [number, number] | import('./position').PolarPosition | undefined;
+}, {
+    angle: number;
+    radius: number;
+    kind: "polar-translate";
+    origin?: string | [number, number] | import('./position').PolarPosition | undefined;
+}>;
+declare const AtTranslateSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"at-translate">;
+    direction: z.ZodNativeEnum<{
+        readonly above: "above";
+        readonly below: "below";
+        readonly left: "left";
+        readonly right: "right";
+        readonly 'above-left': "above-left";
+        readonly 'above-right': "above-right";
+        readonly 'below-left': "below-left";
+        readonly 'below-right': "below-right";
+    }>;
+    of: z.ZodString;
+    distance: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    direction: "above" | "below" | "left" | "right" | "above-left" | "above-right" | "below-left" | "below-right";
+    of: string;
+    kind: "at-translate";
+    distance?: number | undefined;
+}, {
+    direction: "above" | "below" | "left" | "right" | "above-left" | "above-right" | "below-left" | "below-right";
+    of: string;
+    kind: "at-translate";
+    distance?: number | undefined;
+}>;
+declare const OffsetTranslateSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"offset-translate">;
+    of: z.ZodUnion<[z.ZodString, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, z.ZodType<import('./position').PolarPosition, z.ZodTypeDef, import('./position').PolarPosition>]>;
+    offset: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+}, "strip", z.ZodTypeAny, {
+    of: string | [number, number] | import('./position').PolarPosition;
+    kind: "offset-translate";
+    offset?: [number, number] | undefined;
+}, {
+    of: string | [number, number] | import('./position').PolarPosition;
+    kind: "offset-translate";
+    offset?: [number, number] | undefined;
+}>;
+declare const RotateSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"rotate">;
+    degrees: z.ZodNumber;
+    cx: z.ZodOptional<z.ZodNumber>;
+    cy: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    kind: "rotate";
+    degrees: number;
+    cx?: number | undefined;
+    cy?: number | undefined;
+}, {
+    kind: "rotate";
+    degrees: number;
+    cx?: number | undefined;
+    cy?: number | undefined;
+}>;
+declare const ScaleSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"scale">;
+    x: z.ZodNumber;
+    y: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    kind: "scale";
+    x: number;
+    y?: number | undefined;
+}, {
+    kind: "scale";
+    x: number;
+    y?: number | undefined;
+}>;
+export declare const TransformSchema: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+    kind: z.ZodLiteral<"translate">;
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    kind: "translate";
+    x: number;
+    y: number;
+}, {
+    kind: "translate";
+    x: number;
+    y: number;
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"polar-translate">;
+    origin: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, z.ZodType<import('./position').PolarPosition, z.ZodTypeDef, import('./position').PolarPosition>]>>;
+    angle: z.ZodNumber;
+    radius: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    angle: number;
+    radius: number;
+    kind: "polar-translate";
+    origin?: string | [number, number] | import('./position').PolarPosition | undefined;
+}, {
+    angle: number;
+    radius: number;
+    kind: "polar-translate";
+    origin?: string | [number, number] | import('./position').PolarPosition | undefined;
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"at-translate">;
+    direction: z.ZodNativeEnum<{
+        readonly above: "above";
+        readonly below: "below";
+        readonly left: "left";
+        readonly right: "right";
+        readonly 'above-left': "above-left";
+        readonly 'above-right': "above-right";
+        readonly 'below-left': "below-left";
+        readonly 'below-right': "below-right";
+    }>;
+    of: z.ZodString;
+    distance: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    direction: "above" | "below" | "left" | "right" | "above-left" | "above-right" | "below-left" | "below-right";
+    of: string;
+    kind: "at-translate";
+    distance?: number | undefined;
+}, {
+    direction: "above" | "below" | "left" | "right" | "above-left" | "above-right" | "below-left" | "below-right";
+    of: string;
+    kind: "at-translate";
+    distance?: number | undefined;
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"offset-translate">;
+    of: z.ZodUnion<[z.ZodString, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, z.ZodType<import('./position').PolarPosition, z.ZodTypeDef, import('./position').PolarPosition>]>;
+    offset: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+}, "strip", z.ZodTypeAny, {
+    of: string | [number, number] | import('./position').PolarPosition;
+    kind: "offset-translate";
+    offset?: [number, number] | undefined;
+}, {
+    of: string | [number, number] | import('./position').PolarPosition;
+    kind: "offset-translate";
+    offset?: [number, number] | undefined;
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"rotate">;
+    degrees: z.ZodNumber;
+    cx: z.ZodOptional<z.ZodNumber>;
+    cy: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    kind: "rotate";
+    degrees: number;
+    cx?: number | undefined;
+    cy?: number | undefined;
+}, {
+    kind: "rotate";
+    degrees: number;
+    cx?: number | undefined;
+    cy?: number | undefined;
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"scale">;
+    x: z.ZodNumber;
+    y: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    kind: "scale";
+    x: number;
+    y?: number | undefined;
+}, {
+    kind: "scale";
+    x: number;
+    y?: number | undefined;
+}>]>;
+/** IR 层 transform 类型——6 变体 discriminated union（4 translate + rotate + scale） */
+export type IRTransform = z.infer<typeof TransformSchema>;
+/** 笛卡尔 translate 子分支 */
+export type IRTranslateTransform = z.infer<typeof TranslateSchema>;
+/** 极坐标 translate 子分支 */
+export type IRPolarTranslateTransform = z.infer<typeof PolarTranslateSchema>;
+/** 相对方向 translate 子分支 */
+export type IRAtTranslateTransform = z.infer<typeof AtTranslateSchema>;
+/** 偏移 translate 子分支 */
+export type IROffsetTranslateTransform = z.infer<typeof OffsetTranslateSchema>;
+/** 旋转子分支 */
+export type IRRotateTransform = z.infer<typeof RotateSchema>;
+/** 缩放子分支 */
+export type IRScaleTransform = z.infer<typeof ScaleSchema>;
+export {};
+//# sourceMappingURL=transform.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"transform.d.ts","sourceRoot":"","sources":["../../../src/ir/transform.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,QAAA,MAAM,eAAe;;;;;;;;;;;;EAYlB,CAAC;AAEJ,QAAA,MAAM,oBAAoB;;;;;;;;;;;;;;;EA0BvB,CAAC;AAEJ,QAAA,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;EAwBpB,CAAC;AAEJ,QAAA,MAAM,qBAAqB;;;;;;;;;;;;EAmBxB,CAAC;AAEJ,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;EAsBf,CAAC;AAEJ,QAAA,MAAM,WAAW;;;;;;;;;;;;EAqBd,CAAC;AAEJ,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAWzB,CAAC;AAEJ,gFAAgF;AAChF,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAC1D,wBAAwB;AACxB,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AACnE,wBAAwB;AACxB,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAC7E,yBAAyB;AACzB,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AACvE,uBAAuB;AACvB,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAC/E,YAAY;AACZ,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAC7D,YAAY;AACZ,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC"}

package/dist/es/ir/transform.js

@@ -0,0 +1,56 @@
+import { PositionSchema } from "./position/position.js";
+import { PolarPositionSchema } from "./position/polar-position.js";
+import { AT_DIRECTIONS } from "./position/at-position.js";
+import { z } from "zod";
+//#region src/ir/transform.ts
+var TranslateSchema = z.object({
+	kind: z.literal("translate").describe("Discriminator: Cartesian translate (the 3-variant Scene transform shape)."),
+	x: z.number().describe("Cartesian x translation in user units."),
+	y: z.number().describe("Cartesian y translation in user units (screen y-down).")
+}).describe("Cartesian translate transform; mirrors the Position [x, y] literal. Lowered directly to Scene `GroupPrim` translate.");
+var PolarTranslateSchema = z.object({
+	kind: z.literal("polar-translate").describe("Discriminator: polar translate; mirrors PolarPosition."),
+	origin: z.union([
+		z.string().min(1),
+		PositionSchema,
+		PolarPositionSchema
+	]).optional().describe("Origin reference (same union as PolarPosition.origin): node id string / Cartesian [x, y] / nested PolarPosition; omit = origin at (0, 0) so this acts as an absolute polar shift."),
+	angle: z.number().finite().describe("Angle in degrees; 0° = +x, 90° = +y (screen-down); matches PolarPosition.angle convention."),
+	radius: z.number().finite().describe("Radius / distance in user units; negative values are accepted (equivalent to angle + 180°).")
+}).describe("Polar translate transform; mirrors PolarPosition. Lowered to Cartesian translate at compile time via resolvePosition.");
+var AtTranslateSchema = z.object({
+	kind: z.literal("at-translate").describe("Discriminator: direction-relative translate; mirrors AtPosition."),
+	direction: z.nativeEnum(AT_DIRECTIONS).describe("Direction enum (8 values, shared with AtPosition.direction)."),
+	of: z.string().min(1).describe("Referent node id; must be defined earlier in the IR (forward references rejected, mirroring AtPosition.of)."),
+	distance: z.number().positive().optional().describe("Distance along direction in user units; omit → falls back to CompileOptions.nodeDistance (same default chain as AtPosition.distance).")
+}).describe("Direction-relative translate transform; mirrors AtPosition. Lowered to Cartesian translate at compile time via resolvePosition.");
+var OffsetTranslateSchema = z.object({
+	kind: z.literal("offset-translate").describe("Discriminator: offset-from-referent translate; mirrors OffsetPosition."),
+	of: z.union([
+		z.string().min(1),
+		PositionSchema,
+		PolarPositionSchema
+	]).describe("Referent base point (same union as OffsetPosition.of): node id (forward references rejected) / Cartesian [x, y] / PolarPosition."),
+	offset: z.tuple([z.number().finite(), z.number().finite()]).optional().describe("Additional [dx, dy] offset in user units; omit = [0, 0] so the transform translates exactly to the referent.")
+}).describe("Offset translate transform; mirrors OffsetPosition. Lowered to Cartesian translate at compile time via resolvePosition.");
+var RotateSchema = z.object({
+	kind: z.literal("rotate").describe("Discriminator: rotation about a point."),
+	degrees: z.number().finite().describe("Rotation angle in degrees; positive = visually clockwise under screen y-down."),
+	cx: z.number().finite().optional().describe("Rotation center x in user units; omit = 0 (rotate about local origin)."),
+	cy: z.number().finite().optional().describe("Rotation center y in user units; omit = 0 (rotate about local origin).")
+}).describe("Rotation transform; identical shape to Scene `RotateTransform`. Passed through to GroupPrim without further lowering.");
+var ScaleSchema = z.object({
+	kind: z.literal("scale").describe("Discriminator: uniform / anisotropic scale."),
+	x: z.number().finite().describe("Scale factor on the x axis. Zero scale collapses the coordinate system and is not invertible — relative positions inside the scope degrade to the local origin (0, 0). Avoid zero in practice; use a tiny positive value if a \"near-invisible\" effect is desired."),
+	y: z.number().finite().optional().describe("Scale factor on the y axis; omit = x (uniform scaling). Zero scale falls back to (0, 0) for relative position inverse projection (see `x`).")
+}).describe("Scale transform; identical shape to Scene `ScaleTransform`. Passed through to GroupPrim without further lowering.");
+var TransformSchema = z.discriminatedUnion("kind", [
+	TranslateSchema,
+	PolarTranslateSchema,
+	AtTranslateSchema,
+	OffsetTranslateSchema,
+	RotateSchema,
+	ScaleSchema
+]).describe("IR-level transform; 6 variants. The 4 translate variants (translate / polar-translate / at-translate / offset-translate) mirror the Node.position union one-for-one; rotate and scale match the Scene `Transform` shape. At compile time the 4 translate variants are lowered to Cartesian translate via resolvePosition before being pushed onto the cumulative chain emitted to Scene `GroupPrim` (which stays at 3 variants).");
+//#endregion
+export { TransformSchema };

package/dist/lib/compile/anchor-cache.cjs

@@ -0,0 +1,41 @@
+const require_node = require("./node.cjs");
+//#region src/compile/anchor-cache.ts
+/**
+* (layout, anchorName) → IRPosition 缓存
+* @description WeakMap 让 NodeLayout 引用一旦失效（compile 结束、NameStack 回收），对应 Map 自动 GC，无需手动 invalidate
+*/
+var cache = /* @__PURE__ */ new WeakMap();
+/** 角度字符串识别：可选负号 + 数字 + 可选小数；与 parseTarget.ts 的 ANGLE_RE 同语义 */
+var ANGLE_RE = /^-?\d+(\.\d+)?$/;
+/**
+* 把 anchorName 解析到对应 shape 的 anchor / boundaryPoint 上
+* @description 数字字符串走 angleBoundaryOf；其余按 RectAnchor 走 anchorOf
+*/
+var computeAnchor = (layout, anchorName) => {
+	if (ANGLE_RE.test(anchorName)) return positionToIR(require_node.angleBoundaryOf(layout, Number(anchorName)));
+	return positionToIR(require_node.anchorOf(layout, anchorName));
+};
+/** geometry Position（含 readonly 形态）转 IRPosition 元组（IRPosition === [number, number]） */
+var positionToIR = (p) => [p[0], p[1]];
+/**
+* 取节点 anchor 的全局坐标，带 per-layout 缓存
+* @description name 接受 RectAnchor 关键字（如 `'north'` / `'south-west'`）或数字角度字符串（如 `'30'` / `'-45'`）；
+*   同一 (layout, name) 第二次起返回首调用结果的**同一引用**——上游可用 `===` 判定 cache 命中
+* @param layout 已 Pass 1 完成的 NodeLayout（rect 已是全局坐标）
+* @param anchorName 关键字或数字角度字符串
+* @returns 全局坐标系下的 IRPosition `[x, y]`
+*/
+var resolveAnchor = (layout, anchorName) => {
+	let layoutCache = cache.get(layout);
+	if (!layoutCache) {
+		layoutCache = /* @__PURE__ */ new Map();
+		cache.set(layout, layoutCache);
+	}
+	const cached = layoutCache.get(anchorName);
+	if (cached !== void 0) return cached;
+	const result = computeAnchor(layout, anchorName);
+	layoutCache.set(anchorName, result);
+	return result;
+};
+//#endregion
+exports.resolveAnchor = resolveAnchor;

package/dist/lib/compile/anchor-cache.d.ts

@@ -0,0 +1,12 @@
+import { IRPosition } from '../ir';
+import { NodeLayout } from './node';
+/**
+ * 取节点 anchor 的全局坐标，带 per-layout 缓存
+ * @description name 接受 RectAnchor 关键字（如 `'north'` / `'south-west'`）或数字角度字符串（如 `'30'` / `'-45'`）；
+ *   同一 (layout, name) 第二次起返回首调用结果的**同一引用**——上游可用 `===` 判定 cache 命中
+ * @param layout 已 Pass 1 完成的 NodeLayout（rect 已是全局坐标）
+ * @param anchorName 关键字或数字角度字符串
+ * @returns 全局坐标系下的 IRPosition `[x, y]`
+ */
+export declare const resolveAnchor: (layout: NodeLayout, anchorName: string) => IRPosition;
+//# sourceMappingURL=anchor-cache.d.ts.map

package/dist/lib/compile/anchor-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"anchor-cache.d.ts","sourceRoot":"","sources":["../../../src/compile/anchor-cache.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,OAAO,CAAC;AAExC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAC;AA4BzC;;;;;;;GAOG;AACH,eAAO,MAAM,aAAa,GACxB,QAAQ,UAAU,EAClB,YAAY,MAAM,KACjB,UAWF,CAAC"}