@jasy/pdf 1.0.0-alpha.8 → 1.0.0-beta.1

package/dist/vector/path.d.ts

@@ -0,0 +1,33 @@
+import type { PathCommand } from "../ir/display-list.js";
+/**
+ * Geometry helpers shared by everything that produces a `Path` IR node - today a colour glyph's
+ * outline, next an SVG shape.
+ *
+ * PDF has no quadratic curve operator: `c` (cubic), `v` and `y` are all there is. TrueType outlines
+ * are quadratic and so is SVG's `Q`/`T`, so both have to raise the degree, and there is exactly one
+ * correct way to do it - hence one function rather than two copies that drift.
+ */
+/**
+ * Raises a quadratic Bézier to the cubic PDF wants. A quadratic with control point `C` between `P0`
+ * and `P1` is the cubic with controls `P0 + 2/3(C - P0)` and `P1 + 2/3(C - P1)` - an exact identity,
+ * not an approximation, so nothing is lost.
+ */
+export declare function quadToCubic(x0: number, y0: number, cx: number, cy: number, x: number, y: number): PathCommand;
+/**
+ * Applies an affine to every point of a command list, BAKING the transform into the coordinates.
+ *
+ * Normally a transform belongs in the graphics state, so a stroke scales with the drawing. A clip has
+ * no stroke and is set from a path in the CURRENT space, so a `<clipPath>` whose children carry their
+ * own `transform` has to have it folded in here instead.
+ */
+export declare function transformCommands(commands: readonly PathCommand[], [a, b, c, d, e, f]: readonly [number, number, number, number, number, number]): PathCommand[];
+/**
+ * The bounding box of a command list. Control points are included, which overstates a curve slightly -
+ * the approximation every renderer makes for `objectBoundingBox` units and for a canvas gradient.
+ */
+export declare function boundsOf(commands: readonly PathCommand[]): {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};

package/dist/vector/path.js

@@ -0,0 +1,81 @@
+/**
+ * Geometry helpers shared by everything that produces a `Path` IR node - today a colour glyph's
+ * outline, next an SVG shape.
+ *
+ * PDF has no quadratic curve operator: `c` (cubic), `v` and `y` are all there is. TrueType outlines
+ * are quadratic and so is SVG's `Q`/`T`, so both have to raise the degree, and there is exactly one
+ * correct way to do it - hence one function rather than two copies that drift.
+ */
+/**
+ * Raises a quadratic Bézier to the cubic PDF wants. A quadratic with control point `C` between `P0`
+ * and `P1` is the cubic with controls `P0 + 2/3(C - P0)` and `P1 + 2/3(C - P1)` - an exact identity,
+ * not an approximation, so nothing is lost.
+ */
+export function quadToCubic(x0, y0, cx, cy, x, y) {
+    return {
+        op: "c",
+        x1: x0 + (2 / 3) * (cx - x0),
+        y1: y0 + (2 / 3) * (cy - y0),
+        x2: x + (2 / 3) * (cx - x),
+        y2: y + (2 / 3) * (cy - y),
+        x,
+        y,
+    };
+}
+/**
+ * Applies an affine to every point of a command list, BAKING the transform into the coordinates.
+ *
+ * Normally a transform belongs in the graphics state, so a stroke scales with the drawing. A clip has
+ * no stroke and is set from a path in the CURRENT space, so a `<clipPath>` whose children carry their
+ * own `transform` has to have it folded in here instead.
+ */
+export function transformCommands(commands, [a, b, c, d, e, f]) {
+    const mx = (x, y) => a * x + c * y + e;
+    const my = (x, y) => b * x + d * y + f;
+    return commands.map((cmd) => {
+        if (cmd.op === "z")
+            return cmd;
+        if (cmd.op === "c") {
+            return {
+                op: "c",
+                x1: mx(cmd.x1, cmd.y1),
+                y1: my(cmd.x1, cmd.y1),
+                x2: mx(cmd.x2, cmd.y2),
+                y2: my(cmd.x2, cmd.y2),
+                x: mx(cmd.x, cmd.y),
+                y: my(cmd.x, cmd.y),
+            };
+        }
+        return { op: cmd.op, x: mx(cmd.x, cmd.y), y: my(cmd.x, cmd.y) };
+    });
+}
+/**
+ * The bounding box of a command list. Control points are included, which overstates a curve slightly -
+ * the approximation every renderer makes for `objectBoundingBox` units and for a canvas gradient.
+ */
+export function boundsOf(commands) {
+    let minX = Infinity;
+    let minY = Infinity;
+    let maxX = -Infinity;
+    let maxY = -Infinity;
+    for (const c of commands) {
+        const points = c.op === "c"
+            ? [
+                [c.x1, c.y1],
+                [c.x2, c.y2],
+                [c.x, c.y],
+            ]
+            : c.op === "z"
+                ? []
+                : [[c.x, c.y]];
+        for (const [x, y] of points) {
+            minX = Math.min(minX, x);
+            maxX = Math.max(maxX, x);
+            minY = Math.min(minY, y);
+            maxY = Math.max(maxY, y);
+        }
+    }
+    if (!Number.isFinite(minX))
+        return { x: 0, y: 0, width: 0, height: 0 };
+    return { x: minX, y: minY, width: maxX - minX, height: maxY - minY };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jasy/pdf",
-  "version": "1.0.0-alpha.8",
+  "version": "1.0.0-beta.1",
   "description": "Declarative, component-based PDF generation in pure TypeScript - Flutter-style components, real AFM font metrics, a hand-rolled PDF writer. No headless browser, no Java.",
   "keywords": [
     "declarative",
@@ -40,13 +40,17 @@
     "./package.json": "./package.json"
   },
   "dependencies": {
+    "bidi-js": "^1.0.3",
+    "brotli": "^1.3.3",
     "fflate": "^0.8.3",
-    "jimp": "^1.6.0"
+    "jimp": "^1.6.0",
+    "svgpath": "^2.6.0"
   },
   "devDependencies": {
     "@jimp/types": "^1.6.0",
     "@types/node": "^25.9.3",
     "@vitest/coverage-v8": "^2.1.1",
+    "hyphen": "^1.14.1",
     "ncp": "^2.0.0",
     "oxfmt": "^0.55.0",
     "oxlint": "^1.70.0",