office-viewer 0.1.0

package/esm/openxml/word/numbering/Num.js

@@ -0,0 +1,46 @@
+import { __values } from '../../../node_modules/tslib/tslib.es6.js';
+import { getVal } from '../../../OpenXML.js';
+import { Lvl } from './Lvl.js';
+
+var Num = /** @class */ (function () {
+    function Num() {
+        this.lvlOverride = { lvls: {} };
+    }
+    Num.fromXML = function (word, element) {
+        var e_1, _a;
+        var num = new Num();
+        num.numId = element.getAttribute('w:numId') || '';
+        var abstractNumId = element.querySelector('abstractNumId');
+        if (abstractNumId) {
+            num.abstractNumId = getVal(abstractNumId);
+        }
+        var lvlOverride = element.querySelector('lvlOverride');
+        if (lvlOverride) {
+            try {
+                for (var _b = __values(lvlOverride.children), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var child = _c.value;
+                    var tagName = child.tagName;
+                    switch (tagName) {
+                        case 'w:lvl':
+                            var lvlId = child.getAttribute('w:lvlId') || '';
+                            num.lvlOverride.lvls[lvlId] = Lvl.fromXML(word, child);
+                            break;
+                        default:
+                            console.warn("Num: Unknown tag ", tagName, child);
+                    }
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+        }
+        return num;
+    };
+    return Num;
+}());
+
+export { Num };

package/esm/openxml/word/numbering/NumberProperties.d.ts

@@ -0,0 +1,6 @@
+import Word from '../../../Word';
+export declare class NumberPr {
+    ilvl: string;
+    numId: string;
+    static fromXML(word: Word, element: Element): NumberPr;
+}

package/esm/openxml/word/numbering/NumberProperties.js

@@ -0,0 +1,21 @@
+import { getVal } from '../../../OpenXML.js';
+
+var NumberPr = /** @class */ (function () {
+    function NumberPr() {
+    }
+    NumberPr.fromXML = function (word, element) {
+        var numPr = new NumberPr();
+        var ilvl = element.querySelector('ilvl');
+        if (ilvl) {
+            numPr.ilvl = getVal(ilvl);
+        }
+        var numId = element.querySelector('numId');
+        if (numId) {
+            numPr.numId = getVal(numId);
+        }
+        return numPr;
+    };
+    return NumberPr;
+}());
+
+export { NumberPr };

package/esm/openxml/word/numbering/Numbering.d.ts

@@ -0,0 +1,9 @@
+import Word from '../../../Word';
+import { AbstractNum } from './AbstractNum';
+import { Num } from './Num';
+export declare class Numbering {
+    abstractNums: Record<string, AbstractNum>;
+    nums: Record<string, Num>;
+    numData: Record<string, Record<string, number>>;
+    static fromXML(word: Word, element: Document): Numbering;
+}

package/esm/openxml/word/numbering/Numbering.js

@@ -0,0 +1,50 @@
+import { __values } from '../../../node_modules/tslib/tslib.es6.js';
+import { AbstractNum } from './AbstractNum.js';
+import { Num } from './Num.js';
+
+var Numbering = /** @class */ (function () {
+    function Numbering() {
+        this.abstractNums = {};
+        this.nums = {};
+        // 某个 numId 当前值，如果要重新渲染文档，需要将这个置空，
+        // 第一个 key 是 numId，第二个 key 是 ilvl，第一个 key 会自动初始化
+        this.numData = {};
+    }
+    Numbering.fromXML = function (word, element) {
+        var e_1, _a, e_2, _b;
+        var numbering = new Numbering();
+        try {
+            for (var _c = __values(element.getElementsByTagName('w:abstractNum')), _d = _c.next(); !_d.done; _d = _c.next()) {
+                var abstractNumElement = _d.value;
+                var abstractNum = AbstractNum.fromXML(word, abstractNumElement);
+                numbering.abstractNums[abstractNum.abstractNumId] = abstractNum;
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        try {
+            for (var _e = __values(element.getElementsByTagName('w:num')), _f = _e.next(); !_f.done; _f = _e.next()) {
+                var numElement = _f.value;
+                var num = Num.fromXML(word, numElement);
+                numbering.nums[num.numId] = num;
+                numbering.numData[num.numId] = {};
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        return numbering;
+    };
+    return Numbering;
+}());
+
+export { Numbering };

package/esm/openxml/word/properties/Properties.d.ts

@@ -0,0 +1,12 @@
+/**
+ * 属性通用设置项
+ */
+import { CSSStyle } from '../../Style';
+export interface Properties {
+    /**
+     * 解析后的 css 样式
+     */
+    cssStyle?: CSSStyle;
+    pStyle?: string;
+    rStyle?: string;
+}

package/esm/openxml/word/table/Tc.d.ts

@@ -0,0 +1,46 @@
+import Word from '../../../Word';
+import { CSSStyle } from '../../Style';
+import { Paragraph } from '../Paragraph';
+import { Table } from '../Table';
+import { ST_Merge } from '../../Types';
+export interface TcPr {
+    cssStyle?: CSSStyle;
+    hideMark?: false;
+    vMerge?: ST_Merge;
+    gridSpan?: number;
+    rowSpan?: number;
+    /**
+     * 内部 border，需要作用于非第一列的单元格
+     */
+    insideBorder?: {
+        H?: string;
+        V?: string;
+    };
+}
+type TcChild = Paragraph | Table;
+export declare function parseCellMargin(element: Element, style: CSSStyle): void;
+export declare function parseTblCellSpacing(element: Element, style: CSSStyle): void;
+/**
+ * parseBorders 不支持 insideH 和 insideV，所以单独支持一下
+ * 实际显示时需要过滤掉第一列
+ */
+export declare function parseInsideBorders(word: Word, element: Element): {
+    H: string | undefined;
+    V: string | undefined;
+};
+/**
+ * http://officeopenxml.com/WPtableWidth.php
+ */
+export declare function parseTblWidth(element: Element): string;
+export declare class Tc {
+    properties: TcPr;
+    children: TcChild[];
+    add(child: TcChild): void;
+    static parseTcPr(word: Word, element: Element): TcPr;
+    static fromXML(word: Word, element: Element, currentCol: {
+        index: number;
+    }, rowSpanMap: {
+        [key: string]: Tc;
+    }): Tc | null;
+}
+export {};

package/esm/openxml/word/table/Tc.js

@@ -0,0 +1,234 @@
+import { __values } from '../../../node_modules/tslib/tslib.es6.js';
+import { getVal, getValNumber, getValBoolean } from '../../../OpenXML.js';
+import { Paragraph } from '../Paragraph.js';
+import { Table } from '../Table.js';
+import { parseSize, LengthUsage } from '../../../parse/parseSize.js';
+import { parseShdColor } from '../../../parse/parseColor.js';
+import { parseBorders, parseBorder } from '../../../parse/parseBorder.js';
+import { parseTextDirection } from '../../../parse/parseTextDirection.js';
+import { ST_Merge, ST_VerticalJc, ST_TblWidth } from '../../Types.js';
+
+// http://officeopenxml.com/WPtableCellProperties-Margins.php
+function parseCellMargin(element, style) {
+    var e_1, _a;
+    try {
+        for (var _b = __values(element.children), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var child = _c.value;
+            var tagName = child.tagName;
+            switch (tagName) {
+                case 'w:left':
+                case 'w:start':
+                    style['padding-left'] = parseSize(child, 'w:w');
+                    break;
+                case 'w:right':
+                case 'w:end':
+                    style['padding-right'] = parseSize(child, 'w:w');
+                    break;
+                case 'w:top':
+                    style['padding-top'] = parseSize(child, 'w:w');
+                    break;
+                case 'w:bottom':
+                    style['padding-bottom'] = parseSize(child, 'w:w');
+                    break;
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+}
+function parseVAlign(element, style) {
+    var vAlign = getVal(element);
+    switch (vAlign) {
+        case ST_VerticalJc.bottom:
+            style['vertical-align'] = 'bottom';
+            break;
+        case ST_VerticalJc.center:
+            style['vertical-align'] = 'middle';
+            break;
+        case ST_VerticalJc.top:
+            style['vertical-align'] = 'top';
+            break;
+    }
+}
+function parseTblCellSpacing(element, style) {
+    var width = parseTblWidth(element);
+    if (width) {
+        style['cell-spacing'] = width;
+    }
+}
+/**
+ * parseBorders 不支持 insideH 和 insideV，所以单独支持一下
+ * 实际显示时需要过滤掉第一列
+ */
+function parseInsideBorders(word, element) {
+    var H;
+    var insideH = element.querySelector('insideH');
+    if (insideH) {
+        H = parseBorder(word, insideH);
+    }
+    var V;
+    var insideV = element.querySelector('insideV');
+    if (insideV) {
+        V = parseBorder(word, insideV);
+    }
+    return {
+        H: H,
+        V: V
+    };
+}
+/**
+ * http://officeopenxml.com/WPtableWidth.php
+ */
+function parseTblWidth(element) {
+    var type = element.getAttribute('w:type');
+    if (!type || type === ST_TblWidth.dxa) {
+        return parseSize(element, 'w:w');
+    }
+    else if (type === ST_TblWidth.pct) {
+        return parseSize(element, 'w:w', LengthUsage.Percent);
+    }
+    else if (type === ST_TblWidth.auto) {
+        return 'auto';
+    }
+    else {
+        console.warn('parseTblWidth: ignore type', type, element);
+    }
+    return '';
+}
+function parseTcW(element, style) {
+    var width = parseTblWidth(element);
+    if (width) {
+        style.width = width;
+    }
+}
+var Tc = /** @class */ (function () {
+    function Tc() {
+        this.properties = {};
+        this.children = [];
+    }
+    Tc.prototype.add = function (child) {
+        if (child) {
+            this.children.push(child);
+        }
+    };
+    Tc.parseTcPr = function (word, element) {
+        var e_2, _a;
+        var properties = {};
+        var style = {};
+        properties.cssStyle = style;
+        try {
+            for (var _b = __values(element.children), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var child = _c.value;
+                var tagName = child.tagName;
+                switch (tagName) {
+                    case 'w:tcMar':
+                        parseCellMargin(child, style);
+                        break;
+                    case 'w:shd':
+                        style['background-color'] = parseShdColor(word, child);
+                        break;
+                    case 'w:tcW':
+                        parseTcW(child, style);
+                        break;
+                    case 'w:noWrap':
+                        // http://webapp.docx4java.org/OnlineDemo/ecma376/WordML/noWrap.html
+                        var noWrap = getValBoolean(child);
+                        if (noWrap) {
+                            style['white-space'] = 'nowrap';
+                        }
+                        break;
+                    case 'w:vAlign':
+                        parseVAlign(child, style);
+                        break;
+                    case 'w:tcBorders':
+                        parseBorders(word, child, style);
+                        properties.insideBorder = parseInsideBorders(word, child);
+                        break;
+                    case 'w:gridSpan':
+                        properties.gridSpan = getValNumber(child);
+                        break;
+                    case 'w:vMerge':
+                        properties.vMerge = getVal(child) || ST_Merge.continue;
+                        break;
+                    case 'w:textDirection':
+                        parseTextDirection(child, style);
+                        break;
+                    case 'w:cnfStyle':
+                        // 目前是自动计算的，所以不需要这个了
+                        break;
+                    default:
+                        console.warn('parseTcPr: ignore', tagName, child);
+                }
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        return properties;
+    };
+    Tc.fromXML = function (word, element, currentCol, rowSpanMap) {
+        var e_3, _a;
+        var tc = new Tc();
+        try {
+            for (var _b = __values(element.children), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var child = _c.value;
+                var tagName = child.tagName;
+                switch (tagName) {
+                    case 'w:tcPr':
+                        tc.properties = Tc.parseTcPr(word, child);
+                        break;
+                    case 'w:p':
+                        tc.add(Paragraph.fromXML(word, child));
+                        break;
+                    case 'w:tbl':
+                        tc.add(Table.fromXML(word, child));
+                        break;
+                }
+            }
+        }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_3) throw e_3.error; }
+        }
+        var lastCol = rowSpanMap[currentCol.index];
+        // 如果是 continue 意味着这个被合并了
+        if (tc.properties.vMerge) {
+            if (tc.properties.vMerge === ST_Merge.restart) {
+                tc.properties.rowSpan = 1;
+                rowSpanMap[currentCol.index] = tc;
+            }
+            else if (lastCol) {
+                if (lastCol.properties && lastCol.properties.rowSpan) {
+                    lastCol.properties.rowSpan = lastCol.properties.rowSpan + 1;
+                    var colSpan_1 = tc.properties.gridSpan || 1;
+                    currentCol.index += colSpan_1;
+                    return null;
+                }
+                else {
+                    console.warn('Tc.fromXML: continue but not found lastCol', currentCol.index, tc, rowSpanMap);
+                }
+            }
+        }
+        else {
+            delete rowSpanMap[currentCol.index];
+        }
+        var colSpan = tc.properties.gridSpan || 1;
+        currentCol.index += colSpan;
+        return tc;
+    };
+    return Tc;
+}());
+
+export { Tc, parseCellMargin, parseInsideBorders, parseTblCellSpacing, parseTblWidth };

package/esm/openxml/word/table/Tr.d.ts

@@ -0,0 +1,18 @@
+import { CSSStyle } from '../../Style';
+import { Tc } from './Tc';
+import Word from '../../../Word';
+export interface TrPr {
+    cssStyle?: CSSStyle;
+    /**
+     * 单元格样式
+     */
+    tcStyle?: CSSStyle;
+}
+export declare class Tr {
+    properties: TrPr;
+    tcs: Tc[];
+    static parseTrPr(word: Word, element: Element): TrPr;
+    static fromXML(word: Word, element: Element, rowSpanMap: {
+        [key: string]: Tc;
+    }): Tr;
+}

package/esm/openxml/word/table/Tr.js

@@ -0,0 +1,106 @@
+import { __values } from '../../../node_modules/tslib/tslib.es6.js';
+import { getVal, getValBoolean } from '../../../OpenXML.js';
+import { parseTblCellSpacing, Tc } from './Tc.js';
+import { parseTrHeight } from '../../../parse/parseTrHeight.js';
+import { jcToTextAlign } from '../../../parse/jcToTextAlign.js';
+import { Table } from '../Table.js';
+
+var Tr = /** @class */ (function () {
+    function Tr() {
+        this.properties = {};
+        this.tcs = [];
+    }
+    Tr.parseTrPr = function (word, element) {
+        var e_1, _a;
+        var cssStyle = {};
+        var tcStyle = {};
+        try {
+            for (var _b = __values(element.children), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var child = _c.value;
+                var tagName = child.tagName;
+                switch (tagName) {
+                    case 'w:hidden':
+                        if (getValBoolean(child)) {
+                            cssStyle.display = 'none';
+                        }
+                        break;
+                    case 'w:trHeight':
+                        parseTrHeight(child, cssStyle);
+                        break;
+                    case 'w:jc':
+                        cssStyle['text-align'] = jcToTextAlign(getVal(child));
+                        break;
+                    case 'w:cantSplit':
+                        // 目前也不支持分页
+                        break;
+                    case 'w:tblPrEx':
+                        // http://webapp.docx4java.org/OnlineDemo/ecma376/WordML/tblPrEx_1.html
+                        var tablePr = Table.parseTablePr(word, child);
+                        Object.assign(cssStyle, tablePr.cssStyle);
+                        break;
+                    case 'w:tblCellSpacing':
+                        parseTblCellSpacing(child, tcStyle);
+                        break;
+                    case 'w:cnfStyle':
+                        // 目前是自动计算的，所以不需要这个了
+                        break;
+                    default:
+                        console.warn("Tr: Unknown tag ", tagName, child);
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return {
+            cssStyle: cssStyle
+        };
+    };
+    Tr.fromXML = function (word, element, rowSpanMap) {
+        var e_2, _a;
+        var tr = new Tr();
+        // 做成对象是为了传递引用来修改
+        var currentCol = {
+            index: 0
+        };
+        try {
+            for (var _b = __values(element.children), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var child = _c.value;
+                var tagName = child.tagName;
+                switch (tagName) {
+                    case 'w:tc':
+                        var tc = Tc.fromXML(word, child, currentCol, rowSpanMap);
+                        if (tc) {
+                            tr.tcs.push(tc);
+                        }
+                        break;
+                    case 'w:trPr':
+                        tr.properties = Tr.parseTrPr(word, child);
+                        break;
+                    case 'w:tblPrEx':
+                        // http://webapp.docx4java.org/OnlineDemo/ecma376/WordML/tblPrEx_1.html
+                        var tablePr = Table.parseTablePr(word, child);
+                        Object.assign(tr.properties.cssStyle || {}, tablePr.cssStyle);
+                        break;
+                    default:
+                        console.warn("Tr: Unknown tag ", tagName, child);
+                }
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        return tr;
+    };
+    return Tr;
+}());
+
+export { Tr };

package/esm/package/PackageParser.d.ts

@@ -0,0 +1,26 @@
+/**
+ * 文件加载器默认是直接读取 zip，如果要对文件做特殊加密处理，可以实现这个接口
+ */
+export interface PackageParser {
+    load(docxFile: ArrayBuffer | string): void;
+    /**
+     * 读取 xml 文件，转成 json 对象
+     * @param filePath 文件路径
+     * @returns 转成 json 的结果
+     */
+    getXML(filePath: string): Document;
+    /**
+     * 根据类型读取文件
+     */
+    getFileByType(filePath: string, type: 'string' | 'blob'): string | Blob;
+    /**
+     * 文件是否存在
+     */
+    fileExists(filePath: string): boolean;
+    /**
+     * 生成新的 zip 文件
+     *
+     * @param docContent 新的 word/document.xml 文件内容
+     */
+    generateZip(docContent: string): Blob;
+}

package/esm/package/XMLPackageParser.d.ts

@@ -0,0 +1,31 @@
+/**
+ * openxml 默认是 zip 格式，导致构造比较麻烦，所以增加了这种单一格式，所有内容都放在一个 xml 文件里
+ */
+import { PackageParser } from './PackageParser';
+export default class XMLPackageParser implements PackageParser {
+    private xml;
+    private files;
+    private contentTypesDoc;
+    /**
+     * 加载 zip 文件
+     */
+    load(fileContent: ArrayBuffer | string): void;
+    /**
+     * 读取 xml 文件，转成 json 对象
+     * @param filePath 文件路径
+     * @returns 转成 json 的结果
+     */
+    getXML(filePath: string): Document;
+    /**
+     * 在 xml 下基本不用这个
+     */
+    getFileByType(filePath: string, type: 'string' | 'blob'): string;
+    /**
+     * 判断文件是否存在
+     */
+    fileExists(filePath: string): boolean;
+    /**
+     * 生成 zip 文件
+     */
+    generateZip(docContent: string): Blob;
+}

package/esm/package/ZipPackageParser.d.ts

@@ -0,0 +1,29 @@
+/**
+ * zip 文件解析
+ */
+import { PackageParser } from './PackageParser';
+export default class ZipPackageParser implements PackageParser {
+    private zip;
+    /**
+     * 加载 zip 文件
+     */
+    load(docxFile: ArrayBuffer): void;
+    /**
+     * 读取 xml 文件，转成 json 对象
+     * @param filePath 文件路径
+     * @returns 转成 json 的结果
+     */
+    getXML(filePath: string): Document;
+    /**
+     * 根据类型读取文件
+     */
+    getFileByType(filePath: string, type: 'string' | 'blob'): string | Blob;
+    /**
+     * 判断文件是否存在
+     */
+    fileExists(filePath: string): boolean;
+    /**
+     * 生成新的 zip 文件
+     */
+    generateZip(docContent: string): Blob;
+}