@retikz/core 0.1.0 → 0.2.0-alpha.2

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

@@ -0,0 +1 @@
+{"version":3,"file":"scope.d.ts","sourceRoot":"","sources":["../../../src/ir/scope.ts"],"names":[],"mappings":"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmGrB,CAAC"}

package/dist/lib/ir/transform.cjs

@@ -0,0 +1,56 @@
+const require_position = require("./position/position.cjs");
+const require_polar_position = require("./position/polar-position.cjs");
+const require_at_position = require("./position/at-position.cjs");
+let zod = require("zod");
+//#region src/ir/transform.ts
+var TranslateSchema = zod.z.object({
+	kind: zod.z.literal("translate").describe("Discriminator: Cartesian translate (the 3-variant Scene transform shape)."),
+	x: zod.z.number().describe("Cartesian x translation in user units."),
+	y: zod.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 = zod.z.object({
+	kind: zod.z.literal("polar-translate").describe("Discriminator: polar translate; mirrors PolarPosition."),
+	origin: zod.z.union([
+		zod.z.string().min(1),
+		require_position.PositionSchema,
+		require_polar_position.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: zod.z.number().finite().describe("Angle in degrees; 0° = +x, 90° = +y (screen-down); matches PolarPosition.angle convention."),
+	radius: zod.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 = zod.z.object({
+	kind: zod.z.literal("at-translate").describe("Discriminator: direction-relative translate; mirrors AtPosition."),
+	direction: zod.z.nativeEnum(require_at_position.AT_DIRECTIONS).describe("Direction enum (8 values, shared with AtPosition.direction)."),
+	of: zod.z.string().min(1).describe("Referent node id; must be defined earlier in the IR (forward references rejected, mirroring AtPosition.of)."),
+	distance: zod.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 = zod.z.object({
+	kind: zod.z.literal("offset-translate").describe("Discriminator: offset-from-referent translate; mirrors OffsetPosition."),
+	of: zod.z.union([
+		zod.z.string().min(1),
+		require_position.PositionSchema,
+		require_polar_position.PolarPositionSchema
+	]).describe("Referent base point (same union as OffsetPosition.of): node id (forward references rejected) / Cartesian [x, y] / PolarPosition."),
+	offset: zod.z.tuple([zod.z.number().finite(), zod.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 = zod.z.object({
+	kind: zod.z.literal("rotate").describe("Discriminator: rotation about a point."),
+	degrees: zod.z.number().finite().describe("Rotation angle in degrees; positive = visually clockwise under screen y-down."),
+	cx: zod.z.number().finite().optional().describe("Rotation center x in user units; omit = 0 (rotate about local origin)."),
+	cy: zod.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 = zod.z.object({
+	kind: zod.z.literal("scale").describe("Discriminator: uniform / anisotropic scale."),
+	x: zod.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: zod.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 = zod.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
+exports.TransformSchema = TransformSchema;

package/dist/lib/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/lib/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@retikz/core",
-  "version": "0.1.0",
+  "version": "0.2.0-alpha.2",
   "description": "retikz v0.1 core: framework-agnostic IR, scene compiler, and pure parsers.",
   "type": "module",
   "author": "Pionpill",