@progress/kendo-spreadsheet-common 1.1.3-develop.1 → 1.1.3-develop.2

package/dist/index.js

@@ -2486,13 +2486,13 @@
         }
     }
 
-    function limitPrecision$1(num) {
-        return num === parseInt(num, 10) ? num : +num.toPrecision(16);
+    function limitPrecision$1(num, digits) {
+        return num === parseInt(num, 10) ? num : +num.toPrecision(digits || 16);
     }
 
-    function maybeRoundFloatErrors(num) {
+    function maybeRoundFloatErrors(num, digits) {
         if (typeof num == "number") {
-            return limitPrecision$1(num);
+            return limitPrecision$1(num, digits);
         } else {
             return num;
         }
@@ -5651,6 +5651,10 @@
                     // try global name
                     val = this.workbook.nameValue(this._displayString(ref.name));
                 }
+                if (val == null) {
+                    // try without _displayString
+                    val = this.workbook.nameValue(ref.print()) || this.workbook.nameValue(ref.name);
+                }
             }
             if (val instanceof Ref) {
                 val = val.absolute(frow, fcol);
@@ -8869,6 +8873,7 @@
                     sheet._set(ref, propName, propValue);
                 };
 
+                let isValue = false;
                 for (ci = topLeftCol; ci <= bottomRightCol; ci ++) {
                     if (!isAutofill && sheet.isHiddenColumn(ci)) {
                         continue;
@@ -8884,12 +8889,14 @@
                         if (row) {
                             data = row[ci - topLeftCol];
                             if (data) {
-                                Object.keys(data).forEach(setProp);
+                                const keys = Object.keys(data);
+                                keys.forEach(setProp);
+                                isValue = isValue || keys.includes("value");
                             }
                         }
                     }
                 }
-                sheet.triggerChange({ recalc: true, ref: this._ref });
+                sheet.triggerChange({ recalc: true, ref: this._ref, isValue: isValue });
                 return this;
             }
         }
@@ -8902,7 +8909,8 @@
 
             let reason = {
                 recalc: clearAll || options.contentsOnly,
-                ref: this._ref
+                ref: this._ref,
+                isValue: true
             };
 
             sheet.batch(function() {
@@ -16173,7 +16181,7 @@
             if (data.__dataType) {
                 type = data.__dataType;
             }
-        } else if (data !== null && data !== undefined) {
+        } else if (data != null) {
             if (cell.html) {
                 data = dom.html(data);
             } else {
@@ -16208,6 +16216,17 @@
         }
         if (cell.merged) {
             classNames.push("k-spreadsheet-merged-cell");
+            if (!cell.enable) {
+                collection.push(dom.element("div", {
+                    className: "k-spreadsheet-disabled-mask",
+                    style: {
+                        left: (cell.left + 1) + "px",
+                        top: (cell.top + 1) + "px",
+                        width: (cell.width - 1) + "px",
+                        height: (cell.height - 1) + "px"
+                    }
+                }));
+            }
         }
         if (cell.comment) {
             classNames.push("k-spreadsheet-has-comment");
@@ -17814,27 +17833,43 @@
             }
         }
 
+        let attrs = { style: style };
+
         if (!style.textAlign) {
             switch (type) {
-            case "number":
-            case "date":
-            case "percent":
-            case "currency":
-                style.textAlign = "right";
-                break;
-            case "boolean":
-                style.textAlign = "center";
+                case "number":
+                case "date":
+                case "percent":
+                case "currency":
+                    style.textAlign = "right";
+                    break;
+                case "boolean":
+                    style.textAlign = "center";
                 break;
             }
         }
 
+        if (!/^(?:string|undefined)$/.test(type)) {
+            // provide original value and number format for better
+            // interoperability with google sheets and libre office.
+            attrs.sdval = cell.value;
+            attrs["data-sheets-value"] = JSON.stringify({ 1: 3, 3: cell.value });
+            if (format) {
+                attrs.sdnum = format;
+                attrs["data-sheets-numberformat"] = JSON.stringify({ 1: 2, 2: format, 3: 1 });
+            }
+        }
+        if (cell.formula) {
+            attrs["data-sheets-formula"] = "=" + cell.formula.print();
+        }
+
         let className = null;
 
         if (cell.enable === false) {
             className = "k-disabled";
         }
 
-        let td = table.addCell(row, data, style, className, cell.validation);
+        let td = table.addCell(row, data, attrs, className, cell.validation);
 
         let border, sibling;
 
@@ -17893,7 +17928,7 @@
             this.trs.push(tr);
         }
 
-        addCell(rowIndex, text, style, className, validation) {
+        addCell(rowIndex, text, attrs, className, validation) {
             if (text === null || text === undefined) {
                 text = "";
             }
@@ -17902,19 +17937,18 @@
             }
 
             let children = [ text ];
-            let properties = { style: style };
 
             if (validation && !validation.value) {
                 children.push(dom.element("span", { className: "k-dirty" }));
 
                 className = (className || "") + (className ? " " : "") + "k-dirty-cell";
-                properties.title = validation.message;
+                attrs.title = validation.message;
             }
 
             if (className) {
-                properties.className = className;
+                attrs.className = className;
             }
-            let td = dom.element("td", properties, children);
+            let td = dom.element("td", attrs, children);
 
             this.trs[rowIndex].children.push(td);
             return td;
@@ -18907,7 +18941,13 @@
         return style.replace(/^-(?:ms|moz|webkit)-/, "");
     }
 
-    function borderObject(styles) {
+    function borderObject(element, styles) {
+        // MS Office uses class name and writes borders in the <style> section, so for it we need to
+        // use the computed styles.  For Google Sheets / LibreOffice, however, the inline styles are
+        // more accurate.
+        if (!element.className) {
+            styles = element.style;
+        }
         let obj = {};
         [
             "borderBottom",
@@ -18915,16 +18955,45 @@
             "borderLeft",
             "borderTop"
         ].forEach(function(key) {
-            obj[key] = styles[key + "Style"] === "none" ? null : {
-                size: 1,
-                color: styles[key + "Color"]
-            };
+            let width = styles[key + "Width"];
+            if (width) {
+                width = parseInt(width, 10);
+            }
+            if (width) {
+                obj[key] = {
+                    size: width,
+                    color: styles[key + "Color"] || "#000"
+                };
+            }
         });
         return obj;
     }
 
     function cellState(row, col, element, hBorders, vBorders) {
         let styles = window.getComputedStyle(element);
+        let value, format, formula;
+
+        // google sheets
+        if ((value = element.getAttribute("data-sheets-value"))) {
+            value = JSON.parse(value);
+            value = value[value[1]];
+        }
+        if ((format = element.getAttribute("data-sheets-numberformat"))) {
+            format = JSON.parse(format);
+            format = format[format[1]];
+        }
+        formula = element.getAttribute("data-sheets-formula");
+
+        // libre office
+        if (value == null && format == null && formula == null) {
+            value = element.getAttribute("sdval");
+            format = element.getAttribute("sdnum");
+            if (format) {
+                // for ungoogable reasons, libreoffice prepends format strings with
+                // "1033;" and sometimes with "1033;0;". discard it below.
+                format = format.replace(/^1033;(?:0;)?/, "");
+            }
+        }
 
         // note: Chrome 70 appends a \t to a cell's text, which is actually mandated by the standard
         // ([1] item 6).  We remove it below.  In [2] it's suggested they might switch back to
@@ -18932,49 +19001,62 @@
         //
         // [1] https://www.w3.org/TR/html53/dom.html#dom-htmlelement-innertext
         // [2] https://bugs.chromium.org/p/chromium/issues/detail?id=897373
-        let text = (element.innerText || element.textContent).replace(/\t$/, "");
+        if (value == null) {
+            value = (element.innerText || element.textContent).replace(/\t$/, "");
+        }
 
-        let borders = borderObject(styles);
+        let borders = borderObject(element, styles);
         let state = {
-            value: text === "" ? null : text,
+            value: value === "" ? null : value,
+            formula: formula,
 
             borderTop: borders.borderTop || hBorders.get(row, col) || null,
             borderBottom: borders.borderBottom || hBorders.get(row + 1, col) || null,
             borderLeft: borders.borderLeft || vBorders.get(row, col) || null,
             borderRight: borders.borderRight || vBorders.get(row, col + 1) || null,
 
-            fontSize: parseInt(styles["font-size"], 10)
+            fontSize: parseInt(styles["fontSize"], 10)
         };
 
+        if (format != null) {
+            state.format = format;
+        }
+
         hBorders.set(row, col, state.borderTop);
         hBorders.set(row + 1, col, state.borderBottom);
         vBorders.set(row, col, state.borderLeft);
         vBorders.set(row, col + 1, state.borderRight);
 
-        if (styles["background-color"] !== "rgb(0, 0, 0)" && styles["background-color"] !== "rgba(0, 0, 0, 0)") {
-            state.background = styles["background-color"];
+        if (styles["backgroundColor"] !== "rgb(0, 0, 0)" && styles["backgroundColor"] !== "rgba(0, 0, 0, 0)") {
+            state.background = styles["backgroundColor"];
+        }
+        if (stripStyle(styles["textAlign"]) !== "right") {
+            state.textAlign = stripStyle(styles["textAlign"]);
+        }
+        if (styles["verticalAlign"] !== "middle") {
+            state.verticalAlign = styles["verticalAlign"];
+        }
+        if (styles["wordWrap"] !== "normal" ) {
+            state.wrap = true;
+        }
+
+        const txtElem = element.querySelector("font"); // libre office
+        if (txtElem) {
+            styles = window.getComputedStyle(txtElem);
         }
+
         if (styles.color !== "rgb(0, 0, 0)" && styles.color !== "rgba(0, 0, 0, 0)") {
             state.color = styles.color;
         }
-        if (styles["text-decoration"] === "underline") {
+        if (/^underline/.test(styles["textDecoration"])) {
             state.underline = true;
         }
-        if (styles["font-style"] === "italic") {
+        if (styles["fontStyle"] == "italic") {
             state.italic = true;
         }
-        if (styles["font-weight"] === "bold") {
+        if (/^(?:bold|[67]00)$/i.test(styles["fontWeight"])) {
             state.bold = true;
         }
-        if (stripStyle(styles["text-align"]) !== "right") {
-            state.textAlign = stripStyle(styles["text-align"]);
-        }
-        if (styles["vertical-align"] !== "middle") {
-            state.verticalAlign = styles["vertical-align"];
-        }
-        if (styles["word-wrap"] !== "normal" ) {
-            state.wrap = true;
-        }
 
         return state;
     }
@@ -20808,6 +20890,60 @@
         }
     };
 
+    class Deferred {
+        constructor() {
+            this._progressHandlers = [];
+            this._resolved = false;
+            this._rejected = false;
+            this.promise = new window.Promise((resolve, reject) => {
+                this._resolve = (value) => {
+                    if (!this._resolved && !this._rejected) {
+                        this._resolved = true;
+                        resolve(value);
+                    }
+                };
+                this._reject = (reason) => {
+                    if (!this._resolved && !this._rejected) {
+                        this._rejected = true;
+                        reject(reason);
+                    }
+                };
+            });
+        }
+
+        resolve(value) {
+            this._resolve(value);
+            return this;
+        }
+
+        reject(reason) {
+            this._reject(reason);
+            return this;
+        }
+
+        notify(value) {
+            if (!this._resolved && !this._rejected) {
+                this._progressHandlers.forEach(handler => handler(value));
+            }
+        }
+
+        progress(callback) {
+            this._progressHandlers.push(callback);
+            return this;
+        }
+
+        then(onFulfilled, onRejected, onProgress) {
+            if (onProgress) {
+                this.progress(onProgress);
+            }
+            return this.promise.then(onFulfilled, onRejected);
+        }
+
+        promise() {
+            return this.promise;
+        }
+    }
+
     /* eslint-disable complexity */
 
     // WARNING: removing the following jshint declaration and turning
@@ -20822,12 +20958,11 @@
 
     let ERROR_LOG = null;
 
-    function readExcel(file, workbook) {
+    function readExcel(file, workbook, deferred) {
         let reader = new FileReader();
-        reader.onload = function(e) {
-            JSZip.loadAsync(e.target.result).then(zip => {
-                readWorkbook(zip, workbook);
-            });
+        reader.onload = async function(e) {
+            JSZip.loadAsync(e.target.result)
+                .then(async zip => await readWorkbook(zip, workbook, deferred));
         };
 
         reader.readAsArrayBuffer(file);
@@ -20849,6 +20984,7 @@
     let SEL_VIEW = ["bookViews", "workbookView"];
     let SEL_SHEET_VIEW = ["sheetViews", "sheetView"];
     let SEL_HYPERLINK = ["hyperlinks", "hyperlink"];
+    let SEL_PROTECTION = ["sheetProtection"];
 
     /* A validation section looks like this:
         *
@@ -20910,7 +21046,7 @@
         return file;
     }
 
-    async function readWorkbook(zip, workbook) {
+    async function readWorkbook(zip, workbook, progress) {
         ERROR_LOG = workbook.excelImportErrors = [];
 
         let strings = await readStrings(zip);
@@ -20927,6 +21063,10 @@
                     let file = relationships.byId[relId];
                     let name = attrs.name;
                     let state = attrs.state;
+                    let dim = sheetDimensions(relationships.bytes[file]);
+
+                    workbook.options.columnWidth = dim.columnWidth || workbook.options.columnWidth;
+                    workbook.options.rowHeight = dim.rowHeight || workbook.options.rowHeight;
 
                     items.push({
                         workbook: workbook,
@@ -20936,7 +21076,11 @@
                         file: file,
                         options: {
                             state: state,
-                            name: name
+                            name: name,
+                            rows: Math.max(workbook.options.rows || 0, dim.rows),
+                            columns: Math.max(workbook.options.columns || 0, dim.cols),
+                            columnWidth: dim.columnWidth,
+                            rowHeight: dim.rowHeight
                         }
                     });
                 } else if (this.is(SEL_VIEW)) {
@@ -20966,43 +21110,63 @@
             }
         });
 
-        for (let i = 0; i < items.length; i++) {
-            const item = items[i];
-            const dim = await sheetDimensions(item.zip, item.file);
-            const { workbook } = item;
-
-            workbook.options.columnWidth = dim.columnWidth || workbook.options.columnWidth;
-            workbook.options.rowHeight = dim.rowHeight || workbook.options.rowHeight;
-
-            item.options = {
-                ...item.options,
-                rows: Math.max(workbook.options.rows || 0, dim.rows),
-                columns: Math.max(workbook.options.columns || 0, dim.cols),
-                columnWidth: dim.columnWidth,
-                rowHeight: dim.rowHeight
-            };
-        }
+        let loading = new Deferred();
+        loading.progress(function(args) {
+            if (progress) {
+                progress.notify(args);
+            }
+        })
+        .then(function() {
+            let sheets = workbook.sheets();
+            recalcSheets(sheets);
 
-        await loadSheets(items, workbook);
+            workbook.activeSheet(sheets[activeSheet]);
 
-        let sheets = workbook.sheets();
-        recalcSheets(sheets);
+            if (progress) {
+                progress.resolve();
+            }
+        });
 
-        workbook.activeSheet(sheets[activeSheet]);
+        loadSheets(items, workbook, loading);
     }
 
-    async function loadSheets(items, workbook) {
+    function loadSheets(items, workbook, progress) {
+        let ready = window.Promise.resolve();
         for (let i = 0; i < items.length; i++) {
-            const ctx = items[i];
-            let sheet = workbook.insertSheet(ctx.options);
+            (function(entry, i) {
+                ready = ready.then(function() {
+                    let sheet = workbook.insertSheet(entry.options);
+                    sheet.suspendChanges(true);
+
+                    let promise = queueSheet(sheet, entry);
+                    let args = {
+                        sheet: sheet,
+                        progress: i === 1 ? 1 : (i / (items.length - 1))
+                    };
 
-            if (!sheet) {
-                continue;
-            }
+                    promise.then(function() {
+                        progress.notify(args);
+                    });
 
-            sheet.suspendChanges(true);
-            await readSheet(ctx.zip, ctx.file, sheet, ctx.strings, ctx.styles);
+                    return promise;
+                });
+            })(items[i], i);
         }
+
+        ready.then(function() {
+            progress.resolve();
+        });
+    }
+
+    function queueSheet(sheet, ctx) {
+        let deferred = new Deferred();
+
+        setTimeout(async function() {
+            await readSheet(ctx.zip, ctx.file, sheet, ctx.strings, ctx.styles);
+            deferred.resolve();
+        }, 0);
+
+        return deferred;
     }
 
     function recalcSheets(sheets) {
@@ -21013,13 +21177,13 @@
         }
     }
 
-    async function sheetDimensions(zip, file) {
+    function sheetDimensions(bytes) {
         let ref, dim = {
                 rows: 0,
                 cols: 0
             };
 
-        await parse(zip, xl(file), {
+        parseXML(bytes, {
             enter: function(tag, attrs) {
                 if (tag === "dimension") {
                     ref = calc.parseReference(attrs.ref);
@@ -21077,6 +21241,7 @@
         let valueFilterBlanks;
         let valueFilterValues;
         let filters = [];
+        let deferredStyles = [];
 
         ERROR_LOG = sheet._workbook.excelImportErrors;
 
@@ -21121,7 +21286,7 @@
 
                     let styleIndex = attrs.s;
                     if (styleIndex != null) {
-                        applyStyle(sheet, ref, styles, styleIndex);
+                        deferredStyles.push({ ref: ref,  sty: +styleIndex });
                     }
                 } else if (this.is(SEL_MERGE)) {
                     sheet.range(attrs.ref).merge();
@@ -21142,10 +21307,13 @@
                     }
                     if (attrs.style != null) {
                         // apply style on a whole range of columns
-                        applyStyle(sheet, new RangeRef(
-                            new CellRef(-Infinity, start),
-                            new CellRef(+Infinity, stop)
-                        ), styles, attrs.style);
+                        deferredStyles.unshift({
+                            ref: new RangeRef(
+                                new CellRef(-Infinity, start),
+                                new CellRef(+Infinity, stop)
+                            ),
+                            sty: +attrs.style
+                        });
                     }
                 } else if (this.is(SEL_ROW)) {
                     let row = integer(attrs.r) - 1;
@@ -21182,6 +21350,10 @@
                     if (target) {
                         sheet.range(attrs.ref).link(target);
                     }
+                } else if (this.is(SEL_PROTECTION)) {
+                    if (attrs.sheet) {
+                        sheet.range(SHEETREF).enable(false);
+                    }
                 } else if (this.is(["autoFilter"])) {
                     filterRef = attrs.ref;
                     if (closed) {
@@ -21352,6 +21524,8 @@
             }
         });
 
+        deferredStyles.forEach(({ ref, sty }) => applyStyle(sheet, ref, styles, sty));
+
         if (relationships.byType.comments) {
             let commentFile = relative_file(file, relationships.byType.comments[0]);
             await readComments(zip, commentFile, sheet);
@@ -21402,12 +21576,14 @@
         let relationships = await readRelationships(zip, relsFile);
 
         if (relationships.byType.image) {
-            for (const id of Object.keys(relationships.byId)) {
+            let relkeys = Object.keys(relationships.byId);
+            for (let i = 0; i < relkeys.length; ++i) {
+                let id = relkeys[i];
                 let img = relative_file(file, relationships.byId[id]);
                 let type = getContentType(img);
 
                 if (type) {
-                    let data = await zip.files[img].async("arrayBuffer");
+                    let data = await zip.file(img).async("arraybuffer");
                     let name = getFileName(img);
                     let blob = name && !(kendoCommon.browser.edge)
                         ? new window.File([ data ], name, { type: type })
@@ -21681,6 +21857,9 @@
         if (shouldSet("applyNumberFormat", "numFmtId")) {
             setFormat(styles.numFmts[value] || DEFAULT_FORMATS[value]);
         }
+        if (shouldSet("applyProtection", "protection")) {
+            range.enable(!xf.protection.locked);
+        }
 
         function setFormat(f) {
             let format = typeof f == "string" ? f : f.formatCode;
@@ -21769,11 +21948,18 @@
         }
     }
 
-    async function parse(zip, file, callbacks) {
-        let part = zip.files[file];
-        if (part) {
-            await parseXML(await part.async("uint8array"), callbacks);
-        }
+    function parse(zip, file, callbacks) {
+        return new window.Promise(resolve => {
+            let obj = zip.file(file);
+            if (obj) {
+                obj.async("uint8array").then(bytes => {
+                    parseXML(bytes, callbacks);
+                    resolve();
+                });
+            } else {
+                resolve();
+            }
+        });
     }
 
     async function readStrings(zip) {
@@ -21799,7 +21985,7 @@
     }
 
     async function readRelationships(zip, file) {
-        let map = { byId: {}, byType: { theme: [] } };
+        let map = { byId: {}, byType: { theme: [] }, bytes: {} };
         await parse(zip, xl(file) + ".rels", {
             enter: function(tag, attrs) {
                 if (tag === "Relationship") {
@@ -21812,6 +21998,18 @@
                 }
             }
         });
+        let names = [];
+        let promises = [];
+        Object.keys(map.byId).forEach(id => {
+            let filename = map.byId[id];
+            let obj = zip.file(xl(filename));
+            if (obj) {
+                names.push(filename);
+                promises.push(obj.async("uint8array"));
+            }
+        });
+        let data = await window.Promise.all(promises);
+        names.forEach((name, i) => map.bytes[name] = data[i]);
         return map;
     }
 
@@ -21953,6 +22151,10 @@
                         if (attrs.indent != null) {
                             xf.indent = integer(attrs.indent);
                         }
+                    } else if (tag == "protection") {
+                        xf.protection = {
+                            locked: bool(attrs.locked)
+                        };
                     }
                 }
             },
@@ -21984,10 +22186,12 @@
             addBool("applyFill");
             addBool("applyFont");
             addBool("applyNumberFormat");
-            addBool("applyProtection");
+            if (addBool("applyProtection")) {
+                xf.protection = { locked: true };
+            }
             function addBool(name) {
                 if (attrs[name] != null) {
-                    xf[name] = bool(attrs[name]);
+                    return xf[name] = bool(attrs[name]);
                 }
             }
             return xf;
@@ -22036,7 +22240,7 @@
         };
 
         let file = xl(rel);
-        if (zip.files[file]) {
+        if (zip.file(file)) {
             await parse(zip, file, {
                 enter: function(tag, attrs) {
                     if (this.is(SEL_SCHEME_SYSCLR)) {
@@ -22767,10 +22971,14 @@
         }
 
         fromFile(file) {
-            if (file && !this.trigger("excelImport", { file })) {
+            const deferred = new Deferred();
+
+            if (file && !this.trigger("excelImport", { file, deferred })) {
                 this._clearSheets();
-                readExcel(file, this);
+                readExcel(file, this, deferred);
             }
+
+            return deferred.promise;
         }
 
         saveAsExcel(options) {
@@ -24268,6 +24476,11 @@
             right = right.toLowerCase();
         }
         if (typeof right == typeof left) {
+            // for issue https://github.com/telerik/kendo-ui-core/issues/6879, limitPrecision
+            // digits got bumped to 16, but it's too much for the case 9.302 - 0.002 (issue
+            // https://github.com/telerik/kendo-ui-core/issues/7170).
+            left = maybeRoundFloatErrors(left, 15);
+            right = maybeRoundFloatErrors(right, 15);
             return func(left, right);
         } else {
             return new CalcError("VALUE");
@@ -32610,10 +32823,10 @@
                 }
             }
             if (ref.width == 1) {
-                return callback(ref.get(row - 1, 0));
+                return callback(ref.get((row || 1) - 1, 0));
             }
             if (ref.height == 1) {
-                return callback(ref.get(0, col - 1));
+                return callback(ref.get(0, (col || 1) - 1));
             }
         } else {
             callback(new CalcError('REF'));
@@ -43762,6 +43975,7 @@
     exports.CalcError = CalcError;
     exports.CellRef = CellRef;
     exports.Context = Context;
+    exports.Deferred = Deferred;
     exports.Matrix = Matrix;
     exports.NULLREF = NULLREF;
     exports.NameRef = NameRef;