docxmlater 10.4.1 → 11.0.4

package/dist/esm/formatting/StylesManager.js

@@ -0,0 +1,557 @@
+import { XMLBuilder } from '../xml/XMLBuilder.js';
+import { XMLParser } from '../xml/XMLParser.js';
+import { Style } from './Style.js';
+export class StylesManager {
+    styles = new Map();
+    includeBuiltInStyles;
+    _modified = false;
+    _modifiedStyleIds = new Set();
+    latentStyles;
+    latentStyleExceptions = [];
+    static BUILT_IN_STYLE_FACTORIES = new Map([
+        ['Normal', () => Style.createNormalStyle()],
+        ['Heading1', () => Style.createHeadingStyle(1)],
+        ['Heading2', () => Style.createHeadingStyle(2)],
+        ['Heading3', () => Style.createHeadingStyle(3)],
+        ['Heading4', () => Style.createHeadingStyle(4)],
+        ['Heading5', () => Style.createHeadingStyle(5)],
+        ['Heading6', () => Style.createHeadingStyle(6)],
+        ['Heading7', () => Style.createHeadingStyle(7)],
+        ['Heading8', () => Style.createHeadingStyle(8)],
+        ['Heading9', () => Style.createHeadingStyle(9)],
+        ['Heading1Char', () => Style.createHeadingCharStyle(1)],
+        ['Heading2Char', () => Style.createHeadingCharStyle(2)],
+        ['Heading3Char', () => Style.createHeadingCharStyle(3)],
+        ['Heading4Char', () => Style.createHeadingCharStyle(4)],
+        ['Heading5Char', () => Style.createHeadingCharStyle(5)],
+        ['Heading6Char', () => Style.createHeadingCharStyle(6)],
+        ['Heading7Char', () => Style.createHeadingCharStyle(7)],
+        ['Heading8Char', () => Style.createHeadingCharStyle(8)],
+        ['Heading9Char', () => Style.createHeadingCharStyle(9)],
+        ['Title', () => Style.createTitleStyle()],
+        ['Subtitle', () => Style.createSubtitleStyle()],
+        ['ListParagraph', () => Style.createListParagraphStyle()],
+        ['TOCHeading', () => Style.createTOCHeadingStyle()],
+        ['TableNormal', () => Style.createTableNormalStyle()],
+        ['TableGrid', () => Style.createTableGridStyle()],
+    ]);
+    constructor(includeBuiltInStyles = true) {
+        this.includeBuiltInStyles = includeBuiltInStyles;
+        if (includeBuiltInStyles) {
+            this.ensureStyleLoaded('Normal');
+        }
+    }
+    ensureStyleLoaded(styleId) {
+        if (this.styles.has(styleId)) {
+            return;
+        }
+        if (!this.includeBuiltInStyles) {
+            return;
+        }
+        const factory = StylesManager.BUILT_IN_STYLE_FACTORIES.get(styleId);
+        if (factory) {
+            this.styles.set(styleId, factory());
+        }
+    }
+    addStyle(style) {
+        const existing = this.styles.get(style.getStyleId());
+        if (existing) {
+            if (existing.getIsDefault() && !style.getIsDefault()) {
+                style.setIsDefault(true);
+            }
+            const newProps = style.getProperties();
+            const existingProps = existing.getProperties();
+            if (newProps.basedOn === undefined && existingProps.basedOn !== undefined) {
+                style.setBasedOn(existingProps.basedOn);
+            }
+            if (newProps.next === undefined && existingProps.next !== undefined) {
+                style.setNext(existingProps.next);
+            }
+            if (newProps.link === undefined && existingProps.link !== undefined) {
+                style.setLink(existingProps.link);
+            }
+            if (newProps.uiPriority === undefined && existingProps.uiPriority !== undefined) {
+                style.setUiPriority(existingProps.uiPriority);
+            }
+        }
+        this.styles.set(style.getStyleId(), style);
+        this._modifiedStyleIds.add(style.getStyleId());
+        this._modified = true;
+        return this;
+    }
+    getStyle(styleId) {
+        this.ensureStyleLoaded(styleId);
+        return this.styles.get(styleId);
+    }
+    cloneStyle(sourceId, newId, newName) {
+        const source = this.getStyle(sourceId);
+        if (!source)
+            return undefined;
+        const props = source.getProperties();
+        props.styleId = newId;
+        props.name = newName ?? newId;
+        props.isDefault = false;
+        const cloned = new Style(props);
+        this.addStyle(cloned);
+        return cloned;
+    }
+    hasStyle(styleId) {
+        if (this.styles.has(styleId)) {
+            return true;
+        }
+        return this.includeBuiltInStyles && StylesManager.BUILT_IN_STYLE_FACTORIES.has(styleId);
+    }
+    removeStyle(styleId) {
+        return this.styles.delete(styleId);
+    }
+    getAllStyles() {
+        return Array.from(this.styles.values());
+    }
+    isModified() {
+        return this._modified;
+    }
+    resetModified() {
+        this._modified = false;
+        this._modifiedStyleIds.clear();
+    }
+    getModifiedStyleIds() {
+        return new Set(this._modifiedStyleIds);
+    }
+    getStylesByType(type) {
+        return this.getAllStyles().filter((style) => style.getType() === type);
+    }
+    getQuickStyles() {
+        return this.getAllStyles().filter((style) => {
+            const props = style.getProperties();
+            const isQuick = props.qFormat === true || (!props.customStyle && props.qFormat !== false);
+            const isVisible = !props.semiHidden;
+            return isQuick && isVisible;
+        });
+    }
+    getVisibleStyles() {
+        return this.getAllStyles().filter((style) => {
+            const props = style.getProperties();
+            return !props.semiHidden;
+        });
+    }
+    getStylesByPriority() {
+        return this.getAllStyles().sort((a, b) => {
+            const propsA = a.getProperties();
+            const propsB = b.getProperties();
+            const priorityA = propsA.uiPriority ?? 999;
+            const priorityB = propsB.uiPriority ?? 999;
+            return priorityA - priorityB;
+        });
+    }
+    getLinkedStyle(styleId) {
+        const style = this.getStyle(styleId);
+        if (!style) {
+            return undefined;
+        }
+        const props = style.getProperties();
+        if (!props.link) {
+            return undefined;
+        }
+        return this.getStyle(props.link);
+    }
+    getTableStyles() {
+        return this.getAllStyles().filter((style) => style.getType() === 'table');
+    }
+    createTableStyle(styleId, name, basedOn) {
+        const style = Style.create({
+            styleId,
+            name,
+            type: 'table',
+            basedOn,
+            customStyle: true,
+        });
+        this.addStyle(style);
+        return style;
+    }
+    getStyleCount() {
+        return this.styles.size;
+    }
+    clear() {
+        this.styles.clear();
+        return this;
+    }
+    static getBuiltInStyleIds() {
+        return Array.from(StylesManager.BUILT_IN_STYLE_FACTORIES.keys());
+    }
+    static isBuiltInStyle(styleId) {
+        return StylesManager.BUILT_IN_STYLE_FACTORIES.has(styleId);
+    }
+    getStats() {
+        const loadedStyles = this.styles.size;
+        const customStyles = this.getAllStyles().filter((s) => s.getProperties().customStyle).length;
+        return {
+            loadedStyles,
+            availableBuiltInStyles: this.includeBuiltInStyles
+                ? StylesManager.BUILT_IN_STYLE_FACTORIES.size
+                : 0,
+            customStyles,
+        };
+    }
+    createParagraphStyle(styleId, name, basedOn) {
+        const style = Style.create({
+            styleId,
+            name,
+            type: 'paragraph',
+            basedOn,
+            customStyle: true,
+        });
+        this.addStyle(style);
+        return style;
+    }
+    createCharacterStyle(styleId, name, basedOn) {
+        const style = Style.create({
+            styleId,
+            name,
+            type: 'character',
+            basedOn,
+            customStyle: true,
+        });
+        this.addStyle(style);
+        return style;
+    }
+    setLatentStyles(config) {
+        this.latentStyles = config;
+        this._modified = true;
+        return this;
+    }
+    getLatentStyles() {
+        return this.latentStyles;
+    }
+    addLatentStyleException(exception) {
+        const idx = this.latentStyleExceptions.findIndex((e) => e.name === exception.name);
+        if (idx >= 0) {
+            this.latentStyleExceptions[idx] = exception;
+        }
+        else {
+            this.latentStyleExceptions.push(exception);
+        }
+        this._modified = true;
+        return this;
+    }
+    getLatentStyleExceptions() {
+        return [...this.latentStyleExceptions];
+    }
+    generateStylesXml() {
+        const builder = new XMLBuilder();
+        const stylesChildren = [];
+        stylesChildren.push(this.generateDocDefaults());
+        if (this.latentStyles) {
+            stylesChildren.push(this.generateLatentStyles());
+        }
+        for (const style of this.getAllStyles()) {
+            stylesChildren.push(style.toXML());
+        }
+        builder.element('w:styles', {
+            'xmlns:w': 'http://schemas.openxmlformats.org/wordprocessingml/2006/main',
+            'xmlns:r': 'http://schemas.openxmlformats.org/officeDocument/2006/relationships',
+        }, stylesChildren);
+        return builder.build(true);
+    }
+    generateDocDefaults() {
+        const rPrDefaultChildren = [
+            XMLBuilder.wSelf('rFonts', {
+                'w:ascii': 'Calibri',
+                'w:hAnsi': 'Calibri',
+                'w:eastAsia': 'Calibri',
+                'w:cs': 'Calibri',
+            }),
+            XMLBuilder.wSelf('sz', { 'w:val': '22' }),
+            XMLBuilder.wSelf('szCs', { 'w:val': '22' }),
+            XMLBuilder.wSelf('lang', {
+                'w:val': 'en-US',
+                'w:eastAsia': 'en-US',
+                'w:bidi': 'ar-SA',
+            }),
+        ];
+        const pPrDefaultChildren = [
+            XMLBuilder.wSelf('spacing', {
+                'w:after': '200',
+                'w:line': '276',
+                'w:lineRule': 'auto',
+            }),
+        ];
+        return XMLBuilder.w('docDefaults', undefined, [
+            XMLBuilder.w('rPrDefault', undefined, [XMLBuilder.w('rPr', undefined, rPrDefaultChildren)]),
+            XMLBuilder.w('pPrDefault', undefined, [XMLBuilder.w('pPr', undefined, pPrDefaultChildren)]),
+        ]);
+    }
+    generateLatentStyles() {
+        if (!this.latentStyles)
+            return XMLBuilder.w('latentStyles', {}, []);
+        const attrs = {};
+        if (this.latentStyles.defaultLockedState !== undefined) {
+            attrs['w:defLockedState'] = this.latentStyles.defaultLockedState ? '1' : '0';
+        }
+        if (this.latentStyles.defaultUiPriority !== undefined) {
+            attrs['w:defUIPriority'] = this.latentStyles.defaultUiPriority.toString();
+        }
+        if (this.latentStyles.defaultSemiHidden !== undefined) {
+            attrs['w:defSemiHidden'] = this.latentStyles.defaultSemiHidden ? '1' : '0';
+        }
+        if (this.latentStyles.defaultUnhideWhenUsed !== undefined) {
+            attrs['w:defUnhideWhenUsed'] = this.latentStyles.defaultUnhideWhenUsed ? '1' : '0';
+        }
+        if (this.latentStyles.defaultQFormat !== undefined) {
+            attrs['w:defQFormat'] = this.latentStyles.defaultQFormat ? '1' : '0';
+        }
+        if (this.latentStyles.count !== undefined) {
+            attrs['w:count'] = this.latentStyles.count.toString();
+        }
+        const children = this.latentStyleExceptions.map((exc) => {
+            const excAttrs = { 'w:name': exc.name };
+            if (exc.locked !== undefined)
+                excAttrs['w:locked'] = exc.locked ? '1' : '0';
+            if (exc.uiPriority !== undefined)
+                excAttrs['w:uiPriority'] = exc.uiPriority.toString();
+            if (exc.semiHidden !== undefined)
+                excAttrs['w:semiHidden'] = exc.semiHidden ? '1' : '0';
+            if (exc.unhideWhenUsed !== undefined)
+                excAttrs['w:unhideWhenUsed'] = exc.unhideWhenUsed ? '1' : '0';
+            if (exc.qFormat !== undefined)
+                excAttrs['w:qFormat'] = exc.qFormat ? '1' : '0';
+            return XMLBuilder.wSelf('lsdException', excAttrs);
+        });
+        return XMLBuilder.w('latentStyles', attrs, children);
+    }
+    static create() {
+        return new StylesManager(true);
+    }
+    static createEmpty() {
+        return new StylesManager(false);
+    }
+    static validate(xml) {
+        const result = {
+            isValid: true,
+            errors: [],
+            warnings: [],
+            styleCount: 0,
+            styleIds: [],
+        };
+        if (!xml || xml.trim().length === 0) {
+            result.isValid = false;
+            result.errors.push('Styles XML is empty or null');
+            return result;
+        }
+        if (xml.includes('<w:') || xml.includes('>')) {
+            result.isValid = false;
+            result.errors.push('XML contains escaped tags - possible double-encoding corruption');
+            return result;
+        }
+        const stylesContent = XMLParser.extractBetweenTags(xml, '<w:styles', '</w:styles>');
+        if (!stylesContent) {
+            result.isValid = false;
+            result.errors.push('Missing required <w:styles> root element');
+            return result;
+        }
+        if (!xml.includes('xmlns:w=')) {
+            result.warnings.push('Missing WordprocessingML namespace declaration');
+        }
+        const styleElements = XMLParser.extractElements(stylesContent, 'w:style');
+        result.styleCount = styleElements.length;
+        if (styleElements.length === 0) {
+            result.warnings.push('No styles found in document');
+            return result;
+        }
+        const styleWithoutAttrs = styleElements.filter((el) => {
+            const openTagEnd = el.indexOf('>');
+            const openTag = el.substring(0, openTagEnd);
+            return !openTag.includes('w:type') || !openTag.includes('w:styleId');
+        });
+        if (styleWithoutAttrs.length > 0) {
+            result.isValid = false;
+            result.errors.push('Style found without any attributes - w:type and w:styleId are required');
+        }
+        const foundStyleIds = new Set();
+        for (const styleElement of styleElements) {
+            const styleId = XMLParser.extractAttribute(styleElement, 'w:styleId');
+            if (styleId) {
+                if (foundStyleIds.has(styleId)) {
+                    result.isValid = false;
+                    result.errors.push(`Duplicate style ID found: "${styleId}"`);
+                }
+                else {
+                    foundStyleIds.add(styleId);
+                    result.styleIds.push(styleId);
+                }
+            }
+            else {
+                result.isValid = false;
+                result.errors.push('Style found without required w:styleId attribute');
+            }
+            const type = XMLParser.extractAttribute(styleElement, 'w:type');
+            if (type) {
+                if (!['paragraph', 'character', 'table', 'numbering'].includes(type)) {
+                    result.warnings.push(`Invalid style type: "${type}"`);
+                }
+            }
+            else {
+                result.isValid = false;
+                result.errors.push('Style found without required w:type attribute');
+            }
+            const basedOnElement = XMLParser.extractElements(styleElement, 'w:basedOn')[0];
+            if (basedOnElement && styleId) {
+                const basedOn = XMLParser.extractAttribute(basedOnElement, 'w:val');
+                if (basedOn && styleId === basedOn) {
+                    result.isValid = false;
+                    result.errors.push(`Circular reference detected: style "${styleId}" based on itself`);
+                }
+            }
+        }
+        if (!foundStyleIds.has('Normal')) {
+            result.warnings.push('Missing "Normal" style - document may not render correctly');
+        }
+        if (xml.charCodeAt(0) === 0xfeff) {
+            result.warnings.push('XML contains BOM (Byte Order Mark) - may cause parsing issues');
+        }
+        if (result.styleCount === 0) {
+            result.warnings.push('No styles found in document');
+        }
+        return result;
+    }
+    searchByName(searchTerm) {
+        const term = searchTerm.toLowerCase();
+        return this.getAllStyles().filter((style) => style.getName().toLowerCase().includes(term));
+    }
+    findByFont(fontName) {
+        return this.getAllStyles().filter((style) => {
+            const runFormatting = style.getRunFormatting();
+            return runFormatting?.font === fontName;
+        });
+    }
+    findStyles(predicate) {
+        return this.getAllStyles().filter(predicate);
+    }
+    findUnusedStyles(paragraphs) {
+        const usedStyles = new Set();
+        for (const para of paragraphs) {
+            const styleId = para.getStyle();
+            if (styleId) {
+                usedStyles.add(styleId);
+            }
+        }
+        const allStyleIds = this.getAllStyles().map((style) => style.getStyleId());
+        return allStyleIds.filter((styleId) => !usedStyles.has(styleId));
+    }
+    cleanupUnusedStyles(paragraphs) {
+        const unused = this.findUnusedStyles(paragraphs);
+        let count = 0;
+        for (const styleId of unused) {
+            if (!StylesManager.isBuiltInStyle(styleId)) {
+                if (this.removeStyle(styleId)) {
+                    count++;
+                }
+            }
+        }
+        return count;
+    }
+    validateStyleReferences() {
+        const broken = [];
+        const circular = [];
+        const checkedForCycles = new Set();
+        for (const style of this.getAllStyles()) {
+            const props = style.getProperties();
+            if (props.basedOn && !this.hasStyle(props.basedOn)) {
+                broken.push({ styleId: props.styleId, basedOn: props.basedOn });
+            }
+            if (!checkedForCycles.has(props.styleId)) {
+                const result = this.hasCircularReference(props.styleId);
+                if (result.hasCircularRef && result.cyclePath) {
+                    circular.push(result.cyclePath);
+                    result.cyclePath.forEach((id) => checkedForCycles.add(id));
+                }
+            }
+        }
+        return {
+            valid: broken.length === 0 && circular.length === 0,
+            brokenReferences: broken,
+            circularReferences: circular,
+        };
+    }
+    getInheritanceChain(styleId) {
+        const chain = [];
+        const visited = new Set();
+        let current = this.getStyle(styleId);
+        if (!current) {
+            throw new Error(`Style '${styleId}' not found`);
+        }
+        while (current) {
+            const currentId = current.getStyleId();
+            if (visited.has(currentId)) {
+                const cycle = [...chain.map((s) => s.getStyleId()), currentId];
+                throw new Error(`Circular style reference detected: ${cycle.join(' -> ')}. ` +
+                    `Style '${currentId}' references itself through inheritance chain.`);
+            }
+            visited.add(currentId);
+            chain.unshift(current);
+            const props = current.getProperties();
+            current = props.basedOn ? this.getStyle(props.basedOn) : undefined;
+        }
+        return chain;
+    }
+    hasCircularReference(styleId) {
+        const visited = new Set();
+        const path = [];
+        let current = this.getStyle(styleId);
+        while (current) {
+            const currentId = current.getStyleId();
+            if (visited.has(currentId)) {
+                path.push(currentId);
+                return { hasCircularRef: true, cyclePath: path };
+            }
+            visited.add(currentId);
+            path.push(currentId);
+            const props = current.getProperties();
+            current = props.basedOn ? this.getStyle(props.basedOn) : undefined;
+        }
+        return { hasCircularRef: false };
+    }
+    getDerivedStyles(baseStyleId) {
+        return this.getAllStyles().filter((style) => style.getProperties().basedOn === baseStyleId);
+    }
+    exportStyle(styleId) {
+        const style = this.getStyle(styleId);
+        if (!style) {
+            throw new Error(`Style '${styleId}' not found`);
+        }
+        return JSON.stringify(style.getProperties(), null, 2);
+    }
+    importStyle(json) {
+        try {
+            const props = JSON.parse(json);
+            const style = Style.create(props);
+            this.addStyle(style);
+            return style;
+        }
+        catch (error) {
+            throw new Error(`Failed to import style: ${error instanceof Error ? error.message : 'Invalid JSON'}`);
+        }
+    }
+    exportAllStyles() {
+        const styles = this.getAllStyles().map((style) => style.getProperties());
+        return JSON.stringify(styles, null, 2);
+    }
+    importStyles(json) {
+        try {
+            const propsArray = JSON.parse(json);
+            if (!Array.isArray(propsArray)) {
+                throw new Error('JSON must contain an array of style properties');
+            }
+            const styles = [];
+            for (const props of propsArray) {
+                const style = Style.create(props);
+                this.addStyle(style);
+                styles.push(style);
+            }
+            return styles;
+        }
+        catch (error) {
+            throw new Error(`Failed to import styles: ${error instanceof Error ? error.message : 'Invalid JSON'}`);
+        }
+    }
+}
+//# sourceMappingURL=StylesManager.js.map