document-outline.js 0.0.0 → 1.0.1

package/dist/index.js

@@ -0,0 +1,542 @@
+import { applyParagraphStyleProperties, applyRunStyleProperties, isHeadingGroupNode, isListGroupNode, isPackageLeaf, isSectionConstructGroupNode, isShapeConstructGroupNode, isShapeGroupNode, resolveStyleChain } from "document-schema.js";
+import { z } from "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 (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 (isListGroupNode(child)) {
+		openListGroup(scope.listStack, headingScopeOf(scope), paragraphText(child.node), child.node.list.level);
+		walkSectionFlow(scope, child.children);
+	} else if (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 (isListGroupNode(child)) {
+		openListGroup(listStack, scope, paragraphText(child.node), child.node.list.level);
+		walkShapeFlow(listStack, scope, child.children);
+	} else if (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) => isShapeGroupNode(child) ? flattenShapeChildren(child) : [child])
+	}));
+}
+function flattenShapeChildren(group) {
+	return flattenListFlow(group.children);
+}
+function flattenListFlow(children) {
+	const leaves = [];
+	for (const child of children) if (isListGroupNode(child)) leaves.push(child.node, ...flattenListFlow(child.children));
+	else if (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 ? 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 ? 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 (isHeadingGroupNode(child)) resolved = resolveHeadingGroup(styles, chain, child);
+		else if (isListGroupNode(child)) resolved = resolveListGroup(styles, chain, child);
+		else if (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 (isListGroupNode(child)) resolved = resolveListGroup(styles, chain, child);
+		else if (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(resolveStyleChain(styles, chain), leaf);
+}
+function applyEntry(entry, paragraph) {
+	const withParagraph = applyParagraphStyleProperties(entry.paragraph, paragraph);
+	const runProperties = entry.run;
+	if (runProperties === void 0) return withParagraph;
+	return {
+		...withParagraph,
+		runs: withParagraph.runs.map((run) => applyRunStyleProperties(runProperties, run))
+	};
+}
+function isShapeGroup(child) {
+	return "node" in child;
+}
+//#endregion
+//#region src/outline/node.ts
+function isOutlineLeaf(value) {
+	return 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 = 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
+export { OutlineNodeSchema, buildOutline, effectivePackage, flattenOutline, isOutlineChild, isOutlineLeaf, isOutlineNode, leafContentHash, outlineLeafText };

package/package.json

@@ -1,5 +1,94 @@
 {
   "name": "document-outline.js",
-  "version": "0.0.0",
-  "private": false
+  "version": "1.0.1",
+  "description": "Utilities for consumers holding a tree-form DocumentPackage - the TOC outline projection, effective-property resolution, and flatten/leaf-text/stable-hash helpers, the outline package for the documents.js family.",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ExaDev/documents.js.git",
+    "directory": "packages/document-outline.js"
+  },
+  "homepage": "https://github.com/ExaDev/document-outline.js#readme",
+  "bugs": {
+    "url": "https://github.com/ExaDev/document-outline.js/issues"
+  },
+  "license": "MIT",
+  "exports": {
+    ".": {
+      "types": {
+        "import": "./dist/index.d.ts",
+        "require": "./dist/index.d.cts"
+      },
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    },
+    "./*": {
+      "types": {
+        "import": "./dist/*.d.ts",
+        "require": "./dist/*.d.cts"
+      },
+      "import": "./dist/*.js",
+      "require": "./dist/*.cjs"
+    }
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "provenance": true,
+    "registry": "https://registry.npmjs.org/"
+  },
+  "sideEffects": false,
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "turbo run _build",
+    "_build": "tsdown",
+    "prepublishOnly": "pnpm run lint && pnpm run typecheck && tsdown && publint && attw --pack",
+    "lint": "turbo run _lint",
+    "_lint": "eslint . --fix --cache --max-warnings 0",
+    "lint:check": "eslint . --max-warnings 0",
+    "typecheck": "turbo run _typecheck",
+    "_typecheck": "tsc -p tsconfig.json && tsc -p tsconfig.node.json",
+    "test": "turbo run _test",
+    "_test": "vitest run",
+    "test:watch": "vitest",
+    "test:workers": "turbo run _test:workers",
+    "_test:workers": "vitest run --config vitest.workers.config.ts",
+    "prepare": "husky"
+  },
+  "packageManager": "pnpm@11.6.0",
+  "dependencies": {
+    "document-schema.js": "^4.3.4",
+    "zod": "^4.4.3"
+  },
+  "devDependencies": {
+    "@arethetypeswrong/cli": "^0.18.5",
+    "@cloudflare/vitest-pool-workers": "^0.20.1",
+    "@commitlint/cli": "^21.2.1",
+    "@commitlint/config-conventional": "^21.2.0",
+    "@eslint/js": "^10.0.1",
+    "@semantic-release/changelog": "^7.0.0",
+    "@semantic-release/git": "^11.0.1",
+    "@types/node": "^26.1.2",
+    "eslint": "^10.8.0",
+    "globals": "^17.8.0",
+    "husky": "^9.1.7",
+    "lint-staged": "^17.2.0",
+    "publint": "^0.3.21",
+    "semantic-release": "^25.0.8",
+    "tsdown": "^0.22.13",
+    "turbo": "^2.10.8",
+    "typescript": "^6.0.3",
+    "typescript-eslint": "^8.65.0",
+    "vitest": "^4.1.10"
+  },
+  "lint-staged": {
+    "*.ts": "eslint --fix"
+  }
 }