@segnavia/render 0.0.0-stage → 0.2.0

package/dist/press/report.js

@@ -0,0 +1,79 @@
+import { RenderRefusedError } from "../errors.js";
+import { groupAction, shadingAction } from "./policy.js";
+import { inspectContent } from "./content.js";
+import { decodeContent, nameOf, numberOf, resolvedColorSpace } from "./pdf-objects.js";
+import { walkPressGraph } from "./visitor.js";
+import { PDFDict, PDFDocument, PDFName, PDFRef } from "pdf-lib";
+//#region src/press/report.ts
+const key = (name) => PDFName.of(name);
+const refuse = (found, supported) => {
+	throw new RenderRefusedError(`The PDF has unsupported ${found}; supported: ${supported}.`);
+};
+const resolved = (state, object) => object instanceof PDFRef ? state.document.context.lookup(object) : object;
+const requiredDimension = (value, name) => value ?? refuse(`RGB image ${name} missing`, `a ${name} number`);
+function inspectImage(state, image) {
+	if (state.images.has(image)) return;
+	state.images.add(image);
+	const space = resolvedColorSpace(state.document, resolved(state, image.dict.get(key("ColorSpace"))));
+	if (space.kind !== "rgb") return;
+	const width = requiredDimension(numberOf(image.dict, "Width"), "Width");
+	const height = requiredDimension(numberOf(image.dict, "Height"), "Height");
+	state.report.images.push({
+		width,
+		height,
+		colorSpace: space.label
+	});
+}
+function inspectFunction(state, fn, policy) {
+	if (policy.action === "refuse") refuse(policy.found, policy.supported);
+	if (fn && numberOf(fn, "FunctionType") === 2) state.report.gradientStops += 2;
+}
+function inspectShading(state, shading) {
+	if (state.shadings.has(shading)) return false;
+	state.shadings.add(shading);
+	const type = numberOf(shading, "ShadingType");
+	const space = resolvedColorSpace(state.document, resolved(state, shading.get(key("ColorSpace"))));
+	const policy = shadingAction(space.kind, type);
+	if (policy.action === "refuse" || policy.action === "convert") refuse(`ShadingType ${type ?? "missing"} color space ${space.label}`, policy.supported);
+	return true;
+}
+function inspectGroup(state, owner, maskSource) {
+	const group = owner.lookupMaybe(key("Group"), PDFDict);
+	if (!group || nameOf(group.get(key("S"))) !== "Transparency" || state.groups.has(group)) return;
+	state.groups.add(group);
+	const space = resolvedColorSpace(state.document, resolved(state, group.get(key("CS"))));
+	const policy = groupAction(space.kind, space.label, maskSource);
+	if (policy.action !== "keep") refuse(`transparency group color space ${space.label}`, policy.supported);
+	if (space.kind === "cmyk") state.report.groups++;
+}
+async function inspectPressPdf(bytes) {
+	const document = await PDFDocument.load(bytes, { updateMetadata: false });
+	const state = {
+		budget: { decodedBytes: 0 },
+		document,
+		groups: /* @__PURE__ */ new WeakSet(),
+		images: /* @__PURE__ */ new WeakSet(),
+		report: {
+			images: [],
+			fills: 0,
+			strokes: 0,
+			gradientStops: 0,
+			groups: 0
+		},
+		shadings: /* @__PURE__ */ new WeakSet()
+	};
+	walkPressGraph(document, {
+		content: (_object, stream) => {
+			const counts = inspectContent(decodeContent(stream, state.budget));
+			state.report.fills += counts.fills;
+			state.report.strokes += counts.strokes;
+		},
+		function: (fn, decision) => inspectFunction(state, fn, decision),
+		group: (owner, _stream, maskSource) => inspectGroup(state, owner, maskSource),
+		image: (image) => inspectImage(state, image),
+		shading: (shading) => inspectShading(state, shading)
+	});
+	return state.report;
+}
+//#endregion
+export { inspectPressPdf };

package/dist/press/types.d.ts

@@ -0,0 +1,16 @@
+//#region src/press/types.d.ts
+export interface PressImage {
+  width: number;
+  height: number;
+  colorSpace: 'DeviceRGB' | 'CalRGB' | 'ICCBased' | 'Indexed';
+}
+export interface PressReport {
+  /** Authored raster images left in RGB, read back from the finished PDF. */
+  images: PressImage[];
+  /** CMYK painting and group counts read back from the finished PDF. */
+  fills: number;
+  strokes: number;
+  gradientStops: number;
+  groups: number;
+}
+//#endregion

package/dist/press/visitor.js

@@ -0,0 +1,140 @@
+import { shadingFunctionAction } from "./policy.js";
+import { dictionaryOf, nameOf, numberOf, rawStreamOf } from "./pdf-objects.js";
+import { PDFArray, PDFDict, PDFName, PDFRef } from "pdf-lib";
+//#region src/press/visitor.ts
+const key = (name) => PDFName.of(name);
+const resolved = (state, object) => object instanceof PDFRef ? state.document.context.lookup(object) : object;
+const dictionary = (state, object) => dictionaryOf(resolved(state, object));
+const stream = (state, object) => rawStreamOf(resolved(state, object));
+function visitContent(state, object, replace) {
+	if (!object) return;
+	if (object instanceof PDFRef) {
+		const label = object.toString();
+		if (state.references.has(label)) return;
+		state.references.add(label);
+	}
+	const found = stream(state, object);
+	if (!found || state.streams.has(found)) return;
+	state.streams.add(found);
+	state.actions?.group(found.dict, found, state.maskSources.has(found));
+	state.actions?.content(object, found, replace);
+	visitResources(state, found.dict.lookupMaybe(key("Resources"), PDFDict));
+}
+function visitSoftMask(state, object) {
+	const mask = dictionary(state, dictionary(state, object)?.get(key("SMask")));
+	const sourceObject = mask?.get(key("G"));
+	const source = stream(state, sourceObject);
+	if (!source || !sourceObject) return;
+	state.maskSources.add(source);
+	visitContent(state, sourceObject, (replacement) => mask?.set(key("G"), replacement));
+}
+function visitAppearances(state, page) {
+	const annotations = resolved(state, page.get(key("Annots")));
+	if (!(annotations instanceof PDFArray)) return;
+	for (let index = 0; index < annotations.size(); index++) {
+		const appearance = dictionary(state, dictionary(state, annotations.get(index))?.get(key("AP")));
+		for (const name of [
+			"N",
+			"R",
+			"D"
+		]) {
+			const object = appearance?.get(key(name));
+			if (!object) continue;
+			if (stream(state, object)) visitContent(state, object, (replacement) => appearance?.set(key(name), replacement));
+			else {
+				const states = dictionary(state, object);
+				for (const [stateName, stateObject] of states?.entries() ?? []) visitContent(state, stateObject, (replacement) => states?.set(stateName, replacement));
+			}
+		}
+	}
+}
+function visitFunction(state, object) {
+	const fn = dictionary(state, object);
+	if (fn && state.functions.has(fn)) return;
+	if (fn) state.functions.add(fn);
+	const type = fn ? numberOf(fn, "FunctionType") : void 0;
+	const functions = type === 3 ? fn?.lookupMaybe(key("Functions"), PDFArray) : void 0;
+	const decision = shadingFunctionAction(type, Boolean(fn), type !== 3 || Boolean(functions));
+	state.actions?.function(fn, decision);
+	for (let index = 0; index < (functions?.size() ?? 0); index++) visitFunction(state, functions?.get(index));
+}
+function visitShading(state, shading) {
+	if (state.actions?.shading(shading)) visitFunction(state, shading.get(key("Function")));
+}
+function visitShadings(state, resources) {
+	const shadings = resources.lookupMaybe(key("Shading"), PDFDict);
+	for (const [, object] of shadings?.entries() ?? []) {
+		const found = dictionary(state, object);
+		if (found) visitShading(state, found);
+	}
+}
+function visitPatterns(state, resources) {
+	const patterns = resources.lookupMaybe(key("Pattern"), PDFDict);
+	for (const [name, object] of patterns?.entries() ?? []) {
+		const found = dictionary(state, object);
+		if (!found) continue;
+		if (numberOf(found, "PatternType") === 2) {
+			const shading = dictionary(state, found.get(key("Shading")));
+			if (shading) visitShading(state, shading);
+		} else visitContent(state, object, (replacement) => patterns?.set(name, replacement));
+		visitResources(state, found.lookupMaybe(key("Resources"), PDFDict));
+	}
+}
+function visitGraphicsStates(state, resources) {
+	const graphicsStates = resources.lookupMaybe(key("ExtGState"), PDFDict);
+	for (const [, object] of graphicsStates?.entries() ?? []) visitSoftMask(state, object);
+}
+function visitXObjects(state, resources) {
+	const xObjects = resources.lookupMaybe(key("XObject"), PDFDict);
+	for (const [name, object] of xObjects?.entries() ?? []) {
+		const found = stream(state, object);
+		if (!found) continue;
+		if (nameOf(found.dict.get(key("Subtype"))) === "Image") state.actions?.image(found);
+		else visitContent(state, object, (replacement) => xObjects?.set(name, replacement));
+	}
+}
+function visitFonts(state, resources) {
+	const fonts = resources.lookupMaybe(key("Font"), PDFDict);
+	for (const [, object] of fonts?.entries() ?? []) {
+		const font = dictionary(state, object);
+		if (!font || nameOf(font.get(key("Subtype"))) !== "Type3") continue;
+		const charProcs = font.lookupMaybe(key("CharProcs"), PDFDict);
+		for (const [name, glyph] of charProcs?.entries() ?? []) visitContent(state, glyph, (replacement) => charProcs?.set(name, replacement));
+		visitResources(state, font.lookupMaybe(key("Resources"), PDFDict));
+	}
+}
+function visitResources(state, resources) {
+	if (!resources || state.resources.has(resources)) return;
+	state.resources.add(resources);
+	visitShadings(state, resources);
+	visitPatterns(state, resources);
+	visitGraphicsStates(state, resources);
+	visitXObjects(state, resources);
+	visitFonts(state, resources);
+}
+function traverse(document, maskSources, actions) {
+	const state = {
+		document,
+		maskSources,
+		actions,
+		functions: /* @__PURE__ */ new WeakSet(),
+		references: /* @__PURE__ */ new Set(),
+		resources: /* @__PURE__ */ new WeakSet(),
+		streams: /* @__PURE__ */ new WeakSet()
+	};
+	for (const page of document.getPages()) {
+		actions?.group(page.node, void 0, false);
+		const contents = page.node.Contents();
+		if (contents instanceof PDFArray) for (let index = 0; index < contents.size(); index++) visitContent(state, contents.get(index), (replacement) => contents.set(index, replacement));
+		else visitContent(state, contents, (replacement) => page.node.set(key("Contents"), replacement));
+		visitResources(state, page.node.Resources());
+		visitAppearances(state, page.node);
+	}
+}
+function walkPressGraph(document, actions) {
+	const maskSources = /* @__PURE__ */ new WeakSet();
+	traverse(document, maskSources);
+	traverse(document, maskSources, actions);
+}
+//#endregion
+export { walkPressGraph };

package/package.json

@@ -1,6 +1,34 @@
 {
   "name": "@segnavia/render",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.2.0",
+  "type": "module",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/modstudio/segnavia.git",
+    "directory": "packages/render"
+  },
+  "files": [
+    "dist"
+  ],
+  "sideEffects": false,
+  "engines": {
+    "node": ">=22"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "exports": {
+    ".": {
+      "@segnavia/source": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "@segnavia/format": "0.2.0",
+    "@segnavia/frame": "0.2.0",
+    "playwright-core": "1.55.1",
+    "pdf-lib": "^1.17.1"
+  }
+}

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.