@twinfinity/printing 6.0.1-ci.28952-beta → 6.0.2-beta

package/src/layout/clipUtils.ts

@@ -1,193 +1,193 @@
-import type { SvgModelView } from './types';
-import { EPSILON_DIVISION_SAFETY, CENTER_FRACTION } from './geometryConstants';
-
-export type Point = { x: number; y: number };
-export type Polygon = Point[];
-
-import { isRecord, getProp } from './typeGuards';
-
-export const pointInPolygon = (polygon: Polygon, x: number, y: number): boolean => {
-    let inside = false;
-    for (let i = 0, j = polygon.length - 1; i < polygon.length; j = i++) {
-        const xi = polygon[i].x,
-            yi = polygon[i].y;
-        const xj = polygon[j].x,
-            yj = polygon[j].y;
-        const intersect = yi > y !== yj > y && x < ((xj - xi) * (y - yi)) / (yj - yi) + xi;
-        if (intersect) inside = !inside;
-    }
-    return inside;
-};
-
-export const filterItemsInPolygons = (
-    items: unknown[],
-    polygons: Polygon[],
-    xField = 'x',
-    yField = 'z',
-    getPathValue: (obj: unknown, path: string) => unknown
-): unknown[] => {
-    if (!Array.isArray(items) || !Array.isArray(polygons) || polygons.length === 0) return items ?? [];
-    return items.filter((item) => {
-        const xVal = getPathValue(item, xField);
-        const yVal = getPathValue(item, yField);
-        if (!Number.isFinite(xVal) || !Number.isFinite(yVal)) return false;
-        const x = Number(xVal);
-        const y = Number(yVal);
-        return polygons.some((poly) => pointInPolygon(poly, x, y));
-    });
-};
-
-export const filterEntriesByClip = (
-    entries: unknown[],
-    polygons: Array<Array<{ x: number; z: number }>>
-): unknown[] => {
-    if (!Array.isArray(entries) || !Array.isArray(polygons) || polygons.length === 0) return entries ?? [];
-
-    const getCenter = (entry: unknown): { x: number | null; z: number | null } => {
-        const product = getProp(entry, 'product') ?? entry;
-        try {
-            const boundingInfoFn = getProp(product, 'boundingInfo');
-            const boundingInfo = typeof boundingInfoFn === 'function' ? boundingInfoFn() : null;
-            const bbox = isRecord(boundingInfo) ? getProp(boundingInfo, 'boundingBox') : null;
-            const min = isRecord(bbox) ? (getProp(bbox, 'minimumWorld') ?? getProp(bbox, 'minimum')) : null;
-            const max = isRecord(bbox) ? (getProp(bbox, 'maximumWorld') ?? getProp(bbox, 'maximum')) : null;
-            const minX = isRecord(min) ? getProp(min, 'x') : null;
-            const maxX = isRecord(max) ? getProp(max, 'x') : null;
-            const minZ = isRecord(min) ? getProp(min, 'z') : null;
-            const maxZ = isRecord(max) ? getProp(max, 'z') : null;
-            if (Number.isFinite(minX) && Number.isFinite(maxX) && Number.isFinite(minZ) && Number.isFinite(maxZ)) {
-                return {
-                    x: (Number(minX) + Number(maxX)) * CENTER_FRACTION,
-                    z: (Number(minZ) + Number(maxZ)) * CENTER_FRACTION
-                };
-            }
-        } catch {
-            // Bounding info access may fail for products without geometry or with malformed data structures.
-            // This is expected behavior - we fall back to entry.x/z properties below.
-        }
-        const x = getProp(entry, 'x');
-        const z = getProp(entry, 'z');
-        return { x: typeof x === 'number' ? x : null, z: typeof z === 'number' ? z : null };
-    };
-
-    return entries.filter((entry) => {
-        const center = getCenter(entry);
-        if (!Number.isFinite(center.x) || !Number.isFinite(center.z)) return false;
-        const x = Number(center.x);
-        const z = Number(center.z);
-        return polygons.some((poly) =>
-            pointInPolygon(
-                poly.map((p) => ({ x: p.x, y: p.z })),
-                x,
-                z
-            )
-        );
-    });
-};
-
-export const offsetPolygons = (polys: Polygon[], delta: number): Polygon[] => {
-    if (!Array.isArray(polys) || !polys.length || !Number.isFinite(delta) || delta === 0) return polys ?? [];
-    const intersectLines = (p: Point, r: Point, q: Point, s: Point): Point | null => {
-        const rxs = r.x * s.y - r.y * s.x;
-        if (Math.abs(rxs) < EPSILON_DIVISION_SAFETY) return null; // parallel
-        const t = ((q.x - p.x) * s.y - (q.y - p.y) * s.x) / rxs;
-        return { x: p.x + t * r.x, y: p.y + t * r.y };
-    };
-    const offsetPoly = (poly: Polygon): Polygon => {
-        const n = poly.length;
-        if (n < 3) return poly;
-        const area = poly.reduce((sum, p, i) => {
-            const q = poly[(i + 1) % n];
-            return sum + p.x * q.y - q.x * p.y;
-        }, 0);
-        const orient = area >= 0 ? 1 : -1; // ccw => outward is right normal
-        const out: Polygon = [];
-        for (let i = 0; i < n; i++) {
-            const p0 = poly[(i + n - 1) % n];
-            const p1 = poly[i];
-            const p2 = poly[(i + 1) % n];
-            const e1x = p1.x - p0.x;
-            const e1y = p1.y - p0.y;
-            const e2x = p2.x - p1.x;
-            const e2y = p2.y - p1.y;
-            const len1 = Math.hypot(e1x, e1y) || EPSILON_DIVISION_SAFETY;
-            const len2 = Math.hypot(e2x, e2y) || EPSILON_DIVISION_SAFETY;
-            const n1x = (orient * e1y) / len1;
-            const n1y = (orient * -e1x) / len1;
-            const n2x = (orient * e2y) / len2;
-            const n2y = (orient * -e2x) / len2;
-            const line1Point = { x: p1.x + n1x * delta, y: p1.y + n1y * delta };
-            const line2Point = { x: p1.x + n2x * delta, y: p1.y + n2y * delta };
-            const inter = intersectLines(line1Point, { x: e1x, y: e1y }, line2Point, { x: e2x, y: e2y });
-            out.push(inter ?? line2Point);
-        }
-        return out;
-    };
-    return polys.map(offsetPoly);
-};
-
-export const projectPolygonsToLocal = (
-    polygonsSource: unknown,
-    xField: string,
-    yField: string,
-    model: SvgModelView,
-    rotationDeg: number,
-    contentOffsetX: number,
-    contentOffsetY: number,
-    mmPerModel: number
-): { local: Polygon[]; page: Polygon[] } => {
-    const cosA = Math.cos((rotationDeg * Math.PI) / 180);
-    const sinA = Math.sin((rotationDeg * Math.PI) / 180);
-    const toLocal = (px: number, py: number): Point => {
-        const viewX = px - model.transform!.viewMinX;
-        const viewY = model.transform!.viewMaxZ - py;
-        const x0 = viewX - model.widthModel / 2;
-        const y0 = viewY - model.heightModel / 2;
-        const x1 = x0 * cosA - y0 * sinA;
-        const y1 = x0 * sinA + y0 * cosA;
-        return { x: x1, y: y1 };
-    };
-    const toPage = (px: number, py: number): Point => {
-        const viewX = px - model.transform!.viewMinX;
-        const viewY = model.transform!.viewMaxZ - py;
-        const x0 = viewX - model.widthModel / 2;
-        const y0 = viewY - model.heightModel / 2;
-        const x1 = x0 * cosA - y0 * sinA;
-        const y1 = x0 * sinA + y0 * cosA;
-        return { x: contentOffsetX + x1 * mmPerModel, y: contentOffsetY + y1 * mmPerModel };
-    };
-    const projectPolyLocal = (poly: unknown[]): Polygon =>
-        poly
-            .map((pt: unknown) => {
-                const px = Number(getProp(pt, xField));
-                const py = Number(getProp(pt, yField));
-                if (!Number.isFinite(px) || !Number.isFinite(py)) return null;
-                return toLocal(px, py);
-            })
-            .filter(Boolean) as Polygon;
-    const projectPoly = (poly: unknown[]): Polygon =>
-        poly
-            .map((pt: unknown) => {
-                const px = Number(getProp(pt, xField));
-                const py = Number(getProp(pt, yField));
-                if (!Number.isFinite(px) || !Number.isFinite(py)) return null;
-                return toPage(px, py);
-            })
-            .filter(Boolean) as Polygon;
-
-    const local: Polygon[] = [];
-    const page: Polygon[] = [];
-    if (Array.isArray(polygonsSource)) {
-        polygonsSource.forEach((poly: unknown) => {
-            const points = getProp(poly, 'points');
-            const pl = Array.isArray(points) ? points : Array.isArray(poly) ? poly : null;
-            if (!pl || pl.length < 3) return;
-            const projectedLocal = projectPolyLocal(pl);
-            if (projectedLocal.length >= 3) {
-                local.push(projectedLocal);
-                page.push(projectPoly(pl));
-            }
-        });
-    }
-    return { local, page };
-};
+import type { SvgModelView } from './types';
+import { EPSILON_DIVISION_SAFETY, CENTER_FRACTION } from './geometryConstants';
+
+export type Point = { x: number; y: number };
+export type Polygon = Point[];
+
+import { isRecord, getProp } from './typeGuards';
+
+export const pointInPolygon = (polygon: Polygon, x: number, y: number): boolean => {
+    let inside = false;
+    for (let i = 0, j = polygon.length - 1; i < polygon.length; j = i++) {
+        const xi = polygon[i].x,
+            yi = polygon[i].y;
+        const xj = polygon[j].x,
+            yj = polygon[j].y;
+        const intersect = yi > y !== yj > y && x < ((xj - xi) * (y - yi)) / (yj - yi) + xi;
+        if (intersect) inside = !inside;
+    }
+    return inside;
+};
+
+export const filterItemsInPolygons = (
+    items: unknown[],
+    polygons: Polygon[],
+    xField = 'x',
+    yField = 'z',
+    getPathValue: (obj: unknown, path: string) => unknown
+): unknown[] => {
+    if (!Array.isArray(items) || !Array.isArray(polygons) || polygons.length === 0) return items ?? [];
+    return items.filter((item) => {
+        const xVal = getPathValue(item, xField);
+        const yVal = getPathValue(item, yField);
+        if (!Number.isFinite(xVal) || !Number.isFinite(yVal)) return false;
+        const x = Number(xVal);
+        const y = Number(yVal);
+        return polygons.some((poly) => pointInPolygon(poly, x, y));
+    });
+};
+
+export const filterEntriesByClip = (
+    entries: unknown[],
+    polygons: Array<Array<{ x: number; z: number }>>
+): unknown[] => {
+    if (!Array.isArray(entries) || !Array.isArray(polygons) || polygons.length === 0) return entries ?? [];
+
+    const getCenter = (entry: unknown): { x: number | null; z: number | null } => {
+        const product = getProp(entry, 'product') ?? entry;
+        try {
+            const boundingInfoFn = getProp(product, 'boundingInfo');
+            const boundingInfo = typeof boundingInfoFn === 'function' ? boundingInfoFn() : null;
+            const bbox = isRecord(boundingInfo) ? getProp(boundingInfo, 'boundingBox') : null;
+            const min = isRecord(bbox) ? (getProp(bbox, 'minimumWorld') ?? getProp(bbox, 'minimum')) : null;
+            const max = isRecord(bbox) ? (getProp(bbox, 'maximumWorld') ?? getProp(bbox, 'maximum')) : null;
+            const minX = isRecord(min) ? getProp(min, 'x') : null;
+            const maxX = isRecord(max) ? getProp(max, 'x') : null;
+            const minZ = isRecord(min) ? getProp(min, 'z') : null;
+            const maxZ = isRecord(max) ? getProp(max, 'z') : null;
+            if (Number.isFinite(minX) && Number.isFinite(maxX) && Number.isFinite(minZ) && Number.isFinite(maxZ)) {
+                return {
+                    x: (Number(minX) + Number(maxX)) * CENTER_FRACTION,
+                    z: (Number(minZ) + Number(maxZ)) * CENTER_FRACTION
+                };
+            }
+        } catch {
+            // Bounding info access may fail for products without geometry or with malformed data structures.
+            // This is expected behavior - we fall back to entry.x/z properties below.
+        }
+        const x = getProp(entry, 'x');
+        const z = getProp(entry, 'z');
+        return { x: typeof x === 'number' ? x : null, z: typeof z === 'number' ? z : null };
+    };
+
+    return entries.filter((entry) => {
+        const center = getCenter(entry);
+        if (!Number.isFinite(center.x) || !Number.isFinite(center.z)) return false;
+        const x = Number(center.x);
+        const z = Number(center.z);
+        return polygons.some((poly) =>
+            pointInPolygon(
+                poly.map((p) => ({ x: p.x, y: p.z })),
+                x,
+                z
+            )
+        );
+    });
+};
+
+export const offsetPolygons = (polys: Polygon[], delta: number): Polygon[] => {
+    if (!Array.isArray(polys) || !polys.length || !Number.isFinite(delta) || delta === 0) return polys ?? [];
+    const intersectLines = (p: Point, r: Point, q: Point, s: Point): Point | null => {
+        const rxs = r.x * s.y - r.y * s.x;
+        if (Math.abs(rxs) < EPSILON_DIVISION_SAFETY) return null; // parallel
+        const t = ((q.x - p.x) * s.y - (q.y - p.y) * s.x) / rxs;
+        return { x: p.x + t * r.x, y: p.y + t * r.y };
+    };
+    const offsetPoly = (poly: Polygon): Polygon => {
+        const n = poly.length;
+        if (n < 3) return poly;
+        const area = poly.reduce((sum, p, i) => {
+            const q = poly[(i + 1) % n];
+            return sum + p.x * q.y - q.x * p.y;
+        }, 0);
+        const orient = area >= 0 ? 1 : -1; // ccw => outward is right normal
+        const out: Polygon = [];
+        for (let i = 0; i < n; i++) {
+            const p0 = poly[(i + n - 1) % n];
+            const p1 = poly[i];
+            const p2 = poly[(i + 1) % n];
+            const e1x = p1.x - p0.x;
+            const e1y = p1.y - p0.y;
+            const e2x = p2.x - p1.x;
+            const e2y = p2.y - p1.y;
+            const len1 = Math.hypot(e1x, e1y) || EPSILON_DIVISION_SAFETY;
+            const len2 = Math.hypot(e2x, e2y) || EPSILON_DIVISION_SAFETY;
+            const n1x = (orient * e1y) / len1;
+            const n1y = (orient * -e1x) / len1;
+            const n2x = (orient * e2y) / len2;
+            const n2y = (orient * -e2x) / len2;
+            const line1Point = { x: p1.x + n1x * delta, y: p1.y + n1y * delta };
+            const line2Point = { x: p1.x + n2x * delta, y: p1.y + n2y * delta };
+            const inter = intersectLines(line1Point, { x: e1x, y: e1y }, line2Point, { x: e2x, y: e2y });
+            out.push(inter ?? line2Point);
+        }
+        return out;
+    };
+    return polys.map(offsetPoly);
+};
+
+export const projectPolygonsToLocal = (
+    polygonsSource: unknown,
+    xField: string,
+    yField: string,
+    model: SvgModelView,
+    rotationDeg: number,
+    contentOffsetX: number,
+    contentOffsetY: number,
+    mmPerModel: number
+): { local: Polygon[]; page: Polygon[] } => {
+    const cosA = Math.cos((rotationDeg * Math.PI) / 180);
+    const sinA = Math.sin((rotationDeg * Math.PI) / 180);
+    const toLocal = (px: number, py: number): Point => {
+        const viewX = px - model.transform!.viewMinX;
+        const viewY = model.transform!.viewMaxZ - py;
+        const x0 = viewX - model.widthModel / 2;
+        const y0 = viewY - model.heightModel / 2;
+        const x1 = x0 * cosA - y0 * sinA;
+        const y1 = x0 * sinA + y0 * cosA;
+        return { x: x1, y: y1 };
+    };
+    const toPage = (px: number, py: number): Point => {
+        const viewX = px - model.transform!.viewMinX;
+        const viewY = model.transform!.viewMaxZ - py;
+        const x0 = viewX - model.widthModel / 2;
+        const y0 = viewY - model.heightModel / 2;
+        const x1 = x0 * cosA - y0 * sinA;
+        const y1 = x0 * sinA + y0 * cosA;
+        return { x: contentOffsetX + x1 * mmPerModel, y: contentOffsetY + y1 * mmPerModel };
+    };
+    const projectPolyLocal = (poly: unknown[]): Polygon =>
+        poly
+            .map((pt: unknown) => {
+                const px = Number(getProp(pt, xField));
+                const py = Number(getProp(pt, yField));
+                if (!Number.isFinite(px) || !Number.isFinite(py)) return null;
+                return toLocal(px, py);
+            })
+            .filter(Boolean) as Polygon;
+    const projectPoly = (poly: unknown[]): Polygon =>
+        poly
+            .map((pt: unknown) => {
+                const px = Number(getProp(pt, xField));
+                const py = Number(getProp(pt, yField));
+                if (!Number.isFinite(px) || !Number.isFinite(py)) return null;
+                return toPage(px, py);
+            })
+            .filter(Boolean) as Polygon;
+
+    const local: Polygon[] = [];
+    const page: Polygon[] = [];
+    if (Array.isArray(polygonsSource)) {
+        polygonsSource.forEach((poly: unknown) => {
+            const points = getProp(poly, 'points');
+            const pl = Array.isArray(points) ? points : Array.isArray(poly) ? poly : null;
+            if (!pl || pl.length < 3) return;
+            const projectedLocal = projectPolyLocal(pl);
+            if (projectedLocal.length >= 3) {
+                local.push(projectedLocal);
+                page.push(projectPoly(pl));
+            }
+        });
+    }
+    return { local, page };
+};

package/src/layout/colorConstants.ts

@@ -1,16 +1,16 @@
-/**
- * Color computation constants
- */
-
-// RGB color value limits
-export const RGB_MAX = 255; // Maximum value for RGB color components (0-255)
-export const RGB_MIN = 0; // Minimum value for RGB color components
-
-// Bit shift offsets for color packing/unpacking
-export const RED_SHIFT = 16; // Shift for red component in 24-bit color
-export const GREEN_SHIFT = 8; // Shift for green component in 24-bit color
-
-// Color modulo for hash-based color generation
-export const HASH_COLOR_MODULO = 255; // Modulo for generating colors from hash values
-export const HASH_GREEN_SHIFT = 4; // Bit shift for green in hash-based colors
-export const HASH_BLUE_SHIFT = 8; // Bit shift for blue in hash-based colors
+/**
+ * Color computation constants
+ */
+
+// RGB color value limits
+export const RGB_MAX = 255; // Maximum value for RGB color components (0-255)
+export const RGB_MIN = 0; // Minimum value for RGB color components
+
+// Bit shift offsets for color packing/unpacking
+export const RED_SHIFT = 16; // Shift for red component in 24-bit color
+export const GREEN_SHIFT = 8; // Shift for green component in 24-bit color
+
+// Color modulo for hash-based color generation
+export const HASH_COLOR_MODULO = 255; // Modulo for generating colors from hash values
+export const HASH_GREEN_SHIFT = 4; // Bit shift for green in hash-based colors
+export const HASH_BLUE_SHIFT = 8; // Bit shift for blue in hash-based colors

package/src/layout/elementKinds.ts

@@ -1,35 +1,35 @@
-/**
- * Constants for layout element kinds
- */
-
-export const ELEMENT_KIND_VIEWPORT = 'viewport';
-export const ELEMENT_KIND_TEXT = 'text';
-export const ELEMENT_KIND_IMAGE = 'image';
-export const ELEMENT_KIND_LINE = 'line';
-export const ELEMENT_KIND_RECT = 'rect';
-export const ELEMENT_KIND_CIRCLE = 'circle';
-export const ELEMENT_KIND_POLYLINE = 'polyline';
-export const ELEMENT_KIND_POLYGON = 'polygon';
-export const ELEMENT_KIND_SCALE_BAR = 'scaleBar';
-export const ELEMENT_KIND_QR = 'qr';
-export const ELEMENT_KIND_LABELS = 'labels';
-export const ELEMENT_KIND_LEGEND = 'legend';
-export const ELEMENT_KIND_GROUP = 'group';
-
-/**
- * Union type of all valid element kinds
- */
-export type ElementKind =
-    | typeof ELEMENT_KIND_VIEWPORT
-    | typeof ELEMENT_KIND_TEXT
-    | typeof ELEMENT_KIND_IMAGE
-    | typeof ELEMENT_KIND_LINE
-    | typeof ELEMENT_KIND_RECT
-    | typeof ELEMENT_KIND_CIRCLE
-    | typeof ELEMENT_KIND_POLYLINE
-    | typeof ELEMENT_KIND_POLYGON
-    | typeof ELEMENT_KIND_SCALE_BAR
-    | typeof ELEMENT_KIND_QR
-    | typeof ELEMENT_KIND_LABELS
-    | typeof ELEMENT_KIND_LEGEND
-    | typeof ELEMENT_KIND_GROUP;
+/**
+ * Constants for layout element kinds
+ */
+
+export const ELEMENT_KIND_VIEWPORT = 'viewport';
+export const ELEMENT_KIND_TEXT = 'text';
+export const ELEMENT_KIND_IMAGE = 'image';
+export const ELEMENT_KIND_LINE = 'line';
+export const ELEMENT_KIND_RECT = 'rect';
+export const ELEMENT_KIND_CIRCLE = 'circle';
+export const ELEMENT_KIND_POLYLINE = 'polyline';
+export const ELEMENT_KIND_POLYGON = 'polygon';
+export const ELEMENT_KIND_SCALE_BAR = 'scaleBar';
+export const ELEMENT_KIND_QR = 'qr';
+export const ELEMENT_KIND_LABELS = 'labels';
+export const ELEMENT_KIND_LEGEND = 'legend';
+export const ELEMENT_KIND_GROUP = 'group';
+
+/**
+ * Union type of all valid element kinds
+ */
+export type ElementKind =
+    | typeof ELEMENT_KIND_VIEWPORT
+    | typeof ELEMENT_KIND_TEXT
+    | typeof ELEMENT_KIND_IMAGE
+    | typeof ELEMENT_KIND_LINE
+    | typeof ELEMENT_KIND_RECT
+    | typeof ELEMENT_KIND_CIRCLE
+    | typeof ELEMENT_KIND_POLYLINE
+    | typeof ELEMENT_KIND_POLYGON
+    | typeof ELEMENT_KIND_SCALE_BAR
+    | typeof ELEMENT_KIND_QR
+    | typeof ELEMENT_KIND_LABELS
+    | typeof ELEMENT_KIND_LEGEND
+    | typeof ELEMENT_KIND_GROUP;