office-viewer 0.1.0 → 0.1.3

package/lib/parse/parseShape.js

@@ -0,0 +1,247 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var OpenXML = require('../OpenXML.js');
+
+/**
+ * 解析 shape
+ */
+function parsePts(element) {
+    var e_1, _a;
+    var pts = [];
+    try {
+        for (var _b = tslib.__values(element.children), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var child = _c.value;
+            var tagName = child.tagName;
+            if (tagName === 'a:pt' || tagName === 'pt') {
+                var x = child.getAttribute('x');
+                var y = child.getAttribute('y');
+                if (x && y) {
+                    pts.push({ x: x, y: y });
+                }
+            }
+            else {
+                console.warn('unknown pt', 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 pts;
+}
+// http://webapp.docx4java.org/OnlineDemo/ecma376/DrawingML/path_2.html
+function parsePath(element) {
+    var e_2, _a;
+    var pathChild = [];
+    try {
+        for (var _b = tslib.__values(element.children), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var child = _c.value;
+            var tagName = child.tagName;
+            switch (tagName) {
+                case 'a:moveTo':
+                case 'moveTo':
+                    var moveToPt = parsePts(child);
+                    if (moveToPt.length) {
+                        var moveTo_1 = {
+                            type: 'moveTo',
+                            pt: moveToPt[0]
+                        };
+                        pathChild.push(moveTo_1);
+                    }
+                    break;
+                case 'a:lnTo':
+                case 'lnTo':
+                    var lnToPt = parsePts(child);
+                    if (lnToPt.length) {
+                        var lnTo = {
+                            type: 'lnTo',
+                            pt: lnToPt[0]
+                        };
+                        pathChild.push(lnTo);
+                    }
+                    break;
+                case 'a:quadBezTo':
+                case 'quadBezTo':
+                    var quadBezToPt = parsePts(child);
+                    if (quadBezToPt.length) {
+                        var quadBezTo = {
+                            type: 'quadBezTo',
+                            pts: quadBezToPt
+                        };
+                        pathChild.push(quadBezTo);
+                    }
+                    break;
+                case 'a:cubicBezTo':
+                case 'cubicBezTo':
+                    var cubicBezToPt = parsePts(child);
+                    if (cubicBezToPt.length) {
+                        var cubicBezTo = {
+                            type: 'cubicBezTo',
+                            pts: cubicBezToPt
+                        };
+                        pathChild.push(cubicBezTo);
+                    }
+                    break;
+                case 'a:arcTo':
+                case 'arcTo':
+                    var wR = child.getAttribute('wR');
+                    var hR = child.getAttribute('hR');
+                    var stAng = child.getAttribute('stAng');
+                    var swAng = child.getAttribute('swAng');
+                    if (wR && hR && stAng && swAng) {
+                        var arcTo = {
+                            type: 'arcTo',
+                            wR: wR,
+                            hR: hR,
+                            stAng: stAng,
+                            swAng: swAng
+                        };
+                        pathChild.push(arcTo);
+                    }
+                    break;
+                case 'a:close':
+                case 'close':
+                    pathChild.push({
+                        type: 'close'
+                    });
+                    break;
+                default:
+                    console.warn('parsePath: 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; }
+    }
+    var path = { defines: pathChild };
+    var fill = element.getAttribute('fill');
+    if (fill) {
+        path.fill = fill;
+    }
+    path.extrusionOk = OpenXML.getAttrBoolean(element, 'extrusionOk', false);
+    path.stroke = OpenXML.getAttrBoolean(element, 'stroke', true);
+    var w = element.getAttribute('w');
+    if (w) {
+        path.w = parseInt(w, 10);
+    }
+    var h = element.getAttribute('h');
+    if (h) {
+        path.h = parseInt(h, 10);
+    }
+    return path;
+}
+function parsePathLst(element) {
+    var e_3, _a;
+    var pathLst = [];
+    try {
+        for (var _b = tslib.__values(element.children), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var child = _c.value;
+            var tagName = child.tagName;
+            switch (tagName) {
+                case 'a:path':
+                case 'path':
+                    pathLst.push(parsePath(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; }
+    }
+    return pathLst;
+}
+function parseShapeGuide(element) {
+    var e_4, _a;
+    var gds = [];
+    try {
+        for (var _b = tslib.__values(element.children), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var child = _c.value;
+            var tagName = child.tagName;
+            switch (tagName) {
+                case 'a:gd':
+                case 'gd':
+                    var name_1 = child.getAttribute('name');
+                    var fmla = child.getAttribute('fmla');
+                    if (name_1 && fmla) {
+                        var gd = {
+                            n: name_1,
+                            f: fmla
+                        };
+                        gds.push(gd);
+                    }
+                    break;
+            }
+        }
+    }
+    catch (e_4_1) { e_4 = { error: e_4_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_4) throw e_4.error; }
+    }
+    return gds;
+}
+function parseShape(element) {
+    var e_5, _a;
+    var shape = {};
+    try {
+        for (var _b = tslib.__values(element.children), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var child = _c.value;
+            var tagName = child.tagName;
+            switch (tagName) {
+                case 'a:avLst':
+                case 'avLst':
+                    shape.avLst = parseShapeGuide(child);
+                    break;
+                case 'a:gdLst':
+                case 'gdLst':
+                    shape.gdLst = parseShapeGuide(child);
+                    break;
+                case 'a:rect':
+                case 'react':
+                    var rect = {
+                        b: child.getAttribute('b') || '',
+                        l: child.getAttribute('l') || '',
+                        r: child.getAttribute('r') || '',
+                        t: child.getAttribute('t') || ''
+                    };
+                    shape.rect = rect;
+                    break;
+                case 'a:pathLst':
+                case 'pathLst':
+                    shape.pathLst = parsePathLst(child);
+                    break;
+            }
+        }
+    }
+    catch (e_5_1) { e_5 = { error: e_5_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_5) throw e_5.error; }
+    }
+    return shape;
+}
+
+exports.parsePath = parsePath;
+exports.parsePathLst = parsePathLst;
+exports.parsePts = parsePts;
+exports.parseShape = parseShape;
+exports.parseShapeGuide = parseShapeGuide;

package/lib/parse/parseSize.d.ts

@@ -12,7 +12,8 @@ export declare function convertLength(val: string, usage?: LengthUsageType): str
  * 转换布尔值
  */
 export declare function convertBoolean(v: string, defaultValue?: boolean): boolean;
-export declare function convertPercentage(val: string): number;
+export declare function convertPercentage(val: string | null): number;
+export declare function convertAngle(val: string | null): number;
 /**
  * 解析尺寸，返回 css 值
  *

package/lib/parse/parseSize.js

@@ -5,6 +5,9 @@ Object.defineProperty(exports, '__esModule', { value: true });
 /**
  * 单位相关的解析，参考了 docxjs 里的实现
  */
+/**
+ * 单位转成 px，这样才能和 svg 里的一致
+ */
 var ptToPx = 1.3333;
 var LengthUsage = {
     Dxa: { mul: ptToPx * 0.05, unit: 'px' },
@@ -23,6 +26,9 @@ function convertLength(val, usage) {
     }
     return "".concat((parseInt(val) * usage.mul).toFixed(2)).concat(usage.unit);
 }
+function convertAngle(val) {
+    return val ? parseInt(val) / 60000 : 0;
+}
 /**
  * 解析尺寸，返回 css 值
  *
@@ -40,5 +46,6 @@ function parseSize(element, attrName, usage) {
 }
 
 exports.LengthUsage = LengthUsage;
+exports.convertAngle = convertAngle;
 exports.convertLength = convertLength;
 exports.parseSize = parseSize;

package/lib/parse/parseSpacing.js

@@ -38,7 +38,7 @@ function parseSpacing(word, element, style) {
                 break;
             default:
                 var lineHeightMin = Math.max(minLineHeight, lineNum / 20);
-                style['line-height'] = style['min-height'] = "".concat(lineHeightMin, "pt");
+                style['line-height'] = "".concat(lineHeightMin, "pt");
                 break;
         }
     }

package/lib/parse/parseTable.d.ts

@@ -0,0 +1,3 @@
+import { Table } from '../openxml/word/Table';
+import Word from '../Word';
+export declare function parseTable(word: Word, element: Element): Table;

package/lib/parse/parseTable.js

@@ -0,0 +1,66 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var Table = require('../openxml/word/Table.js');
+var parseTr = require('./parseTr.js');
+var parseTablePr = require('./parseTablePr.js');
+var parseSize = require('./parseSize.js');
+var mergeSdt = require('./mergeSdt.js');
+
+function parseTblGrid(element) {
+    var e_1, _a;
+    var gridCol = [];
+    var gridColElements = element.getElementsByTagName('w:gridCol');
+    try {
+        for (var gridColElements_1 = tslib.__values(gridColElements), gridColElements_1_1 = gridColElements_1.next(); !gridColElements_1_1.done; gridColElements_1_1 = gridColElements_1.next()) {
+            var gridColElement = gridColElements_1_1.value;
+            var w = parseSize.parseSize(gridColElement, 'w:w');
+            gridCol.push({ w: w });
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (gridColElements_1_1 && !gridColElements_1_1.done && (_a = gridColElements_1.return)) _a.call(gridColElements_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return gridCol;
+}
+function parseTable(word, element) {
+    var e_2, _a;
+    var table = new Table.Table();
+    // 用于计算列的跨行，这里记下前面的跨行情况
+    var rowSpanMap = {};
+    try {
+        for (var _b = tslib.__values(mergeSdt.mergeSdt(element)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var child = _c.value;
+            var tagName = child.tagName;
+            switch (tagName) {
+                case 'w:tblPr':
+                    table.properties = parseTablePr.parseTablePr(word, child);
+                    break;
+                case 'w:tr':
+                    table.trs.push(parseTr.parseTr(word, child, rowSpanMap));
+                    break;
+                case 'w:tblGrid':
+                    table.tblGrid = parseTblGrid(child);
+                    break;
+                default:
+                    console.warn('Table.fromXML 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 table;
+}
+
+exports.parseTable = parseTable;

package/lib/parse/parseTablePr.d.ts

@@ -0,0 +1,3 @@
+import { TablePr } from '../openxml/word/Table';
+import Word from '../Word';
+export declare function parseTablePr(word: Word, element: Element): TablePr;

package/lib/parse/parseTablePr.js

@@ -0,0 +1,189 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var OpenXML = require('../OpenXML.js');
+var parseBorder = require('./parseBorder.js');
+var parseInsideBorders = require('./parseInsideBorders.js');
+var parseTblWidth = require('./parseTblWidth.js');
+var parseColor = require('./parseColor.js');
+var parseSize = require('./parseSize.js');
+var parseTcPr = require('./parseTcPr.js');
+var parseCellMargin = require('./parseCellMargin.js');
+
+/**
+ * 表格的 jc 需要使用 float 来实现
+ * http://officeopenxml.com/WPtableAlignment.php
+ */
+function parseTblJc(element, cssStyle) {
+    var val = OpenXML.getVal(element);
+    switch (val) {
+        case 'left':
+        case 'start':
+            // TODO: 会导致前面的文字掉下去，感觉还是不能支持这个功能
+            // cssStyle['float'] = 'left';
+            break;
+        case 'right':
+        case 'end':
+            cssStyle['float'] = 'right';
+    }
+}
+/**
+ * 这个其实分左右，但目前只支持左，右可能是阿拉伯语？
+ * http://webapp.docx4java.org/OnlineDemo/ecma376/WordML/tblInd_2.html
+ */
+function parseTblInd(element, style) {
+    var width = parseTblWidth.parseTblWidth(element);
+    if (width) {
+        style['margin-left'] = width;
+    }
+}
+function parseTblW(element, style) {
+    var width = parseTblWidth.parseTblWidth(element);
+    if (width) {
+        style['width'] = width;
+    }
+}
+// http://webapp.docx4java.org/OnlineDemo/ecma376/WordML/ST_TblStyleOverrideType.html
+// val 是旧的格式
+function parseTblLook(child) {
+    var tblLook = {};
+    var tblLookVal = OpenXML.getValHex(child);
+    if (OpenXML.getAttrBoolean(child, 'firstRow', false) || tblLookVal & 0x0020) {
+        tblLook['firstRow'] = true;
+    }
+    if (OpenXML.getAttrBoolean(child, 'lastRow', false) || tblLookVal & 0x0040) {
+        tblLook['lastRow'] = true;
+    }
+    if (OpenXML.getAttrBoolean(child, 'firstColumn', false) || tblLookVal & 0x0080) {
+        tblLook['firstColumn'] = true;
+    }
+    if (OpenXML.getAttrBoolean(child, 'lastColumn', false) || tblLookVal & 0x0100) {
+        tblLook['lastColumn'] = true;
+    }
+    if (OpenXML.getAttrBoolean(child, 'noHBand', false) || tblLookVal & 0x0200) {
+        tblLook['noHBand'] = true;
+    }
+    else {
+        tblLook['noHBand'] = false;
+    }
+    if (OpenXML.getAttrBoolean(child, 'noVBand', false) || tblLookVal & 0x0400) {
+        tblLook['noVBand'] = true;
+    }
+    else {
+        tblLook['noVBand'] = false;
+    }
+    return tblLook;
+}
+/**
+ * http://webapp.docx4java.org/OnlineDemo/ecma376/WordML/tblpPr.html
+ * 只支持部分
+ */
+function parseTblpPr(word, child, style) {
+    // 如果设置 padding 会导致绝对定位不准确，所以一旦设置就不支持
+    if (typeof word.renderOptions.padding === 'undefined') {
+        var tplpX = parseSize.parseSize(child, 'w:tblpX');
+        var tplpY = parseSize.parseSize(child, 'w:tblpY');
+        // style.position = 'absolute';
+        style.top = tplpY;
+        style.left = tplpX;
+    }
+    // 之前想用 float 来实现，但是会导致文字掉下去
+    // const topFromText = parseSize(child, 'w:topFromText');
+    // const bottomFromText = parseSize(child, 'w:bottomFromText');
+    // const rightFromText = parseSize(child, 'w:rightFromText');
+    // const leftFromText = parseSize(child, 'w:leftFromText');
+    // style['float'] = 'left';
+    // style['margin-bottom'] = addSize(style['margin-bottom'], bottomFromText);
+    // style['margin-left'] = addSize(style['margin-left'], leftFromText);
+    // style['margin-right'] = addSize(style['margin-right'], rightFromText);
+    // style['margin-top'] = addSize(style['margin-top'], topFromText);
+}
+/**
+ * http://officeopenxml.com/WPtableLayout.php
+ */
+function parseTblLayout(element, style) {
+    var type = element.getAttribute('w:type');
+    if (type === 'fixed') {
+        style['table-layout'] = 'fixed';
+    }
+}
+function parseTablePr(word, element) {
+    var e_1, _a;
+    var properties = {};
+    var tableStyle = {};
+    var tcStyle = {};
+    properties.tblLook = {};
+    properties.cssStyle = tableStyle;
+    properties.tcCSSStyle = tcStyle;
+    try {
+        for (var _b = tslib.__values(element.children), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var child = _c.value;
+            var tagName = child.tagName;
+            switch (tagName) {
+                case 'w:tblBorders':
+                    parseBorder.parseBorders(word, child, tableStyle);
+                    properties.insideBorder = parseInsideBorders.parseInsideBorders(word, child);
+                    break;
+                case 'w:tcBorders':
+                    parseBorder.parseBorders(word, child, tableStyle);
+                    break;
+                case 'w:tblInd':
+                    parseTblInd(child, tableStyle);
+                    break;
+                case 'w:jc':
+                    parseTblJc(child, tableStyle);
+                    break;
+                case 'w:tblCellMar':
+                case 'w:tcMar':
+                    // http://webapp.docx4java.org/OnlineDemo/ecma376/WordML/tblCellMar_1.html
+                    parseCellMargin.parseCellMargin(child, tcStyle);
+                    break;
+                case 'w:tblStyle':
+                    properties.pStyle = OpenXML.getVal(child);
+                    break;
+                case 'w:tblW':
+                    parseTblW(child, tableStyle);
+                    break;
+                case 'w:shd':
+                    // http://officeopenxml.com/WPtableShading.php
+                    tableStyle['background-color'] = parseColor.parseShdColor(word, child);
+                    break;
+                case 'w:tblCaption':
+                    properties.tblCaption = OpenXML.getVal(child);
+                    break;
+                case 'w:tblCellSpacing':
+                    parseTcPr.parseTblCellSpacing(child, tableStyle);
+                    break;
+                case 'w:tblLayout':
+                    parseTblLayout(child, tableStyle);
+                    break;
+                case 'w:tblLook':
+                    properties.tblLook = parseTblLook(child);
+                    break;
+                case 'w:tblStyleRowBandSize':
+                    properties.rowBandSize = OpenXML.getValNumber(child);
+                    break;
+                case 'w:tblStyleColBandSize':
+                    properties.colBandSize = OpenXML.getValNumber(child);
+                    break;
+                case 'w:tblpPr':
+                    parseTblpPr(word, child, tableStyle);
+                    break;
+                default:
+                    console.warn('parseTableProperties 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 properties;
+}
+
+exports.parseTablePr = parseTablePr;

package/lib/parse/parseTblWidth.d.ts

@@ -0,0 +1,4 @@
+/**
+ * http://officeopenxml.com/WPtableWidth.php
+ */
+export declare function parseTblWidth(element: Element): string;

package/lib/parse/parseTblWidth.js

@@ -0,0 +1,27 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var parseSize = require('./parseSize.js');
+
+/**
+ * http://officeopenxml.com/WPtableWidth.php
+ */
+function parseTblWidth(element) {
+    var type = element.getAttribute('w:type');
+    if (!type || type === 'dxa') {
+        return parseSize.parseSize(element, 'w:w');
+    }
+    else if (type === 'pct') {
+        return parseSize.parseSize(element, 'w:w', parseSize.LengthUsage.Percent);
+    }
+    else if (type === 'auto') {
+        return 'auto';
+    }
+    else {
+        console.warn('parseTblWidth: ignore type', type, element);
+    }
+    return '';
+}
+
+exports.parseTblWidth = parseTblWidth;

package/lib/parse/parseTc.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 拆分出来主要是为了避免循环引用
+ */
+import { Tc } from '../openxml/word/table/Tc';
+import Word from '../Word';
+export declare function parseTc(word: Word, element: Element, currentCol: {
+    index: number;
+}, rowSpanMap: {
+    [key: string]: Tc;
+}): Tc | null;

package/lib/parse/parseTc.js

@@ -0,0 +1,68 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var Tc = require('../openxml/word/table/Tc.js');
+var parseTcPr = require('./parseTcPr.js');
+var Paragraph = require('../openxml/word/Paragraph.js');
+var parseTable = require('./parseTable.js');
+
+/**
+ * 拆分出来主要是为了避免循环引用
+ */
+function parseTc(word, element, currentCol, rowSpanMap) {
+    var e_1, _a;
+    var tc = new Tc.Tc();
+    try {
+        for (var _b = tslib.__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 = parseTcPr.parseTcPr(word, child);
+                    break;
+                case 'w:p':
+                    tc.add(Paragraph.Paragraph.fromXML(word, child));
+                    break;
+                case 'w:tbl':
+                    tc.add(parseTable.parseTable(word, child));
+                    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; }
+    }
+    var lastCol = rowSpanMap[currentCol.index];
+    // 如果是 continue 意味着这个被合并了
+    if (tc.properties.vMerge) {
+        if (tc.properties.vMerge === '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;
+}
+
+exports.parseTc = parseTc;

package/lib/parse/parseTcPr.d.ts

@@ -0,0 +1,5 @@
+import { CSSStyle } from '../openxml/Style';
+import { TcPr } from '../openxml/word/table/Tc';
+import Word from '../Word';
+export declare function parseTblCellSpacing(element: Element, style: CSSStyle): void;
+export declare function parseTcPr(word: Word, element: Element): TcPr;