UNPKG

open-agreements

Version:

Open-source legal template filling CLI and library

202 lines • 9.65 kB
const W = 'http://schemas.openxmlformats.org/wordprocessingml/2006/main'; function children(parent, local) { return Array.from(parent.childNodes).filter((node) => node.nodeType === 1 && node.namespaceURI === W && node.localName === local); } function direct(parent, local) { if (!parent) return null; const found = children(parent, local); if (found.length > 1) throw new Error(`numbering counters: duplicate ${local}`); return found[0] ?? null; } function attr(element, local) { return element.getAttributeNS(W, local) ?? ''; } function integer(raw, context, max = Number.MAX_SAFE_INTEGER) { if (!/^\d+$/.test(raw) || !Number.isSafeInteger(Number(raw)) || Number(raw) > max) { throw new Error(`numbering counters: invalid ${context}: ${raw}`); } return Number(raw); } function id(element, local) { return String(integer(attr(element, local), local)); } function fromProperties(properties) { const numPr = direct(properties, 'numPr'); if (!numPr) return {}; if (direct(numPr, 'numberingChange') || direct(numPr, 'ins')) { throw new Error('numbering counters: tracked numbering changes are unsupported'); } const num = direct(numPr, 'numId'); const level = direct(numPr, 'ilvl'); return { ...(num ? { numId: id(num, 'val') } : {}), ...(level ? { ilvl: integer(attr(level, 'val'), 'paragraph level', 8) } : {}), }; } function paragraphResolver(styles) { const definitions = new Map(); let defaultId; for (const style of Array.from(styles?.getElementsByTagNameNS(W, 'style') ?? [])) { if (attr(style, 'type') !== 'paragraph') continue; const key = attr(style, 'styleId'); if (!key || definitions.has(key)) throw new Error('numbering counters: missing/duplicate paragraph style ID'); definitions.set(key, style); if (['1', 'true', 'on'].includes(attr(style, 'default'))) { if (defaultId) throw new Error('numbering counters: multiple default paragraph styles'); defaultId = key; } } const defaults = fromProperties(direct(direct(direct(styles?.documentElement ?? null, 'docDefaults'), 'pPrDefault'), 'pPr')); const cache = new Map(); const visiting = new Set(); const resolve = (key) => { if (cache.has(key)) return cache.get(key); if (visiting.has(key)) throw new Error(`numbering counters: paragraph style cycle at ${key}`); const style = definitions.get(key); if (!style) throw new Error(`numbering counters: unresolved paragraph style ${key}`); visiting.add(key); const parent = direct(style, 'basedOn'); const result = { ...(parent ? resolve(attr(parent, 'val')) : defaults), ...fromProperties(direct(style, 'pPr')) }; visiting.delete(key); cache.set(key, result); return result; }; return (paragraph) => { const properties = direct(paragraph, 'pPr'); const style = direct(properties, 'pStyle'); const styleId = style ? attr(style, 'val') : defaultId; return { ...(styleId ? resolve(styleId) : defaults), ...fromProperties(properties) }; }; } /** * Pure counter projection for a transient renderer copy, not editable-DOCX rewriting. * OOXML defaults: absent start = 0; absent lvlRestart = previous level; 0 = never. * https://learn.microsoft.com/en-us/dotnet/api/documentformat.openxml.wordprocessing.levelrestart * https://learn.microsoft.com/en-us/dotnet/api/documentformat.openxml.wordprocessing.startnumberingvalue * https://learn.microsoft.com/en-us/dotnet/api/documentformat.openxml.wordprocessing.startoverridenumberingvalue */ export function resolveNumberingSnapshots(document, styles, numbering) { const abstracts = new Map(); const numbers = new Map(); const numberingRoot = numbering.documentElement; if (!numberingRoot) throw new Error('numbering counters: missing numbering document root'); for (const node of children(numberingRoot, 'abstractNum')) { const key = id(node, 'abstractNumId'); if (abstracts.has(key)) throw new Error(`numbering counters: duplicate abstractNum ${key}`); abstracts.set(key, node); } for (const node of children(numberingRoot, 'num')) { const key = id(node, 'numId'); if (numbers.has(key)) throw new Error(`numbering counters: duplicate numId ${key}`); numbers.set(key, node); } const instances = new Map(); const instance = (numId) => { if (instances.has(numId)) return instances.get(numId); const num = numbers.get(numId); const abstractId = num && direct(num, 'abstractNumId'); const source = abstractId && abstracts.get(id(abstractId, 'val')); if (!num || !source) throw new Error(`numbering counters: unresolved numbering instance ${numId}`); if (direct(source, 'numStyleLink') || direct(source, 'styleLink')) { throw new Error(`numbering counters: numbering style links unsupported for ${numId}`); } const effective = source.cloneNode(true); const levelNodes = new Map(); for (const node of children(effective, 'lvl')) { const level = integer(attr(node, 'ilvl'), 'abstract level', 8); if (levelNodes.has(level)) throw new Error(`numbering counters: duplicate level ${level}`); levelNodes.set(level, node); } const overridden = new Set(); for (const override of children(num, 'lvlOverride')) { const level = integer(attr(override, 'ilvl'), 'override level', 8); if (overridden.has(level)) throw new Error(`numbering counters: duplicate override ${level}`); overridden.add(level); const replacement = direct(override, 'lvl'); let node = levelNodes.get(level); if (replacement) { if (integer(attr(replacement, 'ilvl'), 'override child level', 8) !== level) { throw new Error('numbering counters: override level mismatch'); } const clone = replacement.cloneNode(true); if (node) effective.replaceChild(clone, node); else effective.appendChild(clone); node = clone; levelNodes.set(level, node); } if (!node) throw new Error(`numbering counters: override references undefined level ${level}`); const startOverride = direct(override, 'startOverride'); if (startOverride) { const startValue = integer(attr(startOverride, 'val'), 'startOverride'); let start = direct(node, 'start'); if (!start) { start = numbering.createElementNS(W, 'w:start'); node.insertBefore(start, node.firstChild); } start.setAttributeNS(W, 'w:val', String(startValue)); } } const levels = new Map(); for (const [level, node] of levelNodes) { const start = direct(node, 'start'); const restart = direct(node, 'lvlRestart'); const restartValue = restart ? integer(attr(restart, 'val'), 'lvlRestart', 9) : level; // A restart reference to this/lower level is ignored by OOXML, using the default. levels.set(level, { start: start ? integer(attr(start, 'val'), 'start') : 0, restart: restartValue > level ? level : restartValue }); const text = direct(node, 'lvlText'); for (const match of attr(text ?? node, 'val').matchAll(/%([1-9])/g)) { const referenced = Number(match[1]) - 1; if (referenced <= level && !levelNodes.has(referenced)) { throw new Error(`numbering counters: level ${level} references undefined ancestor ${referenced}`); } } } const result = { abstract: effective, levels, values: Array(9).fill(undefined) }; instances.set(numId, result); return result; }; const resolveParagraph = paragraphResolver(styles); const snapshots = []; for (const paragraph of Array.from(document.getElementsByTagNameNS(W, 'p'))) { const resolved = resolveParagraph(paragraph); if (!resolved.numId || resolved.numId === '0') continue; const ilvl = resolved.ilvl ?? 0; const state = instance(resolved.numId); const definition = state.levels.get(ilvl); if (!definition) throw new Error(`numbering counters: undefined level ${ilvl} for ${resolved.numId}`); const prior = state.values[ilvl]; state.values[ilvl] = prior === undefined ? definition.start : prior + 1; if (!Number.isSafeInteger(state.values[ilvl])) throw new Error('numbering counters: counter overflow'); for (const [level, lower] of state.levels) { if (level > ilvl && lower.restart > 0 && ilvl < lower.restart) state.values[level] = undefined; } const counters = Array.from({ length: 9 }, (_, level) => state.values[level] ?? state.levels.get(level)?.start ?? 0); snapshots.push({ paragraph, numId: resolved.numId, ilvl, counters, effectiveAbstract: state.abstract.cloneNode(true) }); } return snapshots; } //# sourceMappingURL=numbering-counters.js.map