@segnavia/idml 0.28.0 → 0.30.0

package/dist/model.js

@@ -1,21 +1,15 @@
 import { refusal } from "./refusal.js";
+import { localName, numberAttribute } from "./xml.js";
+import { readMargin } from "./margins.js";
+import { ReportCollector } from "./report.js";
+import { parseStyles, parseSwatches } from "./styles.js";
+import { FramePreferenceIndex, framePreference } from "./frame-preferences.js";
 import { IDML_LIMITS } from "./limits.js";
+import { parseParts } from "./parse-parts.js";
+import { parseStories } from "./story-model.js";
+import { collectUnsupportedElements } from "./unsupported-elements.js";
 import { isTag } from "domhandler";
-import { Parser, parseDocument } from "htmlparser2";
 //#region src/model.ts
-const MAPPED_ELEMENTS = /* @__PURE__ */ new Set([
-	"Document",
-	"DocumentPreference",
-	"MarginPreference",
-	"MasterSpread",
-	"Spread",
-	"Page",
-	"Story",
-	"TextFrame"
-]);
-function localName(name) {
-	return name.includes(":") ? name.split(":").at(-1) ?? name : name;
-}
 function elements(root, name) {
 	const found = [];
 	const pending = [root];
@@ -35,12 +29,6 @@ function attribute(element, ...names) {
 		if (value !== void 0) return value;
 	}
 }
-function numberAttribute(element, name, fallback) {
-	const raw = element && attribute(element, name);
-	const value = raw === void 0 ? fallback : Number(raw);
-	if (value === void 0 || !Number.isFinite(value) || value < 0) throw refusal(`IDML ${name} must be a non-negative number`, `set ${name} to a non-negative numeric value`);
-	return value;
-}
 function boolAttribute(element, name, fallback) {
 	const raw = attribute(element, name);
 	if (raw === void 0) return fallback;
@@ -48,57 +36,14 @@ function boolAttribute(element, name, fallback) {
 	if (raw === "false") return false;
 	throw refusal(`IDML ${name} must be true or false`, `set ${name} to true or false`);
 }
-function checkXmlDepth(source, part, limit) {
-	let depth = 0;
-	new Parser({
-		onopentag() {
-			depth += 1;
-			if (depth > limit) throw refusal(`IDML XML part ${part} exceeds the ${limit} level XML depth limit`, `reduce its nesting to ${limit} levels or fewer`);
-		},
-		onclosetag() {
-			depth -= 1;
-		}
-	}, {
-		xmlMode: true,
-		recognizeSelfClosing: true
-	}).end(source);
-}
-function parseParts(entries, limits) {
-	const decoder = new TextDecoder("utf-8", { fatal: true });
-	return entries.filter((entry) => entry.name.toLowerCase().endsWith(".xml")).map((entry) => {
-		let source;
-		try {
-			source = decoder.decode(entry.bytes);
-		} catch {
-			throw refusal(`IDML XML part ${entry.name} is not valid UTF-8`, "export that XML part as UTF-8");
-		}
-		let document;
-		try {
-			checkXmlDepth(source, entry.name, limits.xmlDepth);
-			document = parseDocument(source, {
-				xmlMode: true,
-				recognizeSelfClosing: true
-			});
-		} catch (error) {
-			if (error instanceof Error && error.message.includes("XML depth limit")) throw error;
-			throw refusal(`IDML XML part ${entry.name} could not be parsed: ${String(error)}`, "export well-formed XML");
-		}
-		const all = elements(document);
-		if (all.length === 0) throw refusal(`IDML XML part ${entry.name} has no root element`, "export a non-empty well-formed XML part");
-		return {
-			name: entry.name,
-			document,
-			all
-		};
-	});
-}
 function page(element) {
 	const id = attribute(element, "Self");
 	if (!id) throw refusal("an IDML Page has no Self identifier", "give every Page a Self identifier");
 	return {
 		id,
 		appliedMaster: attribute(element, "AppliedMaster"),
-		stories: []
+		stories: [],
+		side: "single"
 	};
 }
 const IDENTITY = [
@@ -140,12 +85,19 @@ function pageArea(element) {
 		apply(matrix, [left, bottom])
 	];
 }
-function frameCenter(element, matrix) {
-	const anchors = elements(element).map((candidate) => attribute(candidate, "Anchor")).filter((value) => value !== void 0).map((value) => value.trim().split(/\s+/).map(Number)).filter((value) => value.length === 2 && value.every(Number.isFinite)).map((point) => apply(matrix, point));
-	if (anchors.length === 0) return void 0;
-	const xs = anchors.map(([x]) => x);
-	const ys = anchors.map(([, y]) => y);
-	return [(Math.min(...xs) + Math.max(...xs)) / 2, (Math.min(...ys) + Math.max(...ys)) / 2];
+function bounds(points) {
+	if (points.length === 0) return void 0;
+	const xs = points.map(([x]) => x);
+	const ys = points.map(([, y]) => y);
+	return {
+		left: Math.min(...xs),
+		top: Math.min(...ys),
+		right: Math.max(...xs),
+		bottom: Math.max(...ys)
+	};
+}
+function frameBounds(element, matrix) {
+	return bounds(elements(element).map((candidate) => attribute(candidate, "Anchor")).filter((value) => value !== void 0).map((value) => value.trim().split(/\s+/).map(Number)).filter((value) => value.length === 2 && value.every(Number.isFinite)).map((point) => apply(matrix, point)));
 }
 function contains(area, [x, y]) {
 	let inside = false;
@@ -157,7 +109,22 @@ function contains(area, [x, y]) {
 	}
 	return inside;
 }
-function spreadFrames(spread) {
+function framePlacement(element, matrix, location) {
+	const story = attribute(element, "ParentStory");
+	if (!story) return void 0;
+	const preference = framePreference(element, location);
+	const box = frameBounds(element, matrix);
+	return {
+		id: attribute(element, "Self") ?? story,
+		story,
+		...box ? {
+			bounds: box,
+			center: [(box.left + box.right) / 2, (box.top + box.bottom) / 2]
+		} : {},
+		...preference ? { preference } : {}
+	};
+}
+function spreadFrames(spread, location) {
 	const result = [];
 	const pending = [...spread.children].reverse().map((node) => ({
 		node,
@@ -170,11 +137,8 @@ function spreadFrames(spread) {
 		if (name === "Page" || name === "Spread" || name === "MasterSpread") continue;
 		const matrix = name === "Group" || name === "TextFrame" ? compose(current.matrix, transform(current.node)) : current.matrix;
 		if (name === "TextFrame") {
-			const story = attribute(current.node, "ParentStory");
-			if (story) result.push({
-				story,
-				center: frameCenter(current.node, matrix)
-			});
+			const placement = framePlacement(current.node, matrix, `${location}#TextFrame[${result.length + 1}]`);
+			if (placement) result.push(placement);
 			continue;
 		}
 		for (let index = current.node.children.length - 1; index >= 0; index -= 1) pending.push({
@@ -184,25 +148,99 @@ function spreadFrames(spread) {
 	}
 	return result;
 }
-function placeStories(element, pageElements, pages, unsupportedCounts) {
+function assignSides(pageElements, pages) {
+	if (pages.length < 2) return;
+	const order = pageElements.map((element) => {
+		const area = pageArea(element);
+		return area ? bounds(area) : void 0;
+	}).map((area, index) => ({
+		index,
+		x: area ? (area.left + area.right) / 2 : index
+	})).sort((a, b) => a.x - b.x);
+	const left = order[0];
+	const right = order.at(-1);
+	const leftPage = left ? pages[left.index] : void 0;
+	const rightPage = right ? pages[right.index] : void 0;
+	if (leftPage) leftPage.side = "left";
+	if (rightPage && right?.index !== left?.index) rightPage.side = "right";
+}
+function masterFrames(frames, pageElements, pages) {
+	const result = pages.map(() => []);
+	const areas = pageElements.map((candidate) => {
+		const area = pageArea(candidate);
+		return area ? bounds(area) : void 0;
+	});
+	for (const frame of frames) {
+		const absolute = frame.bounds;
+		if (!absolute || !frame.center) continue;
+		const index = pageElements.findIndex((candidate) => {
+			const area = pageArea(candidate);
+			return area ? contains(area, frame.center) : false;
+		});
+		const area = areas[index];
+		if (index < 0 || !area) continue;
+		result[index]?.push({
+			id: frame.id,
+			story: frame.story,
+			bounds: {
+				left: absolute.left - area.left,
+				top: absolute.top - area.top,
+				width: absolute.right - absolute.left,
+				height: absolute.bottom - absolute.top
+			}
+		});
+	}
+	return result;
+}
+function masterSpread(element, pageElements, pages, placements) {
+	const frames = masterFrames(placements, pageElements, pages);
+	const prefix = attribute(element, "NamePrefix") ?? "";
+	const base = attribute(element, "BaseName") ?? attribute(element, "Name") ?? attribute(element, "Self") ?? "master";
+	const name = prefix ? `${prefix}-${base}` : base;
+	const frameIds = new Set(frames.flat().map((frame) => frame.id));
+	const unmappedItems = element.children.flatMap((child) => {
+		if (!isTag(child)) return [];
+		const type = localName(child.name);
+		if (type === "Page" || type === "Properties") return [];
+		const id = attribute(child, "Self") ?? type;
+		if (type === "TextFrame" && frameIds.has(id)) return [];
+		return [{
+			type,
+			id
+		}];
+	});
+	return {
+		id: attribute(element, "Self") ?? base,
+		name,
+		...attribute(element, "BasedOn") ? { basedOn: attribute(element, "BasedOn") } : {},
+		pages: pages.map((value, index) => ({
+			...value,
+			margin: readMargin(elements(pageElements[index], "MarginPreference")[0]),
+			frames: frames[index] ?? []
+		})),
+		unmappedItems
+	};
+}
+function placeStories(frames, pageElements, pages, report, framePreferences) {
 	const areas = pageElements.map(pageArea);
 	const frameStories = /* @__PURE__ */ new Set();
-	for (const frame of spreadFrames(element)) {
+	for (const frame of frames) {
 		frameStories.add(frame.story);
+		framePreferences.add(frame.story, frame.preference);
 		const pageIndex = frame.center ? areas.findIndex((area) => area !== void 0 && contains(area, frame.center)) : -1;
 		const target = pages[pageIndex];
 		if (target && !target.stories.includes(frame.story)) target.stories.push(frame.story);
-		else if (pageIndex < 0) unsupportedCounts.set("TextFrame off page", (unsupportedCounts.get("TextFrame off page") ?? 0) + 1);
+		else if (pageIndex < 0) report.add(report.unsupportedElements, "TextFrame off page", frame.story);
 	}
 	return frameStories;
 }
-function spreads(parts, kind, orderedNames, unsupportedCounts) {
+function spreads(parts, kind, orderedNames, report, framePreferences) {
 	const result = [];
 	const frameStories = /* @__PURE__ */ new Set();
 	const byName = new Map(parts.map((part) => [part.name, part]));
 	const named = new Set(orderedNames);
 	const unlisted = parts.filter((part) => !named.has(part.name) && part.all.some((element) => localName(element.name) === kind && attribute(element, "Self"))).length;
-	if (unlisted > 0) unsupportedCounts.set("unlisted spread part", (unsupportedCounts.get("unlisted spread part") ?? 0) + unlisted);
+	if (unlisted > 0) report.add(report.unsupportedElements, "unlisted spread part", kind, unlisted);
 	for (const name of orderedNames) {
 		const part = byName.get(name);
 		if (!part) throw refusal(`designmap.xml ${kind} src ${name} has no matching ZIP entry`, `add the named ${kind} part to the package`);
@@ -211,8 +249,10 @@ function spreads(parts, kind, orderedNames, unsupportedCounts) {
 			if (!id) continue;
 			const pageElements = elements(element, "Page");
 			const pages = pageElements.map(page);
-			for (const story of placeStories(element, pageElements, pages, unsupportedCounts)) frameStories.add(story);
-			result.push({
+			assignSides(pageElements, pages);
+			const frames = spreadFrames(element, name);
+			for (const story of placeStories(frames, pageElements, pages, report, framePreferences)) frameStories.add(story);
+			result.push(kind === "MasterSpread" ? masterSpread(element, pageElements, pages, frames) : {
 				id,
 				pages
 			});
@@ -223,31 +263,23 @@ function spreads(parts, kind, orderedNames, unsupportedCounts) {
 		frameStories
 	};
 }
-function spreadSources(document, kind) {
-	return document.all.filter((element) => localName(element.name) === kind).map((element) => attribute(element, "src")).filter((source) => source !== void 0);
-}
-function stories(parts) {
-	const result = [];
-	const seen = /* @__PURE__ */ new Set();
-	for (const part of parts) for (const element of part.all.filter((candidate) => localName(candidate.name) === "Story")) {
+function textVariables(designmap) {
+	return designmap.all.filter((element) => localName(element.name) === "TextVariable").flatMap((element) => {
 		const id = attribute(element, "Self");
-		if (!id || seen.has(id)) continue;
-		seen.add(id);
-		result.push({
+		if (!id) return [];
+		const preference = element.children.find((child) => isTag(child) && localName(child.name).endsWith("Preference"));
+		return [{
 			id,
-			part: part.name
-		});
-	}
-	return result;
+			name: attribute(element, "Name") ?? id,
+			type: attribute(element, "VariableType") ?? "unknown",
+			appliedCharacterStyle: preference ? attribute(preference, "AppliedCharacterStyle") : void 0,
+			searchStrategy: preference ? attribute(preference, "SearchStrategy") : void 0,
+			location: `designmap.xml#${id}`
+		}];
+	});
 }
-function unsupported(parts) {
-	const counts = /* @__PURE__ */ new Map();
-	for (const part of parts) for (const element of part.all) {
-		const name = localName(element.name);
-		if (MAPPED_ELEMENTS.has(name)) continue;
-		counts.set(name, (counts.get(name) ?? 0) + 1);
-	}
-	return counts;
+function spreadSources(document, kind) {
+	return document.all.filter((element) => localName(element.name) === kind).map((element) => attribute(element, "src")).filter((source) => source !== void 0);
 }
 function idmlModel(entries, limits = IDML_LIMITS) {
 	const parts = parseParts(entries, limits);
@@ -260,11 +292,12 @@ function idmlModel(entries, limits = IDML_LIMITS) {
 	const margin = parts.flatMap((part) => part.all).find((element) => localName(element.name) === "MarginPreference");
 	const binding = attribute(preference, "PageBinding") ?? attribute(document, "PageBinding") ?? "LeftToRight";
 	if (binding !== "LeftToRight" && binding !== "RightToLeft") throw refusal(`IDML PageBinding ${binding} is not supported`, "use LeftToRight or RightToLeft page binding");
-	const unsupportedCounts = unsupported(parts);
-	const spreadResult = spreads(parts, "Spread", spreadSources(designmap, "Spread"), unsupportedCounts);
-	const masterResult = spreads(parts, "MasterSpread", spreadSources(designmap, "MasterSpread"), unsupportedCounts);
+	const report = new ReportCollector();
+	collectUnsupportedElements(parts, report);
+	const framePreferences = new FramePreferenceIndex();
+	const spreadResult = spreads(parts, "Spread", spreadSources(designmap, "Spread"), report, framePreferences);
+	const masterResult = spreads(parts, "MasterSpread", spreadSources(designmap, "MasterSpread"), report, new FramePreferenceIndex());
 	const masterStoryIds = [...masterResult.frameStories].filter((story) => !spreadResult.frameStories.has(story));
-	if (masterStoryIds.length > 0) unsupportedCounts.set("master story", masterStoryIds.length);
 	return {
 		id: attribute(document, "Self") ?? "IDML document",
 		preferences: {
@@ -272,19 +305,18 @@ function idmlModel(entries, limits = IDML_LIMITS) {
 			pageHeight: numberAttribute(preference, "PageHeight"),
 			facingPages: boolAttribute(preference, "FacingPages", true),
 			binding: binding === "RightToLeft" ? "right-to-left" : "left-to-right",
-			margin: {
-				top: numberAttribute(margin, "Top", 0),
-				bottom: numberAttribute(margin, "Bottom", 0),
-				left: numberAttribute(margin, "Left", 0),
-				right: numberAttribute(margin, "Right", 0)
-			}
+			margin: readMargin(margin)
 		},
 		spreads: spreadResult.values,
 		masterSpreads: masterResult.values,
-		stories: stories(parts),
+		stories: parseStories(parts, framePreferences, report),
+		bodyFramePreferences: framePreferences.values(),
+		textVariables: textVariables(designmap),
 		masterStoryIds,
 		partsRead: parts.map((part) => part.name),
-		unsupportedElements: Object.fromEntries([...unsupportedCounts].sort(([left], [right]) => left.localeCompare(right)))
+		styles: parts.flatMap((part) => part.name.endsWith("/Styles.xml") || part.name === "Resources/Styles.xml" ? parseStyles(part.all, part.name) : []),
+		swatches: parts.flatMap((part) => part.name.endsWith("/Graphic.xml") || part.name === "Resources/Graphic.xml" ? parseSwatches(part.all) : []),
+		report: report.data()
 	};
 }
 //#endregion

package/dist/parse-parts.js

@@ -0,0 +1,61 @@
+import { refusal } from "./refusal.js";
+import { isTag } from "domhandler";
+import { Parser, parseDocument } from "htmlparser2";
+//#region src/parse-parts.ts
+function allElements(root) {
+	const found = [];
+	const pending = [root];
+	while (pending.length > 0) {
+		const node = pending.pop();
+		if (!node) continue;
+		if (isTag(node)) found.push(node);
+		if ("children" in node) for (const child of [...node.children].reverse()) pending.push(child);
+	}
+	return found;
+}
+function checkDepth(source, part, limit) {
+	let depth = 0;
+	new Parser({
+		onopentag() {
+			depth += 1;
+			if (depth > limit) throw refusal(`IDML XML part ${part} exceeds the ${limit} level XML depth limit`, `reduce its nesting to ${limit} levels or fewer`);
+		},
+		onclosetag() {
+			depth -= 1;
+		}
+	}, {
+		xmlMode: true,
+		recognizeSelfClosing: true
+	}).end(source);
+}
+function parseParts(entries, limits) {
+	const decoder = new TextDecoder("utf-8", { fatal: true });
+	return entries.filter((entry) => entry.name.toLowerCase().endsWith(".xml")).map((entry) => {
+		let source;
+		try {
+			source = decoder.decode(entry.bytes);
+		} catch {
+			throw refusal(`IDML XML part ${entry.name} is not valid UTF-8`, "export that XML part as UTF-8");
+		}
+		let document;
+		try {
+			checkDepth(source, entry.name, limits.xmlDepth);
+			document = parseDocument(source, {
+				xmlMode: true,
+				recognizeSelfClosing: true
+			});
+		} catch (error) {
+			if (error instanceof Error && error.message.includes("XML depth limit")) throw error;
+			throw refusal(`IDML XML part ${entry.name} could not be parsed: ${String(error)}`, "export well-formed XML");
+		}
+		const all = allElements(document);
+		if (all.length === 0) throw refusal(`IDML XML part ${entry.name} has no root element`, "export a non-empty well-formed XML part");
+		return {
+			name: entry.name,
+			document,
+			all
+		};
+	});
+}
+//#endregion
+export { parseParts };

package/dist/report.d.ts

@@ -0,0 +1,24 @@
+//#region src/report.d.ts
+export interface IdmlFontUse {
+  appliedFont: string;
+  fontStyle?: string;
+  locations: string[];
+}
+export interface IdmlMixedMasterChapter {
+  chapter: string;
+  side: 'recto' | 'verso';
+  masters: string[];
+  chosen: string;
+}
+export interface IdmlReportData {
+  unsupportedElements: Record<string, number>;
+  unsupportedStyleProperties: Record<string, number>;
+  unsupportedOverrideProperties: Record<string, number>;
+  unsupportedSpecialCharacters: Record<string, number>;
+  unsupportedLanguages: Record<string, number>;
+  spotColors: Record<string, number>;
+  locations: Record<string, string[]>;
+  fonts: IdmlFontUse[];
+  mixedMasterChapters: IdmlMixedMasterChapter[];
+}
+//#endregion

package/dist/report.js

@@ -0,0 +1,78 @@
+//#region src/report.ts
+const BUCKET_NAMES = {
+	unsupportedElements: "element",
+	unsupportedStyleProperties: "style",
+	unsupportedOverrideProperties: "override",
+	unsupportedSpecialCharacters: "special",
+	unsupportedLanguages: "language",
+	spotColors: "spot"
+};
+var ReportCollector = class {
+	locations = /* @__PURE__ */ new Map();
+	fonts = /* @__PURE__ */ new Map();
+	mixedMasterChapters;
+	buckets = Object.fromEntries(Object.keys(BUCKET_NAMES).map((name) => [name, /* @__PURE__ */ new Map()]));
+	get unsupportedElements() {
+		return this.buckets.unsupportedElements;
+	}
+	get unsupportedStyleProperties() {
+		return this.buckets.unsupportedStyleProperties;
+	}
+	get unsupportedOverrideProperties() {
+		return this.buckets.unsupportedOverrideProperties;
+	}
+	get unsupportedSpecialCharacters() {
+		return this.buckets.unsupportedSpecialCharacters;
+	}
+	get unsupportedLanguages() {
+		return this.buckets.unsupportedLanguages;
+	}
+	get spotColors() {
+		return this.buckets.spotColors;
+	}
+	constructor(seed) {
+		this.mixedMasterChapters = [...seed?.mixedMasterChapters ?? []];
+		for (const name of Object.keys(BUCKET_NAMES)) for (const [key, count] of Object.entries(seed?.[name] ?? {})) this.buckets[name].set(key, count);
+		for (const [key, locations] of Object.entries(seed?.locations ?? {})) this.locations.set(key, [...locations]);
+		for (const font of seed?.fonts ?? []) this.font(font.appliedFont, font.fontStyle, font.locations[0] ?? "Resources/Styles.xml");
+	}
+	add(bucket, name, location, count = 1) {
+		bucket.set(name, (bucket.get(name) ?? 0) + count);
+		const key = `${this.bucketName(bucket)}:${name}`;
+		const values = this.locations.get(key) ?? [];
+		if (values.length < 5 && !values.includes(location)) values.push(location);
+		this.locations.set(key, values);
+	}
+	addOnce(bucket, name, location) {
+		const key = `${this.bucketName(bucket)}:${name}`;
+		if (this.locations.get(key)?.includes(location)) return;
+		this.add(bucket, name, location);
+	}
+	font(appliedFont, fontStyle, location) {
+		if (!appliedFont) return;
+		const key = `${appliedFont}\u0000${fontStyle ?? ""}`;
+		const found = this.fonts.get(key) ?? {
+			appliedFont,
+			...fontStyle ? { fontStyle } : {},
+			locations: []
+		};
+		if (found.locations.length < 5 && !found.locations.includes(location)) found.locations.push(location);
+		this.fonts.set(key, found);
+	}
+	data() {
+		const record = (values) => Object.fromEntries([...values].sort(([a], [b]) => a.localeCompare(b)));
+		return {
+			...Object.fromEntries(Object.keys(BUCKET_NAMES).map((name) => [name, record(this.buckets[name])])),
+			locations: Object.fromEntries([...this.locations].sort(([a], [b]) => a.localeCompare(b))),
+			fonts: [...this.fonts.values()],
+			mixedMasterChapters: [...this.mixedMasterChapters]
+		};
+	}
+	bucketName(bucket) {
+		const found = Object.keys(BUCKET_NAMES).find((name) => this.buckets[name] === bucket);
+		if (!found) throw new Error("Report bucket is not registered.");
+		return BUCKET_NAMES[found];
+	}
+};
+//#endregion
+export { ReportCollector };