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

package/dist/index.js

@@ -1166,66 +1166,36 @@
         }
     }
 
-    const wrapExpression = function(members, paramName) {
-        let result = paramName || "d",
-            index,
-            idx,
-            length,
-            member,
-            count = 1;
-
-        for (idx = 0, length = members.length; idx < length; idx++) {
-            member = members[idx];
-            if (member !== "") {
-                index = member.indexOf("[");
-
-                if (index !== 0) {
-                    if (index === -1) {
-                        member = "." + member;
-                    } else {
-                        count++;
-                        member = "." + member.substring(0, index) + " || {})" + member.substring(index);
-                    }
-                }
-
-                count++;
-                result += member + ((idx < length - 1) ? " || {})" : ")");
-            }
-        }
-        return new Array(count).join("(") + result;
-    };
-
     const getterCache = {};
 
-    function expr(expression, safe, paramName) {
-        expression = expression || "";
-
-        if (typeof safe == 'string') {
-            paramName = safe;
-            safe = false;
-        }
+    getterCache["undefined"] = (obj) => obj;
 
-        paramName = paramName || "d";
+    const FIELD_REGEX = /\[(?:(\d+)|['"](.*?)['"])\]|((?:(?!\[.*?\]|\.).)+)/g;
+    function getter(field, safe) {
+        const key = field + safe;
 
-        if (expression && expression.charAt(0) !== "[") {
-            expression = "." + expression;
+        if (getterCache[key]) {
+            return getterCache[key];
         }
 
-        if (safe) {
-            expression = expression.replace(/"([^.]*)\.([^"]*)"/g,'"$1_$DOT$_$2"');
-            expression = expression.replace(/'([^.]*)\.([^']*)'/g,"'$1_$DOT$_$2'");
-            expression = wrapExpression(expression.split("."), paramName);
-            expression = expression.replace(/_\$DOT\$_/g, ".");
-        } else {
-            expression = paramName + expression;
-        }
+        const fields = [];
+        field.replace(FIELD_REGEX, (_, index, indexAccessor, field) => {
+            fields.push(isPresent(index) ? index : indexAccessor || field);
+            return undefined;
+        });
 
-        return expression;
-    }
+        getterCache[key] = (obj) => {
+            let result = obj;
+            for (let idx = 0; idx < fields.length; idx++) {
+                result = result[fields[idx]];
+                if (!isPresent(result) && safe) {
+                    return result;
+                }
+            }
+
+            return result;
+        };
 
-    function getter(expression, safe) {
-        let key = expression + safe;
-        getterCache[key] = getterCache[key] || new Function("d", "return " + expr(expression, safe));
         return getterCache[key];
     }
 
@@ -1240,10 +1210,6 @@
         return destination;
     }
 
-    function isFunction(fn) {
-        return typeof fn === "function";
-    }
-
     function deepExtendOne(destination, source) {
         let property,
             propValue,
@@ -1317,7 +1283,12 @@
         let div = document.createElement("div"),
             result;
 
-        div.style.cssText = "overflow:scroll;overflow-x:hidden;zoom:1;clear:both;display:block";
+        div.style.overflow = "scroll";
+        div.style.overflowX = "hidden";
+        div.style.zoom = "1";
+        div.style.clear = "both";
+        div.style.display = "block";
+
         div.innerHTML = "&nbsp;";
         document.body.appendChild(div);
 
@@ -1392,6 +1363,13 @@
         }
     };
 
+    const isPresent = (value) => value !== null && value !== undefined;
+    const isBlank = (value) => !isPresent(value);
+    const isDate = (value) => value && value.getTime;
+    const isString = (value) => typeof value === "string";
+    const isNumeric = (value) => !isNaN(value - parseFloat(value));
+    const isFunction = (fn) => typeof fn === "function";
+
     class CalcError {
 
         constructor(code) {
@@ -2486,13 +2464,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 +5629,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 +8851,7 @@
                     sheet._set(ref, propName, propValue);
                 };
 
+                let isValue = false;
                 for (ci = topLeftCol; ci <= bottomRightCol; ci ++) {
                     if (!isAutofill && sheet.isHiddenColumn(ci)) {
                         continue;
@@ -8884,12 +8867,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 +8887,8 @@
 
             let reason = {
                 recalc: clearAll || options.contentsOnly,
-                ref: this._ref
+                ref: this._ref,
+                isValue: true
             };
 
             sheet.batch(function() {
@@ -9399,13 +9385,18 @@
 
     function getTextHeight(text, width, fontFamily, fontSize, wrap) {
         const measureBox = document.createElement("div");
-        measureBox.setAttribute(
-            "style",
-            "position: absolute !important; top: -4000px !important; height: auto !important;" +
-                "padding: 1px 3px !important; box-sizing: border-box; margin: 0 !important; border: 1px solid black !important;" +
-                "line-height: normal !important; visibility: hidden !important;" +
-                "white-space: pre-wrap;"
-        );
+
+        measureBox.style.setProperty('position', 'absolute', 'important');
+        measureBox.style.setProperty('top', '-4000px', 'important');
+        measureBox.style.setProperty('height', 'auto', 'important');
+        measureBox.style.setProperty('padding', '1px 3px', 'important');
+        measureBox.style.setProperty('box-sizing', 'border-box', 'important');
+        measureBox.style.setProperty('margin', '0', 'important');
+        measureBox.style.setProperty('border', '1px solid black', 'important');
+        measureBox.style.setProperty('line-height', 'normal', 'important');
+        measureBox.style.setProperty('visibility', 'hidden', 'important');
+        measureBox.style.setProperty('white-space', 'pre-wrap');
+
         let styles = {
             "baselineMarkerSize" : 0,
             "width" : (wrap === true) ? width + "px" : "auto",
@@ -12120,210 +12111,131 @@
 
     /* eslint-disable no-var */
 
-    const dateRegExp = /^\/Date\((.*?)\)\/$/;
+    const logic = {
+        or: {
+            concat: (acc, fn) => (a) => acc(a) || fn(a),
+            identity: () => false,
+        },
+        and: {
+            concat: (acc, fn) => (a) => acc(a) && fn(a),
+            identity: () => true,
+        },
+    };
+
+    const operatorsMap = {
+        contains: (a, b) => (a || "").indexOf(b) >= 0,
+        doesnotcontain: (a, b) => (a || "").indexOf(b) === -1,
+        doesnotendwith: (a, b) =>
+            (a || "").indexOf(b, (a || "").length - (b || "").length) < 0,
+        doesnotstartwith: (a, b) => (a || "").lastIndexOf(b, 0) === -1,
+        endswith: (a, b) =>
+            (a || "").indexOf(b, (a || "").length - (b || "").length) >= 0,
+        eq: (a, b) => a === b,
+        gt: (a, b) => a > b,
+        gte: (a, b) => a >= b,
+        isempty: (a) => a === "",
+        isnotempty: (a) => a !== "",
+        isnotnull: (a) => isPresent(a),
+        isnull: (a) => isBlank(a),
+        lt: (a, b) => a < b,
+        lte: (a, b) => a <= b,
+        neq: (a, b) => a != b, // tslint:disable-line:triple-equals
+        startswith: (a, b) => (a || "").lastIndexOf(b, 0) === 0,
+    };
 
-    var operators = (function() {
+    const dateRegExp = /^\/Date\((.*?)\)\/$/;
 
-        function quote(str) {
-            if (typeof str == "string") {
-                str = str.replace(/[\r\n]+/g, "");
+    const convertValue = (value, ignoreCase, accentFoldingFiltering) => {
+        if (value != null && isString(value)) {
+            const date = dateRegExp.exec(value);
+            if (date) {
+                return new Date(+date[1]).getTime();
+            } else if (ignoreCase) {
+                return accentFoldingFiltering
+                    ? value.toLocaleLowerCase(accentFoldingFiltering)
+                    : value.toLowerCase();
             }
-            return JSON.stringify(str);
+        } else if (value != null && isDate(value)) {
+            return value.getTime();
         }
+        return value;
+    };
 
-        function textOp(impl) {
-            return function(a, b, ignore, accentFoldingFiltering) {
-                b += "";
-                if (ignore) {
-                    a = "(" + a + " + '').toString()" + ((accentFoldingFiltering) ? ".toLocaleLowerCase('" + accentFoldingFiltering + "')" : ".toLowerCase()");
-                    b = ((accentFoldingFiltering) ? b.toLocaleLowerCase(accentFoldingFiltering) : b.toLowerCase());
-                }
-                return impl(a, quote(b), ignore);
-            };
-        }
+    const transformFilter = ({
+        field,
+        ignoreCase,
+        value,
+        operator,
+        accentFoldingFiltering,
+    }) => {
+        field = !isPresent(field) ? (a) => a : field;
+
+        ignoreCase = isPresent(ignoreCase) ? ignoreCase : true;
+
+        const itemProp = typedGetter(
+            isFunction(field) ? field : getter(field, true),
+            value,
+            ignoreCase,
+            accentFoldingFiltering
+        );
 
-        function operator(op, a, b, ignore, accentFoldingFiltering) {
-            if (b != null) {
-                if (typeof b === 'string') {
-                    var date = dateRegExp.exec(b);
-                    if (date) {
-                        b = new Date(+date[1]);
-                    } else if (ignore) {
-                        b = quote(((accentFoldingFiltering) ? b.toLocaleLowerCase(accentFoldingFiltering) : b.toLowerCase()));
-                        a = "((" + a + " || '')+'')" + ((accentFoldingFiltering) ? ".toLocaleLowerCase('" + accentFoldingFiltering + "')" : ".toLowerCase()");
-                    } else {
-                        b = quote(b);
-                    }
-                }
+        value = convertValue(value, ignoreCase, accentFoldingFiltering);
 
-                if (b.getTime) {
-                    //b looks like a Date
-                    a = "(" + a + "&&" + a + ".getTime?" + a + ".getTime():" + a + ")";
-                    b = b.getTime();
-                }
-            }
+        const op = isFunction(operator) ? operator : operatorsMap[operator];
 
-            return a + " " + op + " " + b;
-        }
+        return (a) => op(itemProp(a), value, ignoreCase);
+    };
 
-        function getMatchRegexp(pattern) {
-            // take a pattern, as supported by Excel match filter, and
-            // convert it to the equivalent JS regular expression.
-            // Excel patterns support:
-            //
-            //   * - match any sequence of characters
-            //   ? - match a single character
-            //
-            // to match a literal * or ?, they must be prefixed by a tilde (~)
-            var rx = "/^";
-            for (var esc = false, i = 0; i < pattern.length; ++i) {
-                var ch = pattern.charAt(i);
-                if (esc) {
-                    rx += "\\" + ch;
-                } else if (ch === "~") {
-                    esc = true;
-                    continue;
-                } else if (ch === "*") {
-                    rx += ".*";
-                } else if (ch === "?") {
-                    rx += ".";
-                } else if (".+^$()[]{}|\\/\n\r\u2028\u2029\xA0".indexOf(ch) >= 0) {
-                    rx += "\\" + ch;
-                } else {
-                    rx += ch;
-                }
-                esc = false;
-            }
-            return rx + "$/";
+    const typedGetter = (prop, value, ignoreCase, accentFoldingFiltering) => {
+        if (!isPresent(value)) {
+            return prop;
         }
 
-        return {
-            quote: function(value) {
-                if (value && value.getTime) {
-                    return "new Date(" + value.getTime() + ")";
-                }
-                return quote(value);
-            },
-            eq: function(a, b, ignore, accentFoldingFiltering) {
-                return operator("==", a, b, ignore, accentFoldingFiltering);
-            },
-            neq: function(a, b, ignore, accentFoldingFiltering) {
-                return operator("!=", a, b, ignore, accentFoldingFiltering);
-            },
-            gt: function(a, b, ignore) {
-                return operator(">", a, b, ignore);
-            },
-            gte: function(a, b, ignore) {
-                return operator(">=", a, b, ignore);
-            },
-            lt: function(a, b, ignore) {
-                return operator("<", a, b, ignore);
-            },
-            lte: function(a, b, ignore) {
-                return operator("<=", a, b, ignore);
-            },
-            startswith: textOp(function(a, b) {
-                return a + ".lastIndexOf(" + b + ", 0) == 0";
-            }),
-            doesnotstartwith: textOp(function(a, b) {
-                return a + ".lastIndexOf(" + b + ", 0) == -1";
-            }),
-            endswith: textOp(function(a, b) {
-                var n = b ? b.length - 2 : 0;
-                return a + ".indexOf(" + b + ", " + a + ".length - " + n + ") >= 0";
-            }),
-            doesnotendwith: textOp(function(a, b) {
-                var n = b ? b.length - 2 : 0;
-                return a + ".indexOf(" + b + ", " + a + ".length - " + n + ") < 0";
-            }),
-            contains: textOp(function(a, b) {
-                return a + ".indexOf(" + b + ") >= 0";
-            }),
-            doesnotcontain: textOp(function(a, b) {
-                return a + ".indexOf(" + b + ") == -1";
-            }),
-            matches: textOp(function(a, b) {
-                b = b.substring(1, b.length - 1);
-                return getMatchRegexp(b) + ".test(" + a + ")";
-            }),
-            doesnotmatch: textOp(function(a, b) {
-                b = b.substring(1, b.length - 1);
-                return "!" + getMatchRegexp(b) + ".test(" + a + ")";
-            }),
-            isempty: function(a) {
-                return a + " === ''";
-            },
-            isnotempty: function(a) {
-                return a + " !== ''";
-            },
-            isnull: function(a) {
-                return "(" + a + " == null)";
-            },
-            isnotnull: function(a) {
-                return "(" + a + " != null)";
-            },
-            isnullorempty: function(a) {
-                return "(" + a + " === null) || (" + a + " === '')";
-            },
-            isnotnullorempty: function(a) {
-                return "(" + a + " !== null) && (" + a + " !== '')";
-            }
-        };
-    })();
-
-    const filterExpr = function(expression) {
-        var expressions = [],
-            logic = { and: " && ", or: " || " },
-            idx,
-            length,
-            filter,
-            expr$1,
-            fieldFunctions = [],
-            operatorFunctions = [],
-            field,
-            operator,
-            filters = expression.filters;
-
-        for (idx = 0, length = filters.length; idx < length; idx++) {
-            filter = filters[idx];
-            field = filter.field;
-            operator = filter.operator;
-
-            if (filter.filters) {
-                expr$1 = filterExpr(filter);
-                //Nested function fields or operators - update their index e.g. __o[0] -> __o[1]
-                filter = expr$1.expression
-                .replace(/__o\[(\d+)\]/g, function(match, index) {
-                    index = +index;
-                    return "__o[" + (operatorFunctions.length + index) + "]";
-                })
-                .replace(/__f\[(\d+)\]/g, function(match, index) {
-                    index = +index;
-                    return "__f[" + (fieldFunctions.length + index) + "]";
-                });
+        let acc = prop;
 
-                operatorFunctions.push.apply(operatorFunctions, expr$1.operators);
-                fieldFunctions.push.apply(fieldFunctions, expr$1.fields);
+        if (isString(value)) {
+            const date = dateRegExp.exec(value);
+            if (date) {
+                value = new Date(+date[1]);
             } else {
-                if (typeof field === 'function') {
-                    expr$1 = "__f[" + fieldFunctions.length + "](d)";
-                    fieldFunctions.push(field);
-                } else {
-                    expr$1 = expr(field);
-                }
-
-                if (typeof operator === 'function') {
-                    filter = "__o[" + operatorFunctions.length + "](" + expr$1 + ", " + operators.quote(filter.value) + ")";
-                    operatorFunctions.push(operator);
-                } else {
-                    filter = operators[(operator || "eq").toLowerCase()](expr$1, filter.value, filter.ignoreCase !== undefined ? filter.ignoreCase : true, expression.accentFoldingFiltering);
-                }
+                acc = (a) => {
+                    const x = prop(a);
+                    if (typeof x === "string" && ignoreCase) {
+                        return accentFoldingFiltering
+                            ? x.toLocaleLowerCase(accentFoldingFiltering)
+                            : x.toLowerCase();
+                    } else {
+                        return isNumeric(x) ? x + "" : x;
+                    }
+                };
             }
+        }
 
-            expressions.push(filter);
+        if (isDate(value)) {
+            return (a) => {
+                const x = acc(a);
+                return isDate(x) ? x.getTime() : x;
+            };
         }
+        return acc;
+    };
 
-        return { expression: "(" + expressions.join(logic[expression.logic]) + ")", fields: fieldFunctions, operators: operatorFunctions };
+    const transformCompositeFilter = function (filter) {
+        const accentFoldingFiltering = filter.accentFoldingFiltering;
+        const combiner = logic[filter.logic || "and"];
+
+        return filter.filters
+            .filter(isPresent)
+            .map((x) => {
+                const extendedFilter = isPresent(accentFoldingFiltering)
+                    ? deepExtend({}, x, { accentFoldingFiltering })
+                    : x;
+
+                return isPresent(x.filters)
+                    ? transformCompositeFilter(extendedFilter)
+                    : transformFilter(extendedFilter);
+            })
+            .reduce(combiner.concat, combiner.identity);
     };
 
     /* eslint-disable max-params */
@@ -12438,13 +12350,11 @@
 
             this._criteria = options.criteria;
 
-            var expression = filterExpr({
+            this._matches = transformCompositeFilter({
                 logic: this._logic,
                 filters: this._criteria,
-                accentFoldingFiltering: culture().name
-            }).expression;
-
-            this._matches = new Function("d", "return " + expression);
+                accentFoldingFiltering: culture().name,
+            });
         }
         matches(value) {
             if (value === null) {
@@ -16173,7 +16083,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 +16118,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");
@@ -17009,24 +16930,9 @@
                 end = begin;
             }
             if (begin && end) {
-                let range = document.createRange();
-                range.setStart(begin.node, begin.pos);
-                range.setEnd(end.node, end.pos);
-                let sel = window.getSelection();
-                let currentRange = sel.getRangeAt(0);
-                if (differ(range, currentRange))  {
-                    sel.removeAllRanges();
-                    sel.addRange(range);
-                }
-            }
-            function differ(a, b) {
-                return (
-                    a.startOffset !== b.startOffset ||
-                    a.endOffset !== b.endOffset ||
-                    a.startContainer !== b.endContainer ||
-                    a.endContainer !== b.endContainer
-                );
+                this._setRange(begin, end);
             }
+
             function lookup(node, pos) {
                 try {
                     (function loop(node) {
@@ -17064,6 +16970,27 @@
             return this.value().length;
         }
 
+        _setRange(begin, end) {
+            let range = document.createRange();
+            range.setStart(begin.node, begin.pos);
+            range.setEnd(end.node, end.pos);
+            let sel = window.getSelection();
+            let currentRange = sel.getRangeAt(0);
+            if (differ(range, currentRange))  {
+                sel.removeAllRanges();
+                sel.addRange(range);
+            }
+
+            function differ(a, b) {
+                return (
+                    a.startOffset !== b.startOffset ||
+                    a.endOffset !== b.endOffset ||
+                    a.startContainer !== b.endContainer ||
+                    a.endContainer !== b.endContainer
+                );
+            }
+        }
+
         _formulaSource() {
             let result = [];
             let value;
@@ -17814,27 +17741,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 +17836,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 +17845,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 +18849,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 +18863,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 +18909,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 +20798,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 +20866,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 +20892,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 +20954,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 +20971,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 +20984,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 +21018,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 +21085,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 +21149,7 @@
         let valueFilterBlanks;
         let valueFilterValues;
         let filters = [];
+        let deferredStyles = [];
 
         ERROR_LOG = sheet._workbook.excelImportErrors;
 
@@ -21121,7 +21194,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 +21215,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 +21258,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 +21432,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 +21484,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 +21765,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 +21856,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 +21893,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 +21906,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 +22059,10 @@
                         if (attrs.indent != null) {
                             xf.indent = integer(attrs.indent);
                         }
+                    } else if (tag == "protection") {
+                        xf.protection = {
+                            locked: bool(attrs.locked)
+                        };
                     }
                 }
             },
@@ -21984,10 +22094,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 +22148,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 +22879,18 @@
         }
 
         fromFile(file) {
-            if (file && !this.trigger("excelImport", { file })) {
+            const deferred = new Deferred();
+
+            if (file && !this.trigger("excelImport", { file, deferred })) {
                 this._clearSheets();
-                readExcel(file, this);
+                this._readExcel(file, this, deferred);
             }
+
+            return deferred.promise;
+        }
+
+        _readExcel(file, workbook, deferred) {
+            readExcel(file, workbook, deferred);
         }
 
         saveAsExcel(options) {
@@ -24268,6 +24388,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 +32735,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 +43887,7 @@
     exports.CalcError = CalcError;
     exports.CellRef = CellRef;
     exports.Context = Context;
+    exports.Deferred = Deferred;
     exports.Matrix = Matrix;
     exports.NULLREF = NULLREF;
     exports.NameRef = NameRef;