document-outline.js 0.0.0 → 1.0.1

package/dist/index.cjs

@@ -0,0 +1,551 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let document_schema_js = require("document-schema.js");
+let zod = require("zod");
+//#region src/outline/build.ts
+function buildOutline(pkg) {
+	switch (pkg.kind) {
+		case "wordprocessing": return wordprocessingOutline(pkg.children);
+		case "presentation": return presentationOutline(pkg.children);
+		case "spreadsheet": return spreadsheetOutline(pkg.children);
+		case "drawing": return drawingOutline(pkg.children);
+		case "formula": return formulaOutline(pkg.children[0]);
+	}
+}
+function freshSectionFlowScope() {
+	return {
+		root: [],
+		headingStack: [],
+		listStack: []
+	};
+}
+function headingScopeOf(scope) {
+	return scope.headingStack.at(-1)?.children ?? scope.root;
+}
+function walkSectionFlow(scope, children) {
+	for (const child of children) if ((0, document_schema_js.isHeadingGroupNode)(child)) {
+		scope.listStack.length = 0;
+		const level = child.node.headingLevel;
+		for (let top = scope.headingStack.at(-1); top !== void 0 && top.level >= level; top = scope.headingStack.at(-1)) scope.headingStack.pop();
+		const node = {
+			text: paragraphText(child.node),
+			level,
+			children: []
+		};
+		const parent = scope.headingStack.at(-1);
+		(parent !== void 0 ? parent.children : scope.root).push(node);
+		scope.headingStack.push(node);
+		walkSectionFlow(scope, child.children);
+	} else if ((0, document_schema_js.isListGroupNode)(child)) {
+		openListGroup(scope.listStack, headingScopeOf(scope), paragraphText(child.node), child.node.list.level);
+		walkSectionFlow(scope, child.children);
+	} else if ((0, document_schema_js.isSectionConstructGroupNode)(child)) {
+		const parent = scope.listStack.at(-1);
+		(parent !== void 0 ? parent.children : headingScopeOf(scope)).push(...projectSectionFlow(child.children));
+	} else if (child.kind === "paragraph") {
+		scope.listStack.length = 0;
+		headingScopeOf(scope).push(child);
+	} else {
+		const parent = scope.listStack.at(-1);
+		(parent !== void 0 ? parent.children : headingScopeOf(scope)).push(child);
+	}
+}
+function projectSectionFlow(children) {
+	const scope = freshSectionFlowScope();
+	walkSectionFlow(scope, children);
+	return scope.root;
+}
+function wordprocessingOutline(sections) {
+	const scope = freshSectionFlowScope();
+	for (const section of sections) walkSectionFlow(scope, section.children);
+	return scope.root;
+}
+function walkShapeFlow(listStack, scope, children) {
+	for (const child of children) if ((0, document_schema_js.isListGroupNode)(child)) {
+		openListGroup(listStack, scope, paragraphText(child.node), child.node.list.level);
+		walkShapeFlow(listStack, scope, child.children);
+	} else if ((0, document_schema_js.isShapeConstructGroupNode)(child)) {
+		const parent = listStack.at(-1);
+		(parent !== void 0 ? parent.children : scope).push(...projectShapeFlow(child.children));
+	} else if (child.kind === "paragraph") {
+		listStack.length = 0;
+		scope.push(child);
+	} else {
+		const parent = listStack.at(-1);
+		(parent !== void 0 ? parent.children : scope).push(child);
+	}
+}
+function projectShapeFlow(children) {
+	const scope = [];
+	walkShapeFlow([], scope, children);
+	return scope;
+}
+function presentationOutline(slides) {
+	return slides.map((slide, index) => {
+		const group = {
+			text: `Slide ${String(index + 1)}`,
+			level: 1,
+			children: []
+		};
+		const listStack = [];
+		for (const shape of slide.children) walkShapeFlow(listStack, group.children, shape.children);
+		return group;
+	});
+}
+function spreadsheetOutline(sheets) {
+	return sheets.map((sheet) => ({
+		text: sheet.node.name,
+		level: 1,
+		children: [...sheet.children]
+	}));
+}
+function drawingOutline(pages) {
+	return pages.map((page, index) => ({
+		text: `Page ${String(index + 1)}`,
+		level: 1,
+		children: page.children.flatMap((child) => (0, document_schema_js.isShapeGroupNode)(child) ? flattenShapeChildren(child) : [child])
+	}));
+}
+function flattenShapeChildren(group) {
+	return flattenListFlow(group.children);
+}
+function flattenListFlow(children) {
+	const leaves = [];
+	for (const child of children) if ((0, document_schema_js.isListGroupNode)(child)) leaves.push(child.node, ...flattenListFlow(child.children));
+	else if ((0, document_schema_js.isShapeConstructGroupNode)(child)) leaves.push(...flattenListFlow(child.children));
+	else leaves.push(child);
+	return leaves;
+}
+function formulaOutline(formula) {
+	return [{
+		text: formula.presentation?.latex ?? "",
+		level: 1,
+		children: [formula]
+	}];
+}
+function openListGroup(listStack, scopeChildren, text, level) {
+	for (let top = listStack.at(-1); top !== void 0 && top.level >= level; top = listStack.at(-1)) listStack.pop();
+	const node = {
+		text,
+		level,
+		children: []
+	};
+	const parent = listStack.at(-1);
+	(parent !== void 0 ? parent.children : scopeChildren).push(node);
+	listStack.push(node);
+}
+function paragraphText(paragraph) {
+	return paragraph.runs.map((run) => run.text).join("");
+}
+//#endregion
+//#region src/outline/effective.ts
+function effectivePackage(pkg) {
+	const styles = pkg.styles;
+	if (styles === void 0) return pkg;
+	switch (pkg.kind) {
+		case "wordprocessing": return withoutStyles({
+			...pkg,
+			children: pkg.children.map((group) => resolveSectionGroup(styles, [], group))
+		});
+		case "presentation": return withoutStyles({
+			...pkg,
+			children: pkg.children.map((group) => resolveSlideGroup(styles, [], group))
+		});
+		case "spreadsheet": return withoutStyles({
+			...pkg,
+			children: pkg.children.map(resolveSheetGroup)
+		});
+		case "drawing": return withoutStyles({
+			...pkg,
+			children: pkg.children.map((group) => resolveDrawPageGroup(styles, [], group))
+		});
+		case "formula": return withoutStyles({ ...pkg });
+	}
+}
+function withoutStyles(pkg) {
+	const copy = { ...pkg };
+	delete copy.styles;
+	return copy;
+}
+function chainWithRef(chain, group) {
+	return group.style === void 0 ? chain : [...chain, group.style];
+}
+function resolveSectionGroup(styles, chain, group) {
+	const children = resolveSectionChildren(styles, chainWithRef(chain, group), group.children);
+	if (group.style === void 0 && children === group.children) return group;
+	return {
+		node: group.node,
+		children
+	};
+}
+function resolveSlideGroup(styles, chain, group) {
+	const own = chainWithRef(chain, group);
+	let changed = group.style !== void 0;
+	const children = [];
+	for (const shape of group.children) {
+		const resolved = resolveShapeGroup(styles, own, shape);
+		changed ||= resolved !== shape;
+		children.push(resolved);
+	}
+	if (!changed) return group;
+	return {
+		node: group.node,
+		children
+	};
+}
+function resolveSheetGroup(group) {
+	return group.style === void 0 ? group : {
+		node: group.node,
+		children: group.children
+	};
+}
+function resolveDrawPageGroup(styles, chain, group) {
+	const own = chainWithRef(chain, group);
+	let changed = group.style !== void 0;
+	const children = [];
+	for (const child of group.children) {
+		const resolved = isShapeGroup(child) ? resolveShapeGroup(styles, own, child) : child;
+		changed ||= resolved !== child;
+		children.push(resolved);
+	}
+	if (!changed) return group;
+	return {
+		node: group.node,
+		children
+	};
+}
+function resolveShapeGroup(styles, chain, group) {
+	const children = resolveListChildren(styles, chainWithRef(chain, group), group.children);
+	if (group.style === void 0 && children === group.children) return group;
+	return {
+		node: group.node,
+		children
+	};
+}
+function resolveSectionConstructGroup(styles, chain, group) {
+	const children = resolveSectionChildren(styles, chainWithRef(chain, group), group.children);
+	if (group.style === void 0 && children === group.children) return group;
+	return {
+		node: group.node,
+		children
+	};
+}
+function resolveShapeConstructGroup(styles, chain, group) {
+	const children = resolveListChildren(styles, chainWithRef(chain, group), group.children);
+	if (group.style === void 0 && children === group.children) return group;
+	return {
+		node: group.node,
+		children
+	};
+}
+function resolveHeadingGroup(styles, chain, group) {
+	const own = chainWithRef(chain, group);
+	const entry = own.length > 0 ? (0, document_schema_js.resolveStyleChain)(styles, own) : void 0;
+	let anchor = group.node;
+	if (entry !== void 0) {
+		const applied = applyEntry(entry, group.node);
+		assertResolvedHeadingAnchor(applied);
+		anchor = applied;
+	}
+	const children = resolveSectionChildren(styles, own, group.children);
+	if (group.style === void 0 && anchor === group.node && children === group.children) return group;
+	return {
+		node: anchor,
+		children
+	};
+}
+function resolveListGroup(styles, chain, group) {
+	const own = chainWithRef(chain, group);
+	const entry = own.length > 0 ? (0, document_schema_js.resolveStyleChain)(styles, own) : void 0;
+	let anchor = group.node;
+	if (entry !== void 0) {
+		const applied = applyEntry(entry, group.node);
+		assertResolvedListAnchor(applied);
+		anchor = applied;
+	}
+	const children = resolveListChildren(styles, own, group.children);
+	if (group.style === void 0 && anchor === group.node && children === group.children) return group;
+	return {
+		node: anchor,
+		children
+	};
+}
+function assertResolvedHeadingAnchor(paragraph) {
+	if (paragraph.headingLevel === void 0) throw new Error("effectivePackage: resolution dropped a heading anchor's headingLevel");
+}
+function assertResolvedListAnchor(paragraph) {
+	if (paragraph.list === void 0) throw new Error("effectivePackage: resolution dropped a list anchor's list membership");
+}
+function resolveSectionChildren(styles, chain, children) {
+	let changed = false;
+	const out = [];
+	for (const child of children) {
+		let resolved;
+		if ((0, document_schema_js.isHeadingGroupNode)(child)) resolved = resolveHeadingGroup(styles, chain, child);
+		else if ((0, document_schema_js.isListGroupNode)(child)) resolved = resolveListGroup(styles, chain, child);
+		else if ((0, document_schema_js.isSectionConstructGroupNode)(child)) resolved = resolveSectionConstructGroup(styles, chain, child);
+		else if (child.kind === "paragraph") resolved = resolveParagraphLeaf(styles, chain, child);
+		else resolved = child;
+		changed ||= resolved !== child;
+		out.push(resolved);
+	}
+	return changed ? out : children;
+}
+function resolveListChildren(styles, chain, children) {
+	let changed = false;
+	const out = [];
+	for (const child of children) {
+		let resolved;
+		if ((0, document_schema_js.isListGroupNode)(child)) resolved = resolveListGroup(styles, chain, child);
+		else if ((0, document_schema_js.isShapeConstructGroupNode)(child)) resolved = resolveShapeConstructGroup(styles, chain, child);
+		else if (child.kind === "paragraph") resolved = resolveParagraphLeaf(styles, chain, child);
+		else resolved = child;
+		changed ||= resolved !== child;
+		out.push(resolved);
+	}
+	return changed ? out : children;
+}
+function resolveParagraphLeaf(styles, chain, leaf) {
+	if (chain.length === 0) return leaf;
+	return applyEntry((0, document_schema_js.resolveStyleChain)(styles, chain), leaf);
+}
+function applyEntry(entry, paragraph) {
+	const withParagraph = (0, document_schema_js.applyParagraphStyleProperties)(entry.paragraph, paragraph);
+	const runProperties = entry.run;
+	if (runProperties === void 0) return withParagraph;
+	return {
+		...withParagraph,
+		runs: withParagraph.runs.map((run) => (0, document_schema_js.applyRunStyleProperties)(runProperties, run))
+	};
+}
+function isShapeGroup(child) {
+	return "node" in child;
+}
+//#endregion
+//#region src/outline/node.ts
+function isOutlineLeaf(value) {
+	return (0, document_schema_js.isPackageLeaf)(value);
+}
+function isOutlineChild(value) {
+	return isOutlineNode(value) || isOutlineLeaf(value);
+}
+function isOutlineNode(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+	if (!("text" in value) || typeof value.text !== "string") return false;
+	if (!("level" in value) || typeof value.level !== "number" || !Number.isFinite(value.level)) return false;
+	if (!("children" in value) || !Array.isArray(value.children)) return false;
+	return value.children.every(isOutlineChild);
+}
+const OutlineNodeSchema = zod.z.custom(isOutlineNode);
+//#endregion
+//#region src/outline/hash.ts
+function stableContentHash(value) {
+	return sha256Hex(new TextEncoder().encode(JSON.stringify(canonicalise(stripSchemaKeys(value)))));
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function stripSchemaKeys(value) {
+	if (Array.isArray(value)) return value.map(stripSchemaKeys);
+	if (isRecord(value)) {
+		const stripped = {};
+		for (const [key, entry] of Object.entries(value)) {
+			if (key === "$schema") continue;
+			stripped[key] = stripSchemaKeys(entry);
+		}
+		return stripped;
+	}
+	return value;
+}
+function canonicalise(value) {
+	if (Array.isArray(value)) return value.map(canonicalise);
+	if (isRecord(value)) {
+		const sorted = {};
+		for (const key of Object.keys(value).sort()) sorted[key] = canonicalise(value[key]);
+		return sorted;
+	}
+	return value;
+}
+function sha256Hex(bytes) {
+	const digest = sha256(bytes);
+	let hex = "";
+	for (const byte of digest) hex += byte.toString(16).padStart(2, "0");
+	return hex;
+}
+const K = [
+	1116352408,
+	1899447441,
+	3049323471,
+	3921009573,
+	961987163,
+	1508970993,
+	2453635748,
+	2870763221,
+	3624381080,
+	310598401,
+	607225278,
+	1426881987,
+	1925078388,
+	2162078206,
+	2614888103,
+	3248222580,
+	3835390401,
+	4022224774,
+	264347078,
+	604807628,
+	770255983,
+	1249150122,
+	1555081692,
+	1996064986,
+	2554220882,
+	2821834349,
+	2952996808,
+	3210313671,
+	3336571891,
+	3584528711,
+	113926993,
+	338241895,
+	666307205,
+	773529912,
+	1294757372,
+	1396182291,
+	1695183700,
+	1986661051,
+	2177026350,
+	2456956037,
+	2730485921,
+	2820302411,
+	3259730800,
+	3345764771,
+	3516065817,
+	3600352804,
+	4094571909,
+	275423344,
+	430227734,
+	506948616,
+	659060556,
+	883997877,
+	958139571,
+	1322822218,
+	1537002063,
+	1747873779,
+	1955562222,
+	2024104815,
+	2227730452,
+	2361852424,
+	2428436474,
+	2756734187,
+	3204031479,
+	3329325298
+];
+function rotr(x, n) {
+	return (x >>> n | x << 32 - n) >>> 0;
+}
+function sha256(bytes) {
+	const bitLength = bytes.length * 8;
+	const paddedLength = (bytes.length + 8 >> 6) + 1 << 6;
+	const padded = new Uint8Array(paddedLength);
+	padded.set(bytes);
+	padded[bytes.length] = 128;
+	const view = new DataView(padded.buffer);
+	view.setUint32(paddedLength - 8, Math.floor(bitLength / 4294967296));
+	view.setUint32(paddedLength - 4, bitLength >>> 0);
+	let h0 = 1779033703;
+	let h1 = 3144134277;
+	let h2 = 1013904242;
+	let h3 = 2773480762;
+	let h4 = 1359893119;
+	let h5 = 2600822924;
+	let h6 = 528734635;
+	let h7 = 1541459225;
+	const w = /* @__PURE__ */ new Uint32Array(64);
+	for (let offset = 0; offset < paddedLength; offset += 64) {
+		for (let i = 0; i < 16; i++) w[i] = view.getUint32(offset + i * 4);
+		for (let i = 16; i < 64; i++) {
+			const w15 = w[i - 15];
+			const w2 = w[i - 2];
+			const s0 = rotr(w15, 7) ^ rotr(w15, 18) ^ w15 >>> 3;
+			const s1 = rotr(w2, 17) ^ rotr(w2, 19) ^ w2 >>> 10;
+			w[i] = w[i - 16] + s0 + w[i - 7] + s1 >>> 0;
+		}
+		let a = h0;
+		let b = h1;
+		let c = h2;
+		let d = h3;
+		let e = h4;
+		let f = h5;
+		let g = h6;
+		let h = h7;
+		for (let i = 0; i < 64; i++) {
+			const s1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25);
+			const ch = e & f ^ ~e & g;
+			const temp1 = h + s1 + ch + K[i] + w[i] >>> 0;
+			const temp2 = (rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22)) + (a & b ^ a & c ^ b & c) >>> 0;
+			h = g;
+			g = f;
+			f = e;
+			e = d + temp1 >>> 0;
+			d = c;
+			c = b;
+			b = a;
+			a = temp1 + temp2 >>> 0;
+		}
+		h0 = h0 + a >>> 0;
+		h1 = h1 + b >>> 0;
+		h2 = h2 + c >>> 0;
+		h3 = h3 + d >>> 0;
+		h4 = h4 + e >>> 0;
+		h5 = h5 + f >>> 0;
+		h6 = h6 + g >>> 0;
+		h7 = h7 + h >>> 0;
+	}
+	const digest = /* @__PURE__ */ new Uint8Array(32);
+	const out = new DataView(digest.buffer);
+	out.setUint32(0, h0);
+	out.setUint32(4, h1);
+	out.setUint32(8, h2);
+	out.setUint32(12, h3);
+	out.setUint32(16, h4);
+	out.setUint32(20, h5);
+	out.setUint32(24, h6);
+	out.setUint32(28, h7);
+	return digest;
+}
+//#endregion
+//#region src/outline/helpers.ts
+function flattenOutline(children) {
+	const leaves = [];
+	const walk = (subtree) => {
+		for (const child of subtree) if (isOutlineNode(child)) walk(child.children);
+		else leaves.push(child);
+	};
+	walk(children);
+	return leaves;
+}
+function outlineLeafText(leaf) {
+	if ("runs" in leaf) return leaf.runs.map((run) => run.text).join("");
+	if ("rows" in leaf) return leaf.rows.map((row) => row.cells.map((cell) => blockTexts(cell.blocks).join(" ")).join(" ")).join("\n");
+	if ("base64" in leaf) return leaf.altText ?? "";
+	if ("mathml" in leaf) return leaf.presentation?.latex ?? "";
+	return "";
+}
+function blockTexts(blocks) {
+	const parts = [];
+	for (const block of blocks) {
+		if (block.kind === "paragraph") parts.push(block.runs.map((run) => run.text).join(""));
+		if (block.kind === "table") parts.push(...block.rows.flatMap((row) => row.cells.map((cell) => blockTexts(cell.blocks).join(" "))));
+	}
+	return parts;
+}
+function leafContentHash(leaf) {
+	return stableContentHash(leaf);
+}
+//#endregion
+exports.OutlineNodeSchema = OutlineNodeSchema;
+exports.buildOutline = buildOutline;
+exports.effectivePackage = effectivePackage;
+exports.flattenOutline = flattenOutline;
+exports.isOutlineChild = isOutlineChild;
+exports.isOutlineLeaf = isOutlineLeaf;
+exports.isOutlineNode = isOutlineNode;
+exports.leafContentHash = leafContentHash;
+exports.outlineLeafText = outlineLeafText;

package/dist/index.d.cts

@@ -0,0 +1,27 @@
+import { DocumentPackage, PackageLeaf } from "document-schema.js";
+import { z } from "zod";
+//#region src/outline/node.d.ts
+type OutlineLeaf = PackageLeaf;
+type OutlineChild = OutlineNode | OutlineLeaf;
+interface OutlineNode {
+  readonly text: string;
+  readonly level: number;
+  children: OutlineChild[];
+}
+declare function isOutlineLeaf(value: unknown): value is OutlineLeaf;
+declare function isOutlineChild(value: unknown): value is OutlineChild;
+declare function isOutlineNode(value: unknown): value is OutlineNode;
+declare const OutlineNodeSchema: z.ZodCustom<OutlineNode, OutlineNode>;
+//#endregion
+//#region src/outline/build.d.ts
+declare function buildOutline(pkg: DocumentPackage): OutlineChild[];
+//#endregion
+//#region src/outline/effective.d.ts
+declare function effectivePackage(pkg: DocumentPackage): DocumentPackage;
+//#endregion
+//#region src/outline/helpers.d.ts
+declare function flattenOutline(children: readonly OutlineChild[]): OutlineLeaf[];
+declare function outlineLeafText(leaf: OutlineLeaf): string;
+declare function leafContentHash(leaf: OutlineLeaf): string;
+//#endregion
+export { OutlineChild, OutlineLeaf, OutlineNode, OutlineNodeSchema, buildOutline, effectivePackage, flattenOutline, isOutlineChild, isOutlineLeaf, isOutlineNode, leafContentHash, outlineLeafText };

package/dist/index.d.ts

@@ -0,0 +1,27 @@
+import { DocumentPackage, PackageLeaf } from "document-schema.js";
+import { z } from "zod";
+//#region src/outline/node.d.ts
+type OutlineLeaf = PackageLeaf;
+type OutlineChild = OutlineNode | OutlineLeaf;
+interface OutlineNode {
+  readonly text: string;
+  readonly level: number;
+  children: OutlineChild[];
+}
+declare function isOutlineLeaf(value: unknown): value is OutlineLeaf;
+declare function isOutlineChild(value: unknown): value is OutlineChild;
+declare function isOutlineNode(value: unknown): value is OutlineNode;
+declare const OutlineNodeSchema: z.ZodCustom<OutlineNode, OutlineNode>;
+//#endregion
+//#region src/outline/build.d.ts
+declare function buildOutline(pkg: DocumentPackage): OutlineChild[];
+//#endregion
+//#region src/outline/effective.d.ts
+declare function effectivePackage(pkg: DocumentPackage): DocumentPackage;
+//#endregion
+//#region src/outline/helpers.d.ts
+declare function flattenOutline(children: readonly OutlineChild[]): OutlineLeaf[];
+declare function outlineLeafText(leaf: OutlineLeaf): string;
+declare function leafContentHash(leaf: OutlineLeaf): string;
+//#endregion
+export { OutlineChild, OutlineLeaf, OutlineNode, OutlineNodeSchema, buildOutline, effectivePackage, flattenOutline, isOutlineChild, isOutlineLeaf, isOutlineNode, leafContentHash, outlineLeafText };