@segnavia/idml 0.0.0-stage → 0.29.0

package/dist/stories.js

@@ -0,0 +1,141 @@
+import { resolveDirection } from "@segnavia/format";
+import { BOOK_COLUMN_MAX, BOOK_COLUMN_MIN } from "@segnavia/html";
+import serialize from "dom-serializer";
+import { Element, Text } from "domhandler";
+//#region src/stories.ts
+const OMITTED = /* @__PURE__ */ new Set([
+	"TextFrame",
+	"Rectangle",
+	"Group",
+	"Polygon",
+	"Table",
+	"Footnote",
+	"Note",
+	"TextVariableInstance"
+]);
+const WRAPPERS = /* @__PURE__ */ new Set([
+	"HyperlinkTextSource",
+	"XMLElement",
+	"Change"
+]);
+function classes(...values) {
+	return values.filter(Boolean).join(" ") || void 0;
+}
+function rangeAttributes(node) {
+	if (!node) return {};
+	const result = { ...node.attributes };
+	const holder = node.children.find((child) => child.name === "Properties");
+	for (const child of holder?.children ?? []) if (child.text) result[child.name] = child.text.trim();
+	return result;
+}
+function tokens(root, report) {
+	const result = [];
+	const terminal = (node, character) => {
+		if (node.name === "Content") result.push({
+			kind: "text",
+			text: node.text ?? "",
+			character,
+			location: node.location
+		});
+		else if (node.name === "Br") result.push({
+			kind: "paragraph",
+			location: node.location
+		});
+		else if (node.name === "#processing-instruction") report.add(report.unsupportedSpecialCharacters, node.text ?? "processing instruction", node.location);
+		else if (OMITTED.has(node.name)) report.add(report.unsupportedElements, node.name, node.location);
+		else if (node.name === "Properties") return true;
+		else if (node.name === "Change" && node.attributes.ChangeType !== void 0 && !node.attributes.ChangeType.includes("Inserted")) report.add(report.unsupportedElements, "Change", node.location);
+		else return false;
+		return true;
+	};
+	const walk = (node, character) => {
+		if (terminal(node, character)) return;
+		const nextCharacter = node.name === "CharacterStyleRange" ? node : character;
+		if (WRAPPERS.has(node.name)) report.add(report.unsupportedElements, node.name, node.location);
+		else if (![
+			"Story",
+			"ParagraphStyleRange",
+			"CharacterStyleRange"
+		].includes(node.name)) report.add(report.unsupportedElements, node.name, node.location);
+		for (const child of node.children) walk(child, nextCharacter);
+	};
+	walk(root);
+	return result;
+}
+function contentNodes(token, styles, direction) {
+	const character = token.character;
+	const characterAttributes = rangeAttributes(character);
+	const characterStyle = characterAttributes.AppliedCharacterStyle;
+	const characterBase = styles.flattened(characterStyle, "character");
+	const styleClass = styles.styleClass(characterStyle, "character");
+	const localClass = styles.overrideClass(characterAttributes, characterBase, direction, character?.location ?? token.location);
+	const nodes = textNodes(token.text ?? "");
+	const classValue = classes(styleClass, localClass);
+	return classValue ? [new Element("span", { class: classValue }, nodes)] : nodes;
+}
+function textNodes(value) {
+	const pieces = value.split("\u2028");
+	const result = [];
+	for (const [index, piece] of pieces.entries()) {
+		if (piece) result.push(new Text(piece));
+		if (index < pieces.length - 1) result.push(new Element("br", {}, []));
+	}
+	return result;
+}
+function paragraphNode(paragraph, paragraphTokens, styles, report, bookDirection, bookLanguage, storyDirection, frame) {
+	const attributes = rangeAttributes(paragraph);
+	const styleId = attributes.AppliedParagraphStyle;
+	const flattened = styles.flattened(styleId, "paragraph");
+	const rawText = paragraphTokens.filter((token) => token.kind === "text").map((token) => token.text ?? "").join("");
+	const resolvedDirection = styles.paragraphDirection(attributes) ?? styles.paragraphDirection(flattened) ?? storyDirection ?? resolveDirection(void 0, void 0, rawText);
+	const languageName = attributes.AppliedLanguage ?? flattened.AppliedLanguage;
+	const language = styles.language(languageName, paragraph.location);
+	const paragraphClass = styles.styleClass(styleId, "paragraph");
+	const overrideClass = styles.overrideClass(attributes, flattened, resolvedDirection, paragraph.location, styles.paragraphStyleDirection(flattened));
+	const htmlAttributes = {};
+	const className = classes(paragraphClass, overrideClass);
+	if (className) htmlAttributes.class = className;
+	if (resolvedDirection !== bookDirection) htmlAttributes.dir = resolvedDirection;
+	if (language && language !== bookLanguage) htmlAttributes.lang = language;
+	const span = attributes.SpanColumnType ?? flattened.SpanColumnType;
+	if (frame && frame.columns >= 2 && span === "SingleColumn") {
+		if (Number.isInteger(frame.columns) && frame.columns >= BOOK_COLUMN_MIN && frame.columns <= BOOK_COLUMN_MAX) htmlAttributes["data-columns"] = String(frame.columns);
+		else report.addOnce(report.unsupportedElements, `TextColumnCount:${frame.columns}`, frame.location ?? paragraph.location);
+	}
+	if (span === "SplitColumns") report.add(report.unsupportedStyleProperties, "SpanColumnType:SplitColumns", paragraph.location);
+	const children = [];
+	for (const token of paragraphTokens) {
+		if (token.kind !== "text") continue;
+		children.push(...contentNodes(token, styles, resolvedDirection));
+	}
+	if (children.length === 0) children.push(new Element("br", {}, []));
+	return new Element("p", htmlAttributes, children);
+}
+function storyHtml(story, styles, report, bookDirection, bookLanguage) {
+	if (!story.root) return { html: serialize(new Element("p", {}, [new Element("br", {}, [])]), {
+		xmlMode: false,
+		encodeEntities: "utf8"
+	}) };
+	const paragraphs = [];
+	for (const paragraph of story.root.children.filter((node) => node.name === "ParagraphStyleRange")) {
+		const all = tokens(paragraph, report);
+		let current = [];
+		const flush = () => {
+			paragraphs.push(paragraphNode(paragraph, current, styles, report, bookDirection, bookLanguage, story.direction, story.frame));
+			current = [];
+		};
+		for (const token of all) if (token.kind === "paragraph") flush();
+		else current.push(token);
+		if (current.length > 0 || all.length === 0 || all.at(-1)?.kind !== "paragraph") flush();
+	}
+	if (paragraphs.length === 0) paragraphs.push(new Element("p", {}, [new Element("br", {}, [])]));
+	return {
+		html: serialize(paragraphs, {
+			xmlMode: false,
+			encodeEntities: "utf8"
+		}),
+		...story.frame ? { gutter: story.frame.gutter } : {}
+	};
+}
+//#endregion
+export { storyHtml };

package/dist/story-model.js

@@ -0,0 +1,53 @@
+import { activeIdmlValue } from "./style-property-report.js";
+import { idmlDirection, localName } from "./xml.js";
+import { isTag } from "domhandler";
+//#region src/story-model.ts
+function textNode(node, part, path) {
+	const children = [];
+	let childIndex = 0;
+	for (const child of node.children) {
+		childIndex += 1;
+		if (isTag(child)) children.push(textNode(child, part, `${path}/${localName(child.name)}[${childIndex}]`));
+		else if (child.type === "directive") children.push({
+			name: "#processing-instruction",
+			attributes: {},
+			text: child.data,
+			children: [],
+			location: `${part}${path}#pi${childIndex}`
+		});
+	}
+	const directText = node.children.filter((child) => child.type === "text").map((child) => child.data).join("");
+	return {
+		name: localName(node.name),
+		attributes: { ...node.attribs },
+		...directText ? { text: directText } : {},
+		children,
+		location: `${part}${path}`
+	};
+}
+function storyDirection(element, part, id, report) {
+	const preference = element.children.find((child) => isTag(child) && localName(child.name) === "StoryPreference");
+	for (const [name, value] of Object.entries(preference?.attribs ?? {})) if (name !== "StoryDirection" && activeIdmlValue(value)) report.add(report.unsupportedElements, `StoryPreference:${name}`, `${part}#${id}`);
+	return idmlDirection(preference?.attribs.StoryDirection ?? element.attribs.StoryDirection);
+}
+function parseStories(parts, framePreferences, report) {
+	const result = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const part of parts) for (const element of part.all.filter((candidate) => localName(candidate.name) === "Story")) {
+		const id = element.attribs.Self;
+		if (!id || seen.has(id)) continue;
+		seen.add(id);
+		const direction = storyDirection(element, part.name, id, report);
+		const frame = framePreferences.preferred(id);
+		result.push({
+			id,
+			part: part.name,
+			root: textNode(element, part.name, `/Story[@Self=${id}]`),
+			...direction ? { direction } : {},
+			...frame ? { frame } : {}
+		});
+	}
+	return result;
+}
+//#endregion
+export { parseStories };

package/dist/style-mappings.js

@@ -0,0 +1,52 @@
+//#region src/style-mappings.ts
+const css = (name) => ({
+	kind: "css",
+	css: name
+});
+const nonFormatting = { kind: "non-formatting" };
+const STYLE_PROPERTY_MAPPINGS = {
+	PointSize: css("font-size"),
+	Leading: css("line-height"),
+	AutoLeading: css("line-height"),
+	Tracking: css("letter-spacing"),
+	SpaceBefore: css("margin-block-start"),
+	SpaceAfter: css("margin-block-end"),
+	FirstLineIndent: css("text-indent"),
+	Capitalization: css("capitalization"),
+	Underline: css("text-decoration-line"),
+	FillColor: css("color"),
+	LeftIndent: css("padding-inline"),
+	RightIndent: css("padding-inline"),
+	Justification: css("text-align"),
+	KeepWithNext: css("keeps"),
+	KeepLinesTogether: css("keeps"),
+	KeepAllLinesTogether: css("keeps"),
+	KeepFirstLines: css("keeps"),
+	KeepLastLines: css("keeps"),
+	StartParagraph: css("starts"),
+	ParagraphDirection: { kind: "direction" },
+	AppliedLanguage: { kind: "language" },
+	AppliedFont: { kind: "font" },
+	FontStyle: { kind: "font" },
+	SpanColumnType: { kind: "columns" },
+	Self: nonFormatting,
+	Name: nonFormatting,
+	BasedOn: nonFormatting,
+	AppliedParagraphStyle: nonFormatting,
+	AppliedCharacterStyle: nonFormatting,
+	EmitCss: nonFormatting,
+	StyleUniqueId: nonFormatting,
+	KeyboardShortcut: nonFormatting,
+	ExtendedKeyboardShortcut: nonFormatting,
+	Imported: nonFormatting,
+	PreviewColor: nonFormatting,
+	IncludeClass: nonFormatting,
+	EpubAriaRole: nonFormatting,
+	SplitDocument: nonFormatting,
+	NextStyle: nonFormatting
+};
+function stylePropertyMapping(name) {
+	return STYLE_PROPERTY_MAPPINGS[name];
+}
+//#endregion
+export { STYLE_PROPERTY_MAPPINGS, stylePropertyMapping };

package/dist/style-property-report.js

@@ -0,0 +1,236 @@
+import { stylePropertyMapping } from "./style-mappings.js";
+//#region src/style-property-report.ts
+const INDESIGN_PROPERTY_DEFAULTS = {
+	HorizontalScale: [100],
+	VerticalScale: [100],
+	Skew: [0],
+	BaselineShift: [0],
+	DesiredWordSpacing: [100],
+	MinimumWordSpacing: [80],
+	MaximumWordSpacing: [133],
+	DesiredLetterSpacing: [0],
+	MinimumLetterSpacing: [0],
+	MaximumLetterSpacing: [0],
+	DesiredGlyphScaling: [100],
+	MinimumGlyphScaling: [100],
+	MaximumGlyphScaling: [100],
+	FillTint: [-1, 100],
+	KerningMethod: ["$ID/Metrics"],
+	Ligatures: [true],
+	OTFContextualAlternate: [true],
+	OTFMark: [true],
+	OTFFigureStyle: ["Default"],
+	OTFLocale: [true],
+	PositionalForm: ["None"],
+	CharacterAlignment: ["AlignEmCenter"],
+	DigitsType: ["DefaultDigits"],
+	CharacterDirection: ["DefaultDirection"],
+	DiacriticPosition: ["OpentypePositionFromBaseline"],
+	XOffsetDiacritic: [0],
+	YOffsetDiacritic: [0],
+	Kashidas: ["DefaultKashidas"],
+	ParagraphKashidaWidth: [2],
+	ParagraphJustification: ["DefaultJustification"],
+	GlyphForm: ["None"],
+	MiterLimit: [4],
+	EndJoin: ["MiterEndJoin"],
+	NoBreak: [false],
+	SingleWordJustification: ["LeftAlign"],
+	"OTF*": [false]
+};
+const JUSTIFICATION_SETTINGS = /* @__PURE__ */ new Set([
+	"DesiredWordSpacing",
+	"MinimumWordSpacing",
+	"MaximumWordSpacing",
+	"DesiredLetterSpacing",
+	"MinimumLetterSpacing",
+	"MaximumLetterSpacing",
+	"DesiredGlyphScaling",
+	"MinimumGlyphScaling",
+	"MaximumGlyphScaling",
+	"SingleWordJustification"
+]);
+const CJK_PREFIXES = [
+	"Kinsoku",
+	"Shatai",
+	"CjkGrid",
+	"Grid",
+	"AutoTcy"
+];
+const CJK_PROPERTIES = /* @__PURE__ */ new Set([
+	"Mojikumi",
+	"Jidori",
+	"Rensuuji",
+	"BunriKinshi",
+	"Tsume",
+	"LeadingAki",
+	"TrailingAki",
+	"Gyoudori",
+	"ParagraphGyoudori",
+	"KeyboardDirection",
+	"TreatIdeographicSpaceAsSpace",
+	"CharacterRotation",
+	"RotateSingleByteCharacters"
+]);
+function truthy(value) {
+	return value?.trim().toLowerCase() === "true";
+}
+function notNone(value) {
+	const normalized = value?.trim().toLowerCase();
+	return Boolean(normalized && ![
+		"none",
+		"$id/none",
+		"nolist"
+	].includes(normalized));
+}
+const SWITCHED_GROUPS = [
+	{
+		matches: (name) => name.startsWith("RuleAbove"),
+		enabled: (values) => truthy(values.RuleAbove),
+		reportAs: "RuleAbove"
+	},
+	{
+		matches: (name) => name.startsWith("RuleBelow"),
+		enabled: (values) => truthy(values.RuleBelow),
+		reportAs: "RuleBelow"
+	},
+	{
+		matches: (name) => name.startsWith("ParagraphBorder"),
+		enabled: (values) => truthy(values.ParagraphBorderOn),
+		reportAs: "ParagraphBorderOn"
+	},
+	{
+		matches: (name) => name.startsWith("ParagraphShading"),
+		enabled: (values) => truthy(values.ParagraphShadingOn),
+		reportAs: "ParagraphShadingOn"
+	},
+	{
+		matches: (name) => name.startsWith("Underline"),
+		enabled: (values) => truthy(values.Underline) || values.Underline === "Underline",
+		reportAs: "Underline"
+	},
+	{
+		matches: (name) => name.startsWith("StrikeThrough") || name.startsWith("StrikeThru"),
+		enabled: (values) => truthy(values.StrikeThru ?? values.StrikeThrough),
+		reportAs: "StrikeThru"
+	},
+	{
+		matches: (name) => name.startsWith("Bullets") || name.startsWith("Numbering"),
+		enabled: (values) => notNone(values.BulletsAndNumberingListType),
+		reportAs: "BulletsAndNumberingListType"
+	},
+	{
+		matches: (name) => name.startsWith("DropCap") || name === "DropcapDetail",
+		enabled: (values) => Number(values.DropCapLines) > 0,
+		reportAs: "DropCapLines"
+	},
+	{
+		matches: (name) => name.startsWith("Kenten"),
+		enabled: (values) => notNone(values.KentenKind),
+		reportAs: "KentenKind"
+	},
+	{
+		matches: (name) => name.startsWith("Ruby"),
+		enabled: (values) => truthy(values.RubyFlag),
+		reportAs: "RubyFlag"
+	},
+	{
+		matches: (name) => name.startsWith("Warichu"),
+		enabled: (values) => truthy(values.Warichu),
+		reportAs: "Warichu"
+	},
+	{
+		matches: (name) => name.startsWith("Tatechuyoko"),
+		enabled: (values) => truthy(values.Tatechuyoko),
+		reportAs: "Tatechuyoko"
+	},
+	{
+		matches: (name) => name.startsWith("Gradient"),
+		enabled: (values) => [values.FillColor, values.StrokeColor].some((value) => value?.toLowerCase().includes("gradient")),
+		reportAs: "Gradient"
+	},
+	{
+		matches: (name) => name.startsWith("Stroke"),
+		enabled: (values) => Number(values.StrokeWeight) > 0 && notNone(values.StrokeColor),
+		reportAs: "Stroke"
+	}
+];
+function equalsDefault(name, value) {
+	const defaults = INDESIGN_PROPERTY_DEFAULTS[name] ?? (name.startsWith("OTF") ? INDESIGN_PROPERTY_DEFAULTS["OTF*"] : void 0);
+	if (!defaults) return false;
+	const normalized = value.trim().toLowerCase();
+	return defaults.some((candidate) => String(candidate).toLowerCase() === normalized);
+}
+function hasEntries(value) {
+	const normalized = value?.trim().toLowerCase();
+	return Boolean(normalized && ![
+		"false",
+		"0",
+		"none",
+		"$id/none",
+		"[]"
+	].includes(normalized));
+}
+function isCjkLanguage(value) {
+	return /(?:chinese|japanese|korean|^zh(?:-|$)|^ja(?:-|$)|^ko(?:-|$))/i.test(value ?? "");
+}
+function activeIdmlValue(value) {
+	const normalized = value.trim().toLowerCase();
+	if (!normalized || [
+		"false",
+		"none",
+		"nothing",
+		"$id/none",
+		"$id/nothing",
+		"n",
+		"no",
+		"off"
+	].includes(normalized)) return false;
+	const numbers = normalized.split(/[\s,]+/).map(Number);
+	return numbers.length === 0 || !numbers.every((number) => Number.isFinite(number) && number === 0);
+}
+function isHyphenationProperty(name) {
+	return name.startsWith("Hyphenat") || name === "HyphenWeight" || name === "ProviderHyphenationStyle";
+}
+function groupedProperties(names, resolved) {
+	const output = [];
+	if (names.some(isHyphenationProperty) && truthy(resolved.Hyphenation)) output.push("Hyphenation");
+	const changedJustification = [...JUSTIFICATION_SETTINGS].some((name) => {
+		const value = resolved[name];
+		return value !== void 0 && !equalsDefault(name, value);
+	});
+	if (names.some((name) => JUSTIFICATION_SETTINGS.has(name)) && changedJustification) output.push("JustificationSettings");
+	return output;
+}
+function reportableProperty(name, value, resolved, root) {
+	if (stylePropertyMapping(name)) return void 0;
+	if (isHyphenationProperty(name) || JUSTIFICATION_SETTINGS.has(name)) return void 0;
+	if ([
+		"EmptyGrepStyles",
+		"EmptyNestedStyles",
+		"EmptyLineStyles"
+	].includes(name)) return void 0;
+	if ([
+		"AllGREPStyles",
+		"AllNestedStyles",
+		"AllLineStyles"
+	].includes(name) || name === "TabList") return hasEntries(value) ? name : void 0;
+	const switched = SWITCHED_GROUPS.find((group) => group.matches(name));
+	if (switched) return switched.enabled(resolved) ? switched.reportAs : void 0;
+	if ((CJK_PREFIXES.some((prefix) => name.startsWith(prefix)) || CJK_PROPERTIES.has(name)) && !isCjkLanguage(resolved.AppliedLanguage)) return void 0;
+	if (equalsDefault(name, value)) return void 0;
+	return !root || activeIdmlValue(value) ? name : void 0;
+}
+function reportableStyleProperties(source, resolved, root = false) {
+	const names = Object.keys(source);
+	const output = new Set(groupedProperties(names, resolved));
+	for (const name of names) {
+		const value = source[name];
+		if (value === void 0) continue;
+		const reported = reportableProperty(name, value, resolved, root);
+		if (reported) output.add(reported);
+	}
+	return [...output];
+}
+//#endregion
+export { INDESIGN_PROPERTY_DEFAULTS, activeIdmlValue, reportableStyleProperties };