document-schema 4.2.0 → 4.3.0

package/dist/factor-styles.js

@@ -0,0 +1,432 @@
+import { canonicalKey } from "./canonicalise.js";
+import { decomposeDrawPage, decomposeSection, decomposeSheet, decomposeSlide } from "./decompose.js";
+import { flattenPackage } from "./flatten.js";
+//#region src/factor-styles.ts
+const PARAGRAPH_STYLE_KEYS = [
+	"alignment",
+	"spacingBeforePt",
+	"spacingAfterPt",
+	"lineSpacing",
+	"indentLeftPt",
+	"indentFirstLinePt"
+];
+const RUN_STYLE_KEYS = [
+	"bold",
+	"italic",
+	"underline",
+	"strike",
+	"fontFamily",
+	"sizePt",
+	"color"
+];
+function isShapeGroupWrapper(wrapper) {
+	return !("kind" in wrapper.node);
+}
+function isAnchorGroupWrapper(wrapper) {
+	return "kind" in wrapper.node && wrapper.node.kind === "paragraph";
+}
+function isSlideGroupWrapper(wrapper) {
+	return "kind" in wrapper.node && wrapper.node.kind === "slide";
+}
+function isDrawPageGroupWrapper(wrapper) {
+	return "kind" in wrapper.node && wrapper.node.kind === "drawPage";
+}
+function isHeadingGroup(group) {
+	return group.node.headingLevel !== void 0;
+}
+function isConstructGroup(child) {
+	return "node" in child && "children" in child && child.node.kind !== "paragraph";
+}
+function assemblePackage(content, pages) {
+	const envelope = {
+		metadata: content.metadata,
+		...content.symbolTable !== void 0 ? { symbolTable: content.symbolTable } : {},
+		...pages !== void 0 ? { pages: [...pages] } : {}
+	};
+	switch (content.kind) {
+		case "wordprocessing": return mint({
+			kind: "wordprocessing",
+			...envelope,
+			children: content.sections.map(decomposeSection)
+		});
+		case "presentation": return mint({
+			kind: "presentation",
+			...envelope,
+			children: content.slides.map(decomposeSlide)
+		});
+		case "spreadsheet": return mint({
+			kind: "spreadsheet",
+			...envelope,
+			children: content.sheets.map(decomposeSheet)
+		});
+		case "drawing": return mint({
+			kind: "drawing",
+			...envelope,
+			children: content.pages.map(decomposeDrawPage)
+		});
+		case "formula": return mint({
+			kind: "formula",
+			...envelope,
+			children: [content.formula]
+		});
+	}
+}
+function factorStyles(pkg) {
+	const reassembled = assemblePackage(flattenPackage(pkg), pkg.pages);
+	if (pkg.definitions === void 0) return reassembled;
+	return {
+		...reassembled,
+		definitions: pkg.definitions
+	};
+}
+function extentOf(wrapper) {
+	if (isShapeGroupWrapper(wrapper)) return flowExtent(wrapper.children);
+	if (isAnchorGroupWrapper(wrapper)) return [wrapper.node, ...flowExtent(wrapper.children)];
+	if (isSlideGroupWrapper(wrapper)) return wrapper.children.flatMap(extentOf);
+	if (isDrawPageGroupWrapper(wrapper)) {
+		const paragraphs = [];
+		for (const child of wrapper.children) if ("node" in child) paragraphs.push(...extentOf(child));
+		return paragraphs;
+	}
+	return flowExtent(wrapper.children);
+}
+function flowExtent(children) {
+	const paragraphs = [];
+	for (const child of children) if ("node" in child && "children" in child) paragraphs.push(...extentOf(child));
+	else if (child.kind === "paragraph") paragraphs.push(child);
+	return paragraphs;
+}
+function paragraphTuple(paragraph, keys) {
+	const tuple = {};
+	for (const key of keys) if (paragraph[key] !== void 0) tuple[key] = paragraph[key];
+	return tuple;
+}
+function runTuple(run, keys) {
+	const tuple = {};
+	for (const key of keys) if (run[key] !== void 0) tuple[key] = run[key];
+	return tuple;
+}
+function commonParagraphKeys(extent, frozen) {
+	return PARAGRAPH_STYLE_KEYS.filter((key) => !frozen.has(key) && extent.every((paragraph) => paragraph[key] !== void 0));
+}
+function commonRunKeys(extent, frozen) {
+	const runs = extent.flatMap((paragraph) => paragraph.runs);
+	if (runs.length === 0) return [];
+	return RUN_STYLE_KEYS.filter((key) => !frozen.has(key) && runs.every((run) => run[key] !== void 0));
+}
+function bestParagraphCandidate(extent, keys, factored) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const paragraph of extent) {
+		if (factored.has(paragraph)) continue;
+		const tuple = paragraphTuple(paragraph, keys);
+		if (Object.keys(tuple).length === 0) continue;
+		const key = canonicalKey(tuple);
+		const existing = groups.get(key);
+		if (existing === void 0) groups.set(key, {
+			tuple,
+			keys,
+			positions: [paragraph]
+		});
+		else existing.positions.push(paragraph);
+	}
+	return bestGroup(groups);
+}
+function bestRunCandidate(extent, keys, factored) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const paragraph of extent) for (const run of paragraph.runs) {
+		if (factored.has(run)) continue;
+		const tuple = runTuple(run, keys);
+		if (Object.keys(tuple).length === 0) continue;
+		const key = canonicalKey(tuple);
+		const existing = groups.get(key);
+		if (existing === void 0) groups.set(key, {
+			tuple,
+			keys,
+			positions: [run]
+		});
+		else existing.positions.push(run);
+	}
+	return bestGroup(groups);
+}
+function bestGroup(groups) {
+	let best;
+	for (const group of groups.values()) {
+		if (group.positions.length < 2) continue;
+		if (best === void 0 || group.positions.length > best.positions.length) best = group;
+	}
+	return best;
+}
+function plan(wrapper, visit, branch, state, entries) {
+	const extent = extentOf(wrapper);
+	const paragraphCandidate = extent.length > 0 ? bestParagraphCandidate(extent, commonParagraphKeys(extent, branch.frozenParagraphs), branch.factoredParagraphs) : void 0;
+	const runCandidate = extent.length > 0 ? bestRunCandidate(extent, commonRunKeys(extent, branch.frozenRuns), branch.factoredRuns) : void 0;
+	const nextFrozenParagraphs = new Set(branch.frozenParagraphs);
+	const nextFrozenRuns = new Set(branch.frozenRuns);
+	const nextFactoredParagraphs = new Set(branch.factoredParagraphs);
+	const nextFactoredRuns = new Set(branch.factoredRuns);
+	if (paragraphCandidate !== void 0 || runCandidate !== void 0) {
+		const content = {
+			...paragraphCandidate !== void 0 ? { paragraph: paragraphCandidate.tuple } : {},
+			...runCandidate !== void 0 ? { run: runCandidate.tuple } : {}
+		};
+		const contentKey = canonicalKey(content);
+		const existing = entries.get(contentKey);
+		if (existing === void 0) entries.set(contentKey, {
+			content,
+			wrappers: [wrapper],
+			frequency: (paragraphCandidate?.positions.length ?? 0) + (runCandidate?.positions.length ?? 0),
+			firstVisit: visit.index
+		});
+		else {
+			existing.wrappers.push(wrapper);
+			existing.frequency += (paragraphCandidate?.positions.length ?? 0) + (runCandidate?.positions.length ?? 0);
+		}
+		const strips = {
+			paragraphs: /* @__PURE__ */ new Map(),
+			runs: /* @__PURE__ */ new Map()
+		};
+		if (paragraphCandidate !== void 0) {
+			for (const paragraph of paragraphCandidate.positions) {
+				nextFactoredParagraphs.add(paragraph);
+				strips.paragraphs.set(paragraph, paragraphCandidate.keys);
+			}
+			for (const key of paragraphCandidate.keys) nextFrozenParagraphs.add(key);
+		}
+		if (runCandidate !== void 0) {
+			for (const run of runCandidate.positions) {
+				nextFactoredRuns.add(run);
+				strips.runs.set(run, runCandidate.keys);
+			}
+			for (const key of runCandidate.keys) nextFrozenRuns.add(key);
+		}
+		state.wrapperStrips.set(wrapper, strips);
+	}
+	visit.index += 1;
+	const next = {
+		frozenParagraphs: nextFrozenParagraphs,
+		frozenRuns: nextFrozenRuns,
+		factoredParagraphs: nextFactoredParagraphs,
+		factoredRuns: nextFactoredRuns
+	};
+	for (const child of childWrappers(wrapper)) plan(child, visit, next, state, entries);
+}
+function childWrappers(wrapper) {
+	if (isShapeGroupWrapper(wrapper) || isAnchorGroupWrapper(wrapper)) {
+		const wrappers = [];
+		for (const child of wrapper.children) if ("node" in child && "children" in child) wrappers.push(child);
+		return wrappers;
+	}
+	if (isSlideGroupWrapper(wrapper)) return [...wrapper.children];
+	if (isDrawPageGroupWrapper(wrapper)) {
+		const shapes = [];
+		for (const child of wrapper.children) if ("node" in child) shapes.push(child);
+		return shapes;
+	}
+	const wrappers = [];
+	for (const child of wrapper.children) if ("node" in child && "children" in child) wrappers.push(child);
+	return wrappers;
+}
+function mint(pkg) {
+	const state = {
+		wrapperRefs: /* @__PURE__ */ new Map(),
+		wrapperStrips: /* @__PURE__ */ new Map()
+	};
+	const entries = /* @__PURE__ */ new Map();
+	const visit = { index: 0 };
+	const rootBranch = {
+		frozenParagraphs: /* @__PURE__ */ new Set(),
+		frozenRuns: /* @__PURE__ */ new Set(),
+		factoredParagraphs: /* @__PURE__ */ new Set(),
+		factoredRuns: /* @__PURE__ */ new Set()
+	};
+	switch (pkg.kind) {
+		case "wordprocessing":
+			for (const root of pkg.children) plan(root, visit, rootBranch, state, entries);
+			break;
+		case "presentation":
+			for (const root of pkg.children) plan(root, visit, rootBranch, state, entries);
+			break;
+		case "drawing": for (const root of pkg.children) plan(root, visit, rootBranch, state, entries);
+	}
+	if (entries.size === 0) return pkg;
+	const ordered = [...entries.values()].sort((a, b) => b.frequency - a.frequency || a.firstVisit - b.firstVisit);
+	const styles = {};
+	ordered.forEach((entry, index) => {
+		const id = `s${index + 1}`;
+		styles[id] = entry.content;
+		for (const wrapper of entry.wrappers) state.wrapperRefs.set(wrapper, id);
+	});
+	switch (pkg.kind) {
+		case "wordprocessing": return {
+			...pkg,
+			styles,
+			children: pkg.children.map((group) => rebuildSectionGroup(group, [], state))
+		};
+		case "presentation": return {
+			...pkg,
+			styles,
+			children: pkg.children.map((group) => rebuildSlideGroup(group, [], state))
+		};
+		case "drawing": return {
+			...pkg,
+			styles,
+			children: pkg.children.map((group) => rebuildDrawPageGroup(group, [], state))
+		};
+		case "spreadsheet":
+		case "formula": return {
+			...pkg,
+			styles
+		};
+	}
+}
+function innerChain(group, chain, state) {
+	const own = state.wrapperStrips.get(group);
+	return own === void 0 ? chain : [...chain, own];
+}
+function paragraphStripsOf(chain, paragraph) {
+	let result;
+	for (const strips of chain) {
+		const found = strips.paragraphs.get(paragraph);
+		if (found !== void 0) result = found;
+	}
+	return result;
+}
+function runStripsOf(chain, run) {
+	let result;
+	for (const strips of chain) {
+		const found = strips.runs.get(run);
+		if (found !== void 0) result = found;
+	}
+	return result;
+}
+function rebuildSlideGroup(group, chain, state) {
+	const inner = innerChain(group, chain, state);
+	const children = group.children.map((shape) => rebuildShapeGroup(shape, inner, state));
+	const ref = state.wrapperRefs.get(group);
+	return ref === void 0 && children.every((child, index) => child === group.children[index]) ? group : {
+		node: group.node,
+		...ref !== void 0 ? { style: ref } : {},
+		children
+	};
+}
+function rebuildDrawPageGroup(group, chain, state) {
+	const inner = innerChain(group, chain, state);
+	const children = group.children.map((child) => "node" in child ? rebuildShapeGroup(child, inner, state) : child);
+	const ref = state.wrapperRefs.get(group);
+	return ref === void 0 && children.every((child, index) => child === group.children[index]) ? group : {
+		node: group.node,
+		...ref !== void 0 ? { style: ref } : {},
+		children
+	};
+}
+function rebuildSectionGroup(group, chain, state) {
+	const inner = innerChain(group, chain, state);
+	const children = group.children.map((child) => rebuildSectionChild(child, inner, state));
+	const ref = state.wrapperRefs.get(group);
+	return ref === void 0 && children.every((child, index) => child === group.children[index]) ? group : {
+		node: group.node,
+		...ref !== void 0 ? { style: ref } : {},
+		children
+	};
+}
+function rebuildSectionChild(child, chain, state) {
+	if (isConstructGroup(child)) return rebuildSectionConstructGroup(child, chain, state);
+	if ("node" in child && "children" in child) return isHeadingGroup(child) ? rebuildHeadingGroup(child, chain, state, rebuildSectionChild) : rebuildListGroup(child, chain, state, rebuildListChild);
+	if (child.kind === "paragraph") return rebuildParagraph(child, chain);
+	return child;
+}
+function rebuildListChild(child, chain, state) {
+	if (isConstructGroup(child)) return rebuildShapeConstructGroup(child, chain, state);
+	if ("node" in child && "children" in child) return rebuildListGroup(child, chain, state, rebuildListChild);
+	if (child.kind === "paragraph") return rebuildParagraph(child, chain);
+	return child;
+}
+function rebuildShapeGroup(group, chain, state) {
+	const inner = innerChain(group, chain, state);
+	const children = group.children.map((child) => rebuildListChild(child, inner, state));
+	const ref = state.wrapperRefs.get(group);
+	return ref === void 0 && children.every((child, index) => child === group.children[index]) ? group : {
+		node: group.node,
+		...ref !== void 0 ? { style: ref } : {},
+		children
+	};
+}
+function rebuildSectionConstructGroup(group, chain, state) {
+	const inner = innerChain(group, chain, state);
+	const children = group.children.map((child) => rebuildSectionChild(child, inner, state));
+	const ref = state.wrapperRefs.get(group);
+	return ref === void 0 && children.every((child, index) => child === group.children[index]) ? group : {
+		node: group.node,
+		...ref !== void 0 ? { style: ref } : {},
+		children
+	};
+}
+function rebuildShapeConstructGroup(group, chain, state) {
+	const inner = innerChain(group, chain, state);
+	const children = group.children.map((child) => rebuildListChild(child, inner, state));
+	const ref = state.wrapperRefs.get(group);
+	return ref === void 0 && children.every((child, index) => child === group.children[index]) ? group : {
+		node: group.node,
+		...ref !== void 0 ? { style: ref } : {},
+		children
+	};
+}
+function rebuildHeadingGroup(group, chain, state, rebuildChild) {
+	const inner = innerChain(group, chain, state);
+	const anchor = rebuildParagraph(group.node, inner);
+	assertHeadingAnchor(anchor);
+	const children = group.children.map((child) => rebuildChild(child, inner, state));
+	const ref = state.wrapperRefs.get(group);
+	return ref === void 0 && anchor === group.node && children.every((child, index) => child === group.children[index]) ? group : {
+		node: anchor,
+		...ref !== void 0 ? { style: ref } : {},
+		children
+	};
+}
+function rebuildListGroup(group, chain, state, rebuildChild) {
+	const inner = innerChain(group, chain, state);
+	const anchor = rebuildParagraph(group.node, inner);
+	assertListAnchor(anchor);
+	const children = group.children.map((child) => rebuildChild(child, inner, state));
+	const ref = state.wrapperRefs.get(group);
+	return ref === void 0 && anchor === group.node && children.every((child, index) => child === group.children[index]) ? group : {
+		node: anchor,
+		...ref !== void 0 ? { style: ref } : {},
+		children
+	};
+}
+function assertHeadingAnchor(paragraph) {
+	if (paragraph.headingLevel === void 0) throw new Error("factorStyles: stripping dropped a heading anchor's headingLevel");
+}
+function assertListAnchor(paragraph) {
+	if (paragraph.list === void 0) throw new Error("factorStyles: stripping dropped a list anchor's list membership");
+}
+function rebuildParagraph(paragraph, chain) {
+	const strips = paragraphStripsOf(chain, paragraph);
+	const base = strips === void 0 ? paragraph : stripParagraphKeys(paragraph, strips);
+	let changed = base !== paragraph;
+	const runs = [];
+	for (const run of base.runs) {
+		const runStrips = runStripsOf(chain, run);
+		const rebuilt = runStrips === void 0 ? run : stripRunKeys(run, runStrips);
+		changed ||= rebuilt !== run;
+		runs.push(rebuilt);
+	}
+	if (!changed) return paragraph;
+	return {
+		...base,
+		runs
+	};
+}
+function stripParagraphKeys(paragraph, keys) {
+	const copy = { ...paragraph };
+	for (const key of keys) delete copy[key];
+	return copy;
+}
+function stripRunKeys(run, keys) {
+	const copy = { ...run };
+	for (const key of keys) delete copy[key];
+	return copy;
+}
+//#endregion
+export { assemblePackage, factorStyles, mint };

package/dist/flatten.cjs

@@ -0,0 +1,154 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_content = require("./content.cjs");
+const require_definitions = require("./definitions.cjs");
+//#region src/flatten.ts
+function chainWithRef(chain, group) {
+	return group.style === void 0 ? chain : [...chain, group.style];
+}
+function entryOf(styles, chain) {
+	if (chain.length === 0) return void 0;
+	if (styles === void 0) throw new Error("flattenPackage: a group carries a style ref but the package has no styles table");
+	return require_definitions.resolveStyleChain(styles, chain);
+}
+function applyEntry(entry, paragraph) {
+	const withParagraph = require_definitions.applyParagraphStyleProperties(entry.paragraph, paragraph);
+	const runProperties = entry.run;
+	if (runProperties === void 0) return withParagraph;
+	return {
+		...withParagraph,
+		runs: withParagraph.runs.map((run) => require_definitions.applyRunStyleProperties(runProperties, run))
+	};
+}
+function flattenPackage(pkg) {
+	const styles = pkg.styles;
+	const envelope = {
+		metadata: pkg.metadata,
+		...pkg.symbolTable !== void 0 ? { symbolTable: pkg.symbolTable } : {}
+	};
+	switch (pkg.kind) {
+		case "wordprocessing": return {
+			kind: "wordprocessing",
+			...envelope,
+			sections: pkg.children.map((group) => ({
+				...untag(group.node),
+				blocks: flattenSectionChildren(styles, chainWithRef([], group), group.children)
+			}))
+		};
+		case "presentation": return {
+			kind: "presentation",
+			...envelope,
+			slides: pkg.children.map((group) => {
+				const chain = chainWithRef([], group);
+				return {
+					...untag(group.node),
+					shapes: group.children.map((shape) => flattenShape(styles, chain, shape))
+				};
+			})
+		};
+		case "spreadsheet": return {
+			kind: "spreadsheet",
+			...envelope,
+			sheets: pkg.children.map((group) => {
+				if (group.style !== void 0) throw new Error("flattenPackage: a sheet group carries a style ref but a sheet holds no block flow to resolve it onto");
+				const images = [];
+				const embedded = [];
+				for (const child of group.children) if ("kind" in child) images.push(child);
+				else embedded.push(child);
+				return {
+					...untag(group.node),
+					images,
+					...embedded.length > 0 ? { embeddedObjects: embedded } : {}
+				};
+			})
+		};
+		case "drawing": return {
+			kind: "drawing",
+			...envelope,
+			pages: pkg.children.map((group) => {
+				const chain = chainWithRef([], group);
+				const shapes = [];
+				const vectors = [];
+				for (const child of group.children) if ("node" in child) shapes.push(flattenShape(styles, chain, child));
+				else vectors.push(child);
+				return {
+					...untag(group.node),
+					shapes,
+					vectors
+				};
+			})
+		};
+		case "formula": {
+			const first = pkg.children[0];
+			if (pkg.children.length !== 1 || first === void 0 || !require_content.ContentFormulaSchema.safeParse(first).success) throw new Error("flattenPackage: a formula package takes exactly one ContentFormula node");
+			return {
+				kind: "formula",
+				...envelope,
+				formula: first
+			};
+		}
+	}
+}
+function untag(descriptor) {
+	const copy = { ...descriptor };
+	delete copy.kind;
+	return copy;
+}
+function flattenShape(styles, chain, group) {
+	return {
+		...group.node,
+		blocks: flattenListChildren(styles, chainWithRef(chain, group), group.children)
+	};
+}
+function flattenSectionChildren(styles, chain, children) {
+	const blocks = [];
+	for (const child of children) if (isHeadingGroup(child)) {
+		const own = chainWithRef(chain, child);
+		blocks.push(resolveAnchor(styles, own, child.node), ...flattenSectionChildren(styles, own, child.children));
+	} else if (isListGroup(child)) {
+		const own = chainWithRef(chain, child);
+		blocks.push(resolveAnchor(styles, own, child.node), ...flattenListChildren(styles, own, child.children));
+	} else if (isConstructGroup(child)) {
+		const own = chainWithRef(chain, child);
+		blocks.push({
+			kind: "constructStart",
+			descriptor: child.node
+		}, ...flattenSectionChildren(styles, own, child.children), { kind: "constructEnd" });
+	} else if (child.kind === "paragraph") {
+		const entry = entryOf(styles, chain);
+		blocks.push(entry === void 0 ? child : applyEntry(entry, child));
+	} else blocks.push(child);
+	return blocks;
+}
+function flattenListChildren(styles, chain, children) {
+	const blocks = [];
+	for (const child of children) if (isListGroup(child)) {
+		const own = chainWithRef(chain, child);
+		blocks.push(resolveAnchor(styles, own, child.node), ...flattenListChildren(styles, own, child.children));
+	} else if (isConstructGroup(child)) {
+		const own = chainWithRef(chain, child);
+		blocks.push({
+			kind: "constructStart",
+			descriptor: child.node
+		}, ...flattenListChildren(styles, own, child.children), { kind: "constructEnd" });
+	} else if (child.kind === "paragraph") {
+		const entry = entryOf(styles, chain);
+		blocks.push(entry === void 0 ? child : applyEntry(entry, child));
+	} else blocks.push(child);
+	return blocks;
+}
+function isHeadingGroup(child) {
+	return "node" in child && "children" in child && child.node.kind === "paragraph" && child.node.headingLevel !== void 0;
+}
+function isListGroup(child) {
+	return "node" in child && "children" in child && child.node.kind === "paragraph" && child.node.list !== void 0;
+}
+function isConstructGroup(child) {
+	return "node" in child && "children" in child && child.node.kind !== "paragraph";
+}
+function resolveAnchor(styles, chain, anchor) {
+	const entry = entryOf(styles, chain);
+	if (entry === void 0) return anchor;
+	return applyEntry(entry, anchor);
+}
+//#endregion
+exports.flattenPackage = flattenPackage;

package/dist/flatten.d.cts

@@ -0,0 +1,6 @@
+import { m as ContentDocument } from "./content-BmqzegMG.cjs";
+import { DocumentPackage } from "./package.cjs";
+//#region src/flatten.d.ts
+declare function flattenPackage(pkg: DocumentPackage): ContentDocument;
+//#endregion
+export { flattenPackage };

package/dist/flatten.d.ts

@@ -0,0 +1,6 @@
+import { m as ContentDocument } from "./content-CIwPb_yh.js";
+import { DocumentPackage } from "./package.js";
+//#region src/flatten.d.ts
+declare function flattenPackage(pkg: DocumentPackage): ContentDocument;
+//#endregion
+export { flattenPackage };