@segnavia/idml 0.28.0 → 0.30.0

package/dist/styles.js

@@ -0,0 +1,285 @@
+import { idmlDirection, localName } from "./xml.js";
+import { stylePropertyMapping } from "./style-mappings.js";
+import { reportableStyleProperties } from "./style-property-report.js";
+import { isTag } from "domhandler";
+//#region src/styles.ts
+const PARAGRAPH_ROOT = "$ID/[No paragraph style]";
+const CHARACTER_ROOT = "$ID/[No character style]";
+function text(element) {
+	return element.children.map((child) => "data" in child ? child.data : isTag(child) ? text(child) : "").join("").trim();
+}
+function properties(element) {
+	const result = { ...element.attribs };
+	const holder = element.children.find((child) => isTag(child) && localName(child.name) === "Properties");
+	for (const child of holder?.children ?? []) {
+		if (!isTag(child)) continue;
+		const value = text(child);
+		if (value || child.children.some(isTag)) result[localName(child.name)] = value || "[entry]";
+	}
+	return result;
+}
+function parseStyles(roots, part) {
+	const result = [];
+	for (const kind of ["ParagraphStyle", "CharacterStyle"]) for (const element of roots.filter((candidate) => localName(candidate.name) === kind)) {
+		const values = properties(element);
+		const id = values.Self;
+		if (!id) continue;
+		result.push({
+			id,
+			name: values.Name ?? id.split("/").at(-1) ?? id,
+			kind: kind === "ParagraphStyle" ? "paragraph" : "character",
+			...values.BasedOn ? { basedOn: values.BasedOn } : {},
+			properties: Object.fromEntries(Object.entries(values).filter(([name]) => ![
+				"Self",
+				"Name",
+				"BasedOn"
+			].includes(name))),
+			location: `${part}#${id}`
+		});
+	}
+	return result;
+}
+function parseSwatches(roots) {
+	const result = [];
+	for (const element of roots.filter((candidate) => localName(candidate.name) === "Color")) {
+		const id = element.attribs.Self;
+		if (!id) continue;
+		const name = element.attribs.Name ?? id;
+		const space = element.attribs.Space;
+		const values = (element.attribs.ColorValue ?? "").trim().split(/\s+/).map(Number).filter(Number.isFinite);
+		const model = element.attribs.Model === "Spot" ? "spot" : space === "RGB" ? "rgb" : space === "CMYK" ? "cmyk" : "named";
+		result.push({
+			id,
+			name,
+			model,
+			...values.length > 0 ? { values } : {}
+		});
+	}
+	return result;
+}
+function rootName(kind) {
+	return kind === "paragraph" ? PARAGRAPH_ROOT : CHARACTER_ROOT;
+}
+function slug(value) {
+	return value.normalize("NFKD").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "") || "style";
+}
+const LANGUAGES = {
+	"$ID/Hebrew": "he",
+	"$ID/English: USA": "en-US",
+	"$ID/English: UK": "en-GB",
+	"$ID/French": "fr",
+	"$ID/German": "de",
+	"$ID/Spanish": "es",
+	"$ID/Italian": "it",
+	"$ID/Arabic": "ar"
+};
+function hasCssMapping(names, css) {
+	return [...names].some((name) => {
+		const mapping = stylePropertyMapping(name);
+		return mapping?.kind === "css" && mapping.css === css;
+	});
+}
+function textDeclarations(values, mapped, output) {
+	if (mapped.has("Capitalization") && values.Capitalization === "SmallCaps") output.push("font-variant-caps:small-caps");
+	if (mapped.has("Capitalization") && values.Capitalization === "AllCaps") output.push("text-transform:uppercase");
+	if (mapped.has("Underline") && (values.Underline === "true" || values.Underline === "Underline")) output.push("text-decoration-line:underline");
+}
+var StyleMapper = class {
+	swatches;
+	report;
+	bookDirection;
+	byId;
+	classes = /* @__PURE__ */ new Map();
+	used = /* @__PURE__ */ new Set();
+	overrides = /* @__PURE__ */ new Map();
+	reportedStyleProperties = /* @__PURE__ */ new Set();
+	constructor(styles, swatches, report, bookDirection) {
+		this.swatches = swatches;
+		this.report = report;
+		this.bookDirection = bookDirection;
+		this.byId = new Map(styles.map((style) => [style.id, style]));
+		const taken = /* @__PURE__ */ new Set();
+		for (const style of styles) {
+			const base = `${style.kind === "paragraph" ? "idml-p-" : "idml-c-"}${slug(style.name)}`;
+			let candidate = base;
+			let suffix = 2;
+			while (taken.has(candidate)) candidate = `${base}-${suffix++}`;
+			taken.add(candidate);
+			this.classes.set(style.id, candidate);
+		}
+	}
+	flattened(id, kind) {
+		return Object.assign({}, ...this.styleChain(id, kind).map((style) => style.properties));
+	}
+	styleChain(id, kind) {
+		const root = this.rootStyle(kind);
+		const chain = [];
+		const seen = /* @__PURE__ */ new Set();
+		let current = this.findStyle(id, kind);
+		while (current && !seen.has(current.id)) {
+			seen.add(current.id);
+			chain.unshift(current);
+			current = this.findStyle(current.basedOn, kind);
+		}
+		if (root && !chain.includes(root)) chain.unshift(root);
+		return chain;
+	}
+	styleClass(id, _kind) {
+		if (!id || id.includes("[None]") || id.includes("[No character style]")) return void 0;
+		const style = this.findStyle(id, _kind);
+		const value = style ? this.classes.get(style.id) : void 0;
+		if (value && style) this.used.add(style.id);
+		return value;
+	}
+	overrideClass(values, base, directionValue, location, styleDirection) {
+		const changed = Object.fromEntries(Object.entries(values).filter(([name, value]) => stylePropertyMapping(name)?.kind !== "non-formatting" && value !== base[name]));
+		const resolved = {
+			...base,
+			...values
+		};
+		for (const name of reportableStyleProperties(changed, resolved)) this.report.add(this.report.unsupportedOverrideProperties, name, location);
+		if (changed.AppliedFont !== void 0 || changed.FontStyle !== void 0) this.report.font(resolved.AppliedFont, resolved.FontStyle, location);
+		const cssProperties = Object.fromEntries(Object.entries(changed).filter(([name]) => stylePropertyMapping(name)?.kind === "css"));
+		if (styleDirection && styleDirection !== directionValue) {
+			for (const name of ["LeftIndent", "RightIndent"]) cssProperties[name] = base[name] ?? "0";
+			for (const name of ["Justification"]) if (base[name] !== void 0 && cssProperties[name] === void 0) cssProperties[name] = base[name];
+		}
+		if (Object.keys(cssProperties).length === 0) return void 0;
+		const key = JSON.stringify(Object.entries(cssProperties).sort(([a], [b]) => a.localeCompare(b))) + directionValue;
+		const found = this.overrides.get(key);
+		if (found) return found.name;
+		const name = `idml-o-${this.overrides.size + 1}`;
+		this.overrides.set(key, {
+			name,
+			properties: cssProperties,
+			direction: directionValue
+		});
+		return name;
+	}
+	paragraphDirection(properties) {
+		return idmlDirection(properties.ParagraphDirection);
+	}
+	paragraphStyleDirection(properties) {
+		return this.paragraphDirection(properties) ?? this.bookDirection;
+	}
+	language(value, location) {
+		if (!value) return void 0;
+		const known = LANGUAGES[value];
+		if (!known) this.report.add(this.report.unsupportedLanguages, value, location);
+		return known;
+	}
+	rootLanguage() {
+		const root = this.rootStyle("paragraph");
+		return this.language(root?.properties.AppliedLanguage, root?.location ?? "Resources/Styles.xml");
+	}
+	css() {
+		const rules = [];
+		for (const id of this.used) {
+			const style = this.byId.get(id);
+			const name = this.classes.get(id);
+			if (!style || !name) continue;
+			const values = this.flattened(id, style.kind);
+			this.reportUnmappedStyleProperties(style);
+			this.report.font(values.AppliedFont, values.FontStyle, style.location);
+			const dir = style.kind === "paragraph" ? this.paragraphStyleDirection(values) : this.bookDirection;
+			const declarations = this.declarations(values, dir, style.location);
+			rules.push(`.${name}{${declarations}}`);
+		}
+		for (const value of this.overrides.values()) {
+			const declarations = this.declarations(value.properties, value.direction, value.name, this.report.unsupportedOverrideProperties);
+			if (declarations) rules.push(`.${value.name}{${declarations}}`);
+		}
+		return rules.join("");
+	}
+	declarations(values, dir, location, unsupported = this.report.unsupportedStyleProperties) {
+		const output = [];
+		const mapped = new Set(Object.keys(values).filter((name) => stylePropertyMapping(name)?.kind === "css"));
+		const pt = (name, property) => {
+			if (!mapped.has(name)) return;
+			const value = Number(values[name]);
+			if (Number.isFinite(value)) output.push(`${property}:${value}pt`);
+		};
+		pt("PointSize", "font-size");
+		if (mapped.has("Leading") && values.Leading === "Auto") output.push(`line-height:${(Number(values.AutoLeading) || 120) / 100}`);
+		else pt("Leading", "line-height");
+		const tracking = Number(values.Tracking);
+		if (mapped.has("Tracking") && Number.isFinite(tracking)) output.push(`letter-spacing:${tracking / 1e3}em`);
+		pt("SpaceBefore", "margin-block-start");
+		pt("SpaceAfter", "margin-block-end");
+		pt("FirstLineIndent", "text-indent");
+		const startIndent = dir === "rtl" ? "RightIndent" : "LeftIndent";
+		const endIndent = dir === "rtl" ? "LeftIndent" : "RightIndent";
+		pt(startIndent, "padding-inline-start");
+		pt(endIndent, "padding-inline-end");
+		textDeclarations(values, mapped, output);
+		if (mapped.has("Justification")) this.justification(values.Justification, dir, output, location, unsupported);
+		if (hasCssMapping(mapped, "keeps")) this.keeps(values, output);
+		if (mapped.has("StartParagraph") && values.StartParagraph && values.StartParagraph !== "Anywhere") this.report.add(unsupported, `StartParagraph:${values.StartParagraph}`, location);
+		const color = mapped.has("FillColor") ? this.color(values.FillColor, location) : void 0;
+		if (color) output.push(`color:${color}`);
+		return output.join(";");
+	}
+	findStyle(id, kind) {
+		if (!id) return void 0;
+		const exact = this.byId.get(id);
+		if (exact?.kind === kind) return exact;
+		return [...this.byId.values()].find((style) => style.kind === kind && (style.name === id || style.id.endsWith(`/${id}`)));
+	}
+	rootStyle(kind) {
+		return [...this.byId.values()].find((style) => style.kind === kind && (style.name === rootName(kind) || style.id.endsWith(`/${rootName(kind)}`)));
+	}
+	reportUnmappedStyleProperties(style) {
+		const root = this.rootStyle(style.kind);
+		const resolved = {};
+		for (const source of this.styleChain(style.id, style.kind)) {
+			Object.assign(resolved, source.properties);
+			for (const name of reportableStyleProperties(source.properties, resolved, source === root)) {
+				const key = `${source.id}\u0000${name}`;
+				if (this.reportedStyleProperties.has(key)) continue;
+				this.reportedStyleProperties.add(key);
+				this.report.add(this.report.unsupportedStyleProperties, name, source.location);
+			}
+		}
+	}
+	justification(value, dir, output, location, bucket) {
+		if (!value) return;
+		const side = (physical) => physical === (dir === "rtl" ? "right" : "left") ? "start" : "end";
+		if (value === "LeftAlign" || value === "RightAlign") output.push(`text-align:${side(value === "LeftAlign" ? "left" : "right")}`);
+		else if (value === "CenterAlign") output.push("text-align:center");
+		else if (value === "FullyJustified") output.push("text-align:justify", "text-align-last:justify");
+		else if (value.endsWith("Justified")) {
+			output.push("text-align:justify");
+			if (value.startsWith("Left")) output.push(`text-align-last:${side("left")}`);
+			else if (value.startsWith("Right")) output.push(`text-align-last:${side("right")}`);
+			else if (value.startsWith("Center")) output.push("text-align-last:center");
+		} else if (value === "ToBindingSide" || value === "AwayFromBindingSide") this.report.add(bucket, `Justification:${value}`, location);
+	}
+	keeps(values, output) {
+		if ((Number(values.KeepWithNext) || 0) > 0) output.push("break-after:avoid");
+		if (values.KeepLinesTogether === "true" && values.KeepAllLinesTogether === "true") output.push("break-inside:avoid");
+		else if (values.KeepLinesTogether === "true") {
+			const first = Number(values.KeepFirstLines);
+			const last = Number(values.KeepLastLines);
+			if (Number.isInteger(first) && first > 0) output.push(`orphans:${first}`);
+			if (Number.isInteger(last) && last > 0) output.push(`widows:${last}`);
+		}
+	}
+	color(id, location) {
+		if (!id || id.endsWith("/None")) return void 0;
+		if (id.endsWith("/Black")) return "#000";
+		if (id.endsWith("/Paper")) return "#fff";
+		const swatch = this.swatches.find((value) => value.id === id || value.name === id);
+		if (!swatch) return void 0;
+		if (swatch.model === "spot") {
+			this.report.add(this.report.spotColors, swatch.name, location);
+			return;
+		}
+		if (swatch.model === "rgb" && swatch.values?.length === 3) return `rgb(${swatch.values.join(" ")})`;
+		if (swatch.model === "cmyk" && swatch.values?.length === 4) {
+			const [c, m, y, k] = swatch.values.map((value) => value / 100);
+			return `rgb(${Math.round(255 * (1 - c) * (1 - k))} ${Math.round(255 * (1 - m) * (1 - k))} ${Math.round(255 * (1 - y) * (1 - k))})`;
+		}
+	}
+};
+//#endregion
+export { StyleMapper, parseStyles, parseSwatches };

package/dist/types.d.ts

@@ -0,0 +1,90 @@
+//#region src/types.d.ts
+export interface IdmlTextNode {
+  name: string;
+  attributes: Record<string, string>;
+  text?: string;
+  children: IdmlTextNode[];
+  location: string;
+}
+export interface IdmlStyle {
+  id: string;
+  name: string;
+  kind: 'paragraph' | 'character';
+  basedOn?: string;
+  properties: Record<string, string>;
+  location: string;
+}
+export interface IdmlSwatch {
+  id: string;
+  name: string;
+  model: 'rgb' | 'cmyk' | 'spot' | 'named';
+  values?: number[];
+}
+export interface IdmlFramePreference {
+  columns: number;
+  gutter: number;
+  location?: string;
+}
+export interface IdmlStory {
+  id: string;
+  part: string;
+  direction?: 'ltr' | 'rtl';
+  root?: IdmlTextNode;
+  frame?: IdmlFramePreference;
+}
+export interface IdmlTextVariable {
+  id: string;
+  name: string;
+  type: string;
+  appliedCharacterStyle?: string;
+  searchStrategy?: string;
+  location: string;
+}
+export interface IdmlMargin {
+  top: number;
+  bottom: number;
+  left: number;
+  right: number;
+}
+export interface IdmlDocumentPreferences {
+  pageWidth: number;
+  pageHeight: number;
+  facingPages: boolean;
+  binding: 'left-to-right' | 'right-to-left';
+  margin: IdmlMargin;
+}
+export interface IdmlPage {
+  id: string;
+  appliedMaster?: string;
+  stories: string[];
+  side?: 'left' | 'right' | 'single';
+}
+export interface IdmlSpread {
+  id: string;
+  pages: IdmlPage[];
+}
+export interface IdmlMasterFrame {
+  id: string;
+  story: string;
+  bounds: {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+  };
+}
+export interface IdmlMasterPage extends IdmlPage {
+  margin: IdmlMargin;
+  frames: IdmlMasterFrame[];
+}
+export interface IdmlMasterSpread {
+  id: string;
+  name: string;
+  basedOn?: string;
+  pages: IdmlMasterPage[];
+  unmappedItems: {
+    type: string;
+    id: string;
+  }[];
+}
+//#endregion

package/dist/unsupported-elements.js

@@ -0,0 +1,51 @@
+import { localName } from "./xml.js";
+//#region src/unsupported-elements.ts
+const MAPPED_ELEMENTS = /* @__PURE__ */ new Set([
+	"Document",
+	"DocumentPreference",
+	"MarginPreference",
+	"MasterSpread",
+	"Spread",
+	"Page",
+	"Story",
+	"TextFrame",
+	"Group",
+	"TextFramePreference",
+	"PathGeometry",
+	"GeometryPathType",
+	"PathPointArray",
+	"PathPointType",
+	"Styles",
+	"Graphic",
+	"RootParagraphStyleGroup",
+	"ParagraphStyleGroup",
+	"RootCharacterStyleGroup",
+	"CharacterStyleGroup",
+	"ParagraphStyle",
+	"CharacterStyle",
+	"Color",
+	"TextVariable",
+	"MatchCharacterStylePreference",
+	"Properties"
+]);
+function insideMappedResource(element) {
+	let parent = element.parent;
+	while (parent && "name" in parent) {
+		const name = localName(parent.name);
+		if (name === "ParagraphStyle" || name === "CharacterStyle" || name === "Color") return true;
+		parent = parent.parent;
+	}
+	return false;
+}
+function collectUnsupportedElements(parts, report) {
+	for (const part of parts) {
+		if (part.name.startsWith("Stories/")) continue;
+		for (const element of part.all) {
+			const name = localName(element.name);
+			if (!MAPPED_ELEMENTS.has(name) && !insideMappedResource(element)) report.add(report.unsupportedElements, name, part.name);
+		}
+	}
+	return report.unsupportedElements;
+}
+//#endregion
+export { collectUnsupportedElements };

package/dist/variables.js

@@ -0,0 +1,21 @@
+//#region src/variables.ts
+const MATCH_CHARACTER_STYLE = "MatchCharacterStyleType";
+function matchVariables(variables, report) {
+	const result = [];
+	const matchedStyles = /* @__PURE__ */ new Set();
+	for (const variable of variables) {
+		if (variable.type !== MATCH_CHARACTER_STYLE || !variable.appliedCharacterStyle) {
+			report.add(report.unsupportedElements, `TextVariable:${variable.name}`, variable.location);
+			continue;
+		}
+		if (matchedStyles.has(variable.appliedCharacterStyle)) {
+			report.add(report.unsupportedElements, `TextVariable duplicate style:${variable.name}`, variable.location);
+			continue;
+		}
+		matchedStyles.add(variable.appliedCharacterStyle);
+		result.push(variable);
+	}
+	return result;
+}
+//#endregion
+export { matchVariables };

package/dist/xml.js

@@ -0,0 +1,18 @@
+import { refusal } from "./refusal.js";
+//#region src/xml.ts
+function localName(name) {
+	return name.includes(":") ? name.split(":").at(-1) ?? name : name;
+}
+function numberAttribute(element, name, fallback) {
+	const raw = element?.attribs[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 idmlDirection(value) {
+	const normalized = value?.toLowerCase();
+	if (normalized?.includes("righttoleft")) return "rtl";
+	if (normalized?.includes("lefttoright")) return "ltr";
+}
+//#endregion
+export { idmlDirection, localName, numberAttribute };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@segnavia/idml",
-  "version": "0.28.0",
+  "version": "0.30.0",
   "type": "module",
   "license": "MIT",
   "repository": {
@@ -26,8 +26,8 @@
     }
   },
   "dependencies": {
-    "@segnavia/format": "0.28.0",
-    "@segnavia/html": "0.28.0",
+    "@segnavia/format": "0.30.0",
+    "@segnavia/html": "0.30.0",
     "dom-serializer": "^2.0.0",
     "domhandler": "^5.0.3",
     "htmlparser2": "^10.0.0"