@aurigma/design-atoms-model/Utils/Utils.js

Design Atoms is a part of Customer's Canvas SDK which allows for manipulating individual design elements through your code.

var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
var __generator = (this && this.__generator) || function (thisArg, body) {
    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
    function verb(n) { return function (v) { return step([n, v]); }; }
    function step(op) {
        if (f) throw new TypeError("Generator is already executing.");
        while (_) try {
            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
            if (y = 0, t) op = [op[0] & 2, t.value];
            switch (op[0]) {
                case 0: case 1: t = op; break;
                case 4: _.label++; return { value: op[1], done: false };
                case 5: _.label++; y = op[1]; op = [0]; continue;
                case 7: op = _.ops.pop(); _.trys.pop(); continue;
                default:
                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
                    if (t[2]) _.ops.pop();
                    _.trys.pop(); continue;
            }
            op = body.call(thisArg, _);
        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
    }
};
var __values = (this && this.__values) || function(o) {
    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
    if (m) return m.call(o);
    if (o && typeof o.length === "number") return {
        next: function () {
            if (o && i >= o.length) o = void 0;
            return { value: o && o[i++], done: !o };
        }
    };
    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
};
var __read = (this && this.__read) || function (o, n) {
    var m = typeof Symbol === "function" && o[Symbol.iterator];
    if (!m) return o;
    var i = m.call(o), r, ar = [], e;
    try {
        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
    }
    catch (error) { e = { error: error }; }
    finally {
        try {
            if (r && !r.done && (m = i["return"])) m.call(i);
        }
        finally { if (e) throw e.error; }
    }
    return ar;
};
var __spread = (this && this.__spread) || function () {
    for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));
    return ar;
};
import { Exception, ArgumentException } from "../Exception";
import { Uuid } from "../Product/Uuid";
import * as _ from "underscore";
import Environment from "../Utils/Environment";
import { cloneDeep } from "lodash-es";
import { EqualsOfFloatNumbers } from "../Math";
export function mmToPoint(millimeters) { return millimeters * 2.83464567; }
;
export function stringEquals(str1, str2, options) {
    var ignoreCase = false;
    if (options != null)
        ignoreCase = typeof options === "boolean" ?
            options
            : options.ignoreCase;
    str1 = ignoreCase ? str1.toLowerCase() : str1;
    str2 = ignoreCase ? str2.toLowerCase() : str2;
    return str1 === str2;
}
export function assert(expression, message) {
    if (message != null)
        message = "Assertion failed";
    if (!expression)
        throw new Exception(message);
}
export function urlCombine(startUrl) {
    var urlParts = [];
    for (var _i = 1; _i < arguments.length; _i++) {
        urlParts[_i - 1] = arguments[_i];
    }
    var endUrl = urlParts.pop();
    if (urlParts.length === 0 && endUrl === "")
        return startUrl;
    var separatorChar = "/";
    endUrl = endUrl.replace(/^(\/|\s)+/g, "");
    startUrl = startUrl.replace(/(\/|\s)+$/g, "");
    if (urlParts.length === 0) {
        return startUrl + separatorChar + endUrl;
    }
    else {
        var trimedArgs = urlParts.map(function (arg) { return arg.replace(/^(\/|\s)+/g, "").replace(/(\/|\s)+$/g, ""); });
        return _.flatten([startUrl, trimedArgs, endUrl]).join(separatorChar);
    }
}
export function contains(str1, str2) {
    return str1 != null && str2 != null && str1.toLowerCase().indexOf(str2.toLowerCase()) !== -1;
}
;
export function equals(obj1, obj2) {
    if (obj1 == null && obj2 == null)
        return true;
    if ((obj1 == null && obj2 != null) || (obj1 != null && obj2 == null))
        return false;
    var typeof1 = typeof obj1;
    var typeof2 = typeof obj2;
    if (typeof1 !== typeof2)
        return false;
    if (typeof1 === "string" || typeof1 === "boolean")
        return obj1 === obj2;
    if (typeof1 === "number")
        return EqualsOfFloatNumbers(obj1, obj2);
    if (Array.isArray(obj1) && Array.isArray(obj2)) {
        if (obj1.length !== obj2.length)
            return false;
        return arrayEquals(obj1, obj2);
    }
    var equalFunc;
    var obj1equalsReady = obj1;
    var obj2equalsReady = obj2;
    if (typeof obj1equalsReady.equals === "function" && typeof obj2equalsReady.equals === "function")
        equalFunc = function (obj1, obj2) { return obj1.equals(obj2); };
    else
        equalFunc = function (obj1, obj2) { return obj1 == obj2; };
    return equalFunc(obj1, obj2);
}
export function arrayEquals(obj1, obj2) {
    if (obj1 == null && obj2 == null)
        return true;
    if (obj1 == null || obj2 == null)
        return false;
    if (obj1.length !== obj2.length)
        return false;
    return obj1.reduce(function (result, value, index) {
        return result && equals(value, obj2[index]);
    }, true);
}
export function arrayReferenceEquals(obj1, obj2) {
    if ((obj1 === null || obj1 === void 0 ? void 0 : obj1.length) !== (obj2 === null || obj2 === void 0 ? void 0 : obj2.length))
        return false;
    return obj1.reduce(function (result, value, index) {
        return result && value == obj2[index];
    }, true);
}
export function isNullOrEmptyOrWhiteSpace(str) {
    if (str == null)
        return true;
    return str.trim() === "";
}
export function capitalize(word) {
    if (word == null || word.length === 0 || /[A-Z]/.test(word[0]))
        return word;
    return word[0].toUpperCase() + word.substr(1);
}
export function isValidXml(str, fixAmpsEnabled) {
    if (fixAmpsEnabled === void 0) { fixAmpsEnabled = true; }
    if (isNullOrEmptyOrWhiteSpace(str) || !str.startsWith("<"))
        return false;
    if (fixAmpsEnabled)
        str = fixAmps(str);
    var xmlDoc = new DOMParser().parseFromString("<root>" + str + "</root>", "application/xml");
    return xmlDoc.querySelector("parsererror") == null;
}
function fixAmps(str) {
    if (isNullOrEmptyOrWhiteSpace(str) || !str.startsWith("<"))
        return str;
    var strParts = [str];
    while (true) {
        var lastPart = strParts.pop();
        var ampIndex = lastPart.indexOf("&");
        if (ampIndex === -1) {
            strParts.push(lastPart);
            break;
        }
        strParts.push(lastPart.substring(0, ampIndex));
        var ampEntity = getAmpEntity(lastPart, ampIndex);
        if (ampEntity != null) {
            strParts.push(ampEntity.entity);
            strParts.push(lastPart.substring(ampIndex + ampEntity.length));
        }
        else {
            strParts.push("&amp;");
            strParts.push(lastPart.substring(ampIndex + 1));
        }
    }
    return strParts.join('');
}
function getAmpEntity(str, index) {
    var substring4 = str.substring(index, index + 4).toLowerCase();
    if (substring4 == "&lt;")
        return { entity: "&lt;", length: 4 };
    else if (substring4 == "&gt;")
        return { entity: "&gt;", length: 4 };
    var substring5 = str.substring(index, index + 5).toLowerCase();
    if (substring5 == "&amp;")
        return { entity: "&amp;", length: 5 };
    var substring6 = str.substring(index, index + 6).toLowerCase();
    if (substring6 == "&apos;")
        return { entity: "&apos;", length: 6 };
    if (substring6 == "&quot;")
        return { entity: "&quot;", length: 6 };
    var substring7 = str.substring(index, index + 7).toLowerCase();
    if (substring7.match(/^&#[\\d]{4};$$/)) { // &#0023;
        return { entity: substring7, length: 7 };
    }
    var substring8 = str.substring(index, index + 8);
    if (substring8.toLowerCase().match(/^&#x[\\dabcdef]{4};$/)) // &#x00AB;
        return { entity: substring8, length: 8 };
    return null;
}
export function getTextFromXml(xmlFormattedText, replaceParagraphString) {
    var e_1, _a, e_2, _b;
    if (replaceParagraphString === void 0) { replaceParagraphString = " "; }
    var domParser = new DOMParser();
    xmlFormattedText = fixAmps(xmlFormattedText);
    var xmlObject = domParser.parseFromString("<root>" + xmlFormattedText + "</root>", "application/xml");
    var parseError = xmlObject.querySelector("parsererror");
    if (parseError == null) {
        try {
            for (var _c = __values(Array.from(xmlObject.querySelectorAll("br"))), _d = _c.next(); !_d.done; _d = _c.next()) {
                var br = _d.value;
                br.textContent = replaceParagraphString;
            }
        }
        catch (e_1_1) { e_1 = { error: e_1_1 }; }
        finally {
            try {
                if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
            }
            finally { if (e_1) throw e_1.error; }
        }
        var paragraphArray = Array.from(xmlObject.querySelectorAll("p, li"));
        if (paragraphArray.length > 1) {
            var paragraphArrayWithoutLastElement = _.without(paragraphArray, paragraphArray[paragraphArray.length - 1]);
            try {
                for (var paragraphArrayWithoutLastElement_1 = __values(paragraphArrayWithoutLastElement), paragraphArrayWithoutLastElement_1_1 = paragraphArrayWithoutLastElement_1.next(); !paragraphArrayWithoutLastElement_1_1.done; paragraphArrayWithoutLastElement_1_1 = paragraphArrayWithoutLastElement_1.next()) {
                    var el = paragraphArrayWithoutLastElement_1_1.value;
                    var spaceSpan = document.createElementNS("application/xml", "span");
                    spaceSpan.textContent = replaceParagraphString;
                    el.appendChild(spaceSpan);
                }
            }
            catch (e_2_1) { e_2 = { error: e_2_1 }; }
            finally {
                try {
                    if (paragraphArrayWithoutLastElement_1_1 && !paragraphArrayWithoutLastElement_1_1.done && (_b = paragraphArrayWithoutLastElement_1.return)) _b.call(paragraphArrayWithoutLastElement_1);
                }
                finally { if (e_2) throw e_2.error; }
            }
        }
        return xmlObject.querySelector("root").textContent;
    }
    else {
        console.warn("Bad value xmlObject", xmlObject, parseError.innerHTML);
        return escapeXml(xmlFormattedText);
    }
}
export function unescapeXml(str) {
    var stringForParse = "<span>" + str + "</span>";
    if (isValidXml(stringForParse, false)) {
        var xmlDoc = new DOMParser().parseFromString(stringForParse, "application/xml");
        var span = xmlDoc.querySelector("span");
        return span.textContent;
    }
    else {
        return str;
    }
}
export function escapeXml(str) {
    var xmlDoc = new DOMParser().parseFromString("<span></span>", "application/xml");
    var span = xmlDoc.querySelector("span");
    span.textContent = str;
    var escapedString = (new XMLSerializer()).serializeToString(xmlDoc);
    escapedString = escapedString.replace("<span>", "").replace("</span>", "").replace("<span/>", "").replace("<span />", "");
    return escapedString;
}
export function stringFormat(str) {
    var args = Array.prototype.slice.call(arguments);
    args.splice(0, 1);
    return str.replace(/\{(\d+)\}/g, function (m, n) { return args[n]; });
}
export function pushArray(array, pushValues) {
    Array.prototype.push.apply(array, pushValues);
}
export function getCurrentLineInTextArea(element) {
    var textLines = element.value.split("\n");
    var selectionStart = element.selectionStart;
    var lineInitialPosition = 0;
    for (var i = 0; i < textLines.length; i++) {
        if (lineInitialPosition + textLines[i].length >= selectionStart) {
            return textLines[i];
        }
        lineInitialPosition += textLines[i].length + 1;
    }
}
export function flatten(nestedCollec) {
    var e_3, _a;
    var flattentArray = [];
    if (nestedCollec instanceof Array)
        try {
            for (var nestedCollec_1 = __values(nestedCollec), nestedCollec_1_1 = nestedCollec_1.next(); !nestedCollec_1_1.done; nestedCollec_1_1 = nestedCollec_1.next()) {
                var innerArray = nestedCollec_1_1.value;
                flattentArray.push.apply(flattentArray, __spread(innerArray));
            }
        }
        catch (e_3_1) { e_3 = { error: e_3_1 }; }
        finally {
            try {
                if (nestedCollec_1_1 && !nestedCollec_1_1.done && (_a = nestedCollec_1.return)) _a.call(nestedCollec_1);
            }
            finally { if (e_3) throw e_3.error; }
        }
    return flattentArray;
}
export function createCssDataUri(css) {
    return "data:text/css," + encodeURI(css);
}
//function and css class are from bootstrap library
export function measureScrollbar() {
    var scrollDiv = document.createElement('div');
    scrollDiv.className = 'modal-scrollbar-measure';
    document.body.appendChild(scrollDiv);
    var scrollbarWidth = scrollDiv.offsetWidth - scrollDiv.clientWidth;
    document.body.removeChild(scrollDiv);
    return scrollbarWidth;
}
export function getHiddenElemenHeight(el) {
    var hiddenElement = el.cloneNode();
    document.body.appendChild(hiddenElement);
    var style = getComputedStyle(hiddenElement);
    var height = hiddenElement.offsetHeight + parseFloat(style.marginTop) + parseFloat(style.marginBottom);
    hiddenElement.remove();
    return height;
}
;
/**
 * @param element Element contains twitter bootstrap dropdown
 * @param getFocusElement Function returns element to be focused after dropdown expand
 */
export function enableMoveDropDownFocus(element, getFocusElement) {
    element.querySelectorAll('[data-toggle="dropdown"]').forEach(function (element) {
        element.parentElement.addEventListener("shown.bs.dropdown", function () {
            getFocusElement().focus();
        });
    });
}
export function timeout(delay) {
    if (delay == null)
        delay = 0;
    return new Promise(function (resolve) { return setTimeout(resolve, delay); });
}
export var delay = timeout;
var objectUniqueIdsMap = new Map();
export function getUniqueId(object) {
    if (object == null)
        return null;
    if (!objectUniqueIdsMap.has(object))
        objectUniqueIdsMap.set(object, new Uuid().value);
    return objectUniqueIdsMap.get(object);
}
export function getFontNames(text) {
    var fontNames = [];
    text = fixAmps(text);
    if (isValidXml(text, false)) {
        try {
            if (text != null)
                walkNodes(text, ["span", "ol", "ul"], parseSizeableNode);
        }
        catch (ex) {
            console.error("Unexpected exception while parsing item text");
            console.error(ex);
        }
    }
    return _.unique(fontNames);
    //#region local funcs
    function parseSizeableNode(element) {
        var style = parseXmlStyle(element);
        if (style != null && style.has("font-name"))
            fontNames.push(style.get("font-name"));
    }
    function parseXmlStyle(element) {
        var e_4, _a;
        var styleAttr = element.attributes.getNamedItem("style");
        if (styleAttr == null || styleAttr.value == null)
            return null;
        var nodeStyleParts = styleAttr.value.split(";");
        var styleMap = new Map();
        try {
            for (var nodeStyleParts_1 = __values(nodeStyleParts), nodeStyleParts_1_1 = nodeStyleParts_1.next(); !nodeStyleParts_1_1.done; nodeStyleParts_1_1 = nodeStyleParts_1.next()) {
                var stylePart = nodeStyleParts_1_1.value;
                stylePart = stylePart.trim();
                if (stylePart == null || stylePart === "")
                    continue;
                var content = stylePart.split(":");
                var key = content[0].trim();
                var value = content[1].trim();
                styleMap.set(key, value);
            }
        }
        catch (e_4_1) { e_4 = { error: e_4_1 }; }
        finally {
            try {
                if (nodeStyleParts_1_1 && !nodeStyleParts_1_1.done && (_a = nodeStyleParts_1.return)) _a.call(nodeStyleParts_1);
            }
            finally { if (e_4) throw e_4.error; }
        }
        return styleMap;
    }
    function walkNodes(gmXml, nodeNames, parseNode) {
        var xmlDoc = new DOMParser().parseFromString("<body>" + gmXml + "</body>", "application/xml");
        var filter = {
            acceptNode: function (node) {
                var nodeName = node.nodeName.toLowerCase();
                return nodeNames.includes(nodeName) ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_SKIP;
            }
        };
        if (Environment.IsIE())
            filter = makeIeCompatible(filter);
        var walker = document.createTreeWalker(xmlDoc.childNodes[0], NodeFilter.SHOW_ELEMENT, filter, false);
        while (walker.nextNode()) {
            var node = walker.currentNode;
            parseNode(node);
        }
        function makeIeCompatible(filter) {
            return filter.acceptNode;
        }
    }
    //#endregion
}
export function assign(target, sources, options) {
    options = normalize(options);
    if (options.ignoreNull) {
        for (var i = 0; i < sources.length; i++) {
            var source = cloneDeep(sources[i]);
            //$.extend ignores undefined in the source, but not null
            removeNulls(source);
            sources[i] = source;
        }
    }
    return options.deep
        ? deepExtend.apply(void 0, __spread([target], sources)) : Object.assign.apply(Object, __spread([target], sources));
    function deepExtend(target) {
        var sources = [];
        for (var _i = 1; _i < arguments.length; _i++) {
            sources[_i - 1] = arguments[_i];
        }
        var extendedObj = target;
        var sourceObj = __spread(sources);
        var merge = function (obj) {
            for (var prop in obj) {
                if (obj.hasOwnProperty(prop)) {
                    if (typeof obj[prop] === "object" && extendedObj[prop] != null) {
                        if (typeof extendedObj[prop] === "object")
                            extendedObj[prop] = deepExtend(extendedObj[prop], obj[prop]);
                        else
                            extendedObj = obj[prop];
                    }
                    else {
                        extendedObj[prop] = obj[prop];
                    }
                }
            }
        };
        for (var i = 0; i < sourceObj.length; i++) {
            var obj = sourceObj[i];
            merge(obj);
        }
        return extendedObj;
    }
    ;
    function normalize(op) {
        if (op == null)
            op = {};
        _.defaults(op, { deep: false, ignoreNull: true });
        return op;
    }
    function removeNulls(source) {
        var e_5, _a;
        try {
            for (var _b = __values(Object.keys(source)), _c = _b.next(); !_c.done; _c = _b.next()) {
                var propName = _c.value;
                var property = source[propName];
                if (property === null) {
                    if (source.hasOwnProperty(propName))
                        delete source[propName];
                    else
                        source[propName] = undefined;
                }
                else if (typeof property === "object") {
                    removeNulls(property);
                }
            }
        }
        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; }
        }
    }
}
export function assignProperties(target, propObject) {
    return assign(target, [propObject], { deep: true });
}
export function normalize(paramObject, defaults) {
    if (paramObject == null)
        paramObject = {};
    _.defaults(paramObject, defaults);
    return paramObject;
}
export function toDashedStyle(camleCase) {
    return camleCase.replace(/([A-Z])/g, function (segment) { return "-" + segment.toLowerCase(); });
}
export function getStringEnumValue(enumObject, enumValue) {
    var propertyNames = Object.getOwnPropertyNames(enumObject);
    return propertyNames[propertyNames
        .map(function (i) { return enumObject[i].toString().toLowerCase(); })
        .indexOf(enumValue.toLowerCase())];
}
export function strToInt(str) {
    var value = parseInt(str);
    if (_.isEmpty(str) || isNaN(value) || !isFinite(value))
        return null;
    return value;
}
export function localStorageEnabled() {
    var test = "test";
    try {
        localStorage.setItem(test, test);
        localStorage.removeItem(test);
        return true;
    }
    catch (e) {
        return false;
    }
}
/**
 * @deprecated The method should not be used. User ImageUtils.getImageSizeByUrl from design-atoms module.
 */
export function getImageSize(imageUrl) {
    return __awaiter(this, void 0, void 0, function () {
        function toImageElement(url) {
            return new Promise(function (resolve, reject) {
                var img = new Image();
                img.crossOrigin = "anonymous";
                img.src = url;
                img.onload = function () { return resolve(img); };
                img.onerror = function (e) { return resolve(null); };
                return img;
            });
        }
        var imgElement;
        return __generator(this, function (_a) {
            switch (_a.label) {
                case 0: return [4 /*yield*/, toImageElement(imageUrl)];
                case 1:
                    imgElement = _a.sent();
                    return [2 /*return*/, { width: imgElement.width, height: imgElement.height }];
            }
        });
    });
}
// export function pick<T, K extends keyof T>(o: T, ...keys: K[]): Pick<T, K> {
//     const t = _.pick(o, ...keys);
//     return t;
// }
export function stripForJson(obj, omitProperties) {
    if (omitProperties == null)
        omitProperties = [];
    else if (typeof omitProperties === "string")
        omitProperties = [omitProperties];
    var objectKeys = [];
    // ReSharper disable once MissingHasOwnPropertyInForeach
    for (var key in obj)
        objectKeys.push(key);
    var allowedKeys = objectKeys.filter(function (key) {
        var e_6, _a;
        try {
            for (var _b = __values(["_", "$$"]), _c = _b.next(); !_c.done; _c = _b.next()) {
                var forbiddenPrefix = _c.value;
                if (key.startsWith(forbiddenPrefix))
                    return false;
            }
        }
        catch (e_6_1) { e_6 = { error: e_6_1 }; }
        finally {
            try {
                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
            }
            finally { if (e_6) throw e_6.error; }
        }
        if (omitProperties.some(function (p) { return p === key; }))
            return false;
        if (typeof obj[key] === "function")
            return false;
        return true;
    });
    return allowedKeys.reduce(function (strippedObject, currentKey) {
        strippedObject[currentKey] = obj[currentKey];
        return strippedObject;
    }, {});
}
export function isFocused(element, _a) {
    var _b = (_a === void 0 ? {} : _a).checkDocumentFocus, checkDocumentFocus = _b === void 0 ? false : _b;
    var focused = document.activeElement === element;
    return focused && (checkDocumentFocus ? document.hasFocus() : true);
}
export function getExtension(fileName) {
    var nameParts = fileName.split(".");
    return nameParts.length > 1 ? nameParts[nameParts.length - 1] : "";
}
export function getNameWithoutExtension(fileName) {
    return fileName.split(".")[0];
}
export function applyNullableValue(actual, redefined) {
    return redefined != null
        ? redefined
        : actual;
}
export function applyUndefinedValue(actual, redefined) {
    return redefined !== undefined
        ? redefined
        : actual;
}
export function getLastPathSegment(path) {
    if (isNullOrEmptyOrWhiteSpace(path))
        return path;
    if (!path.includes("/"))
        return path;
    var segments = path.split("/");
    return _.last(segments);
}
export function parsePercentOrPointValue(point, printAreaSize) {
    var result = null;
    if (typeof point === "string" && /%$/.test(point)) {
        var percent = Number(point.split(/%/)[0]);
        result = printAreaSize * percent / 100;
    }
    else {
        result = Number(point);
    }
    if (typeof result !== "number" || isNaN(result))
        throw new ArgumentException("'" + point + "' is not a number or percent string");
    return result;
}
//# sourceMappingURL=Utils.js.map