Code coverage report for lib/utils/strings.js

# all files / lib/utils/ strings.js

77.36% Statements 41/53
46.88% Branches 15/32
83.33% Functions 5/6
78% Lines 39/50

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    991×
    1×
    1×
    1×

    1×
    1×
    16×

    16×
    20×
    12×

    4×

    1×

    1×

    1×

    1×
    1132×
    1132×

    1132×
    729×

    403×
    403×
    403×
    403×
    5867×

    403×
    5717×

    403×
    5314×
    78091×
    4015×

    74076×

    403×

    1×

    1×
    11×
    11×

    11×
    11×

    1×

     (function (factory) {
        Eif (typeof module === "object" && typeof module.exports === "object") {
            var v = factory(require, exports);
            Iif (v !== undefined) module.exports = v;
        }
        else if (typeof define === "function" && define.amd) {
            define(["require", "exports"], factory);
        }
    })(function (require, exports) {
        /*---------------------------------------------------------------------------------------------
         *  Copyright (c) Microsoft Corporation. All rights reserved.
         *  Licensed under the MIT License. See License.txt in the project root for license information.
         *--------------------------------------------------------------------------------------------*/
        'use strict';
        Object.defineProperty(exports, "__esModule", { value: true });
        function startsWith(haystack, needle) {
            Iif (haystack.length < needle.length) {
                return false;
            }
            for (var i = 0; i < needle.length; i++) {
                if (haystack[i] !== needle[i]) {
                    return false;
                }
            }
            return true;
        }
        exports.startsWith = startsWith;
        /**
         * Determines if haystack ends with needle.
         */
        function endsWith(haystack, needle) {
            var diff = haystack.length - needle.length;
            if (diff > 0) {
                return haystack.lastIndexOf(needle) === diff;
            }
            else if (diff === 0) {
                return haystack === needle;
            }
            else {
                return false;
            }
        }
        exports.endsWith = endsWith;
        /**
         * Computes the difference score for two strings. More similar strings have a higher score.
         * We use largest common subsequence dynamic programming approach but penalize in the end for length differences.
         * Strings that have a large length difference will get a bad default score 0.
         * Complexity - both time and space O(first.length * second.length)
         * Dynamic programming LCS computation http://en.wikipedia.org/wiki/Longest_common_subsequence_problem
         *
         * @param first a string
         * @param second a string
         */
        function difference(first, second, maxLenDelta) {
            Eif (maxLenDelta === void 0) { maxLenDelta = 4; }
            var lengthDifference = Math.abs(first.length - second.length);
            // We only compute score if length of the currentWord and length of entry.name are similar.
            if (lengthDifference > maxLenDelta) {
                return 0;
            }
            // Initialize LCS (largest common subsequence) matrix.
            var LCS = [];
            var zeroArray = [];
            var i, j;
            for (i = 0; i < second.length + 1; ++i) {
                zeroArray.push(0);
            }
            for (i = 0; i < first.length + 1; ++i) {
                LCS.push(zeroArray);
            }
            for (i = 1; i < first.length + 1; ++i) {
                for (j = 1; j < second.length + 1; ++j) {
                    if (first[i - 1] === second[j - 1]) {
                        LCS[i][j] = LCS[i - 1][j - 1] + 1;
                    }
                    else {
                        LCS[i][j] = Math.max(LCS[i - 1][j], LCS[i][j - 1]);
                    }
                }
            }
            return LCS[first.length][second.length] - Math.sqrt(lengthDifference);
        }
        exports.difference = difference;
        /**
         * Limit of string length.
         */
        function getLimitedString(str, ellipsis) {
            Eif (ellipsis === void 0) { ellipsis = true; }
            Iif (!str) {
                return '';
            }
            Eif (str.length < 140) {
                return str;
            }
            return str.slice(0, 140) + (ellipsis ? '\u2026' : '');
        }
        exports.getLimitedString = getLimitedString;
    });
    //# sourceMappingURL=strings.js.map