open-agreements
Version:
Open-source legal template filling CLI and library
202 lines • 9.65 kB
JavaScript
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