@telia-ace/widget-utilities 1.0.0

package/LICENSE.txt

@@ -0,0 +1,6 @@
+Copyright © 2021, Telia Company AB. All rights reserved.
+
+THIS PACKAGE AND CONTAINING SOFTWARE IS PART OF
+THE HUMANY SERVICE. BY USING THIS SOFTWARE YOU
+AGREE TO THE FOLLOWING TERMS AND CONDITIONS:
+http://www.humany.com/legal

package/README.md

@@ -0,0 +1,3 @@
+# `@telia-ace/widget-types-grid`
+
+The type definition for ACE One Widget (exported as `GridWidget`).

package/lib/append-class-names.d.ts

@@ -0,0 +1,6 @@
+declare type ArgumentHandler = string | [boolean, string | string[]] | undefined;
+export declare function uniqueClassArray(classNames: string[]): string[];
+export declare function append(className1?: string, className2?: string): string;
+export declare function handleFunctionArgument(expression: boolean, classes: string | string[]): string | undefined;
+export default function appendClassNames(...args: ArgumentHandler[]): string;
+export {};

package/lib/append-class-names.js

@@ -0,0 +1,84 @@
+"use strict";
+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 __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleFunctionArgument = exports.append = exports.uniqueClassArray = void 0;
+var _1 = require(".");
+function uniqueClassArray(classNames) {
+    var classArray = [];
+    classNames.forEach(function (c) {
+        if (classArray.indexOf(c) === -1) {
+            classArray.push(c);
+        }
+    });
+    return classArray;
+}
+exports.uniqueClassArray = uniqueClassArray;
+function append(className1, className2) {
+    if (className1 === void 0) { className1 = ''; }
+    if (className2 === void 0) { className2 = ''; }
+    var classNames = className1.split(' ').concat(className2.split(' '));
+    return uniqueClassArray(classNames).join(' ').trim();
+}
+exports.append = append;
+function handleFunctionArgument(expression, classes) {
+    if (Boolean(expression)) {
+        if (typeof classes === 'string') {
+            return classes;
+        }
+        if (Array.isArray(classes)) {
+            var className_1 = '';
+            classes.forEach(function (c) { return (className_1 = append(className_1, c)); });
+            return className_1;
+        }
+    }
+}
+exports.handleFunctionArgument = handleFunctionArgument;
+function appendClassNames() {
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+    }
+    var className = '';
+    if (args.length) {
+        args.forEach(function (argument) {
+            if (typeof argument === 'string') {
+                className = append(className, argument);
+            }
+            else if (Array.isArray(argument)) {
+                className = append(className, handleFunctionArgument.apply(void 0, __spreadArray([], __read(argument), false)));
+            }
+            else if (typeof argument !== 'undefined' && argument !== null) {
+                if (process.env.NODE_ENV !== 'production') {
+                    _1.Logger.warn.apply(_1.Logger, __spreadArray(['appendClassNames: arguments either have' +
+                            'to be a string or [boolean, ...string[]]. Passed args:'], __read(args), false));
+                }
+            }
+        });
+    }
+    return className;
+}
+exports.default = appendClassNames;

package/lib/batch.d.ts

@@ -0,0 +1,4 @@
+export declare type BatchFunction<T> = (acc: T) => T;
+export declare type Batch<T> = (fn: BatchFunction<T>) => Promise<T>;
+declare const createBatch: <T>(delay: number, createFallback: () => T) => Batch<T>;
+export default createBatch;

package/lib/batch.js

@@ -0,0 +1,38 @@
+"use strict";
+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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var createBatch = function (delay, createFallback) {
+    var timeout;
+    var queue = [];
+    return function (fn) {
+        clearTimeout(timeout);
+        return new Promise(function (resolve, reject) {
+            queue.push([fn, resolve, reject]);
+            timeout = setTimeout(function () {
+                var acc = createFallback();
+                queue.forEach(function (_a) {
+                    var _b = __read(_a, 3), fn = _b[0], resolve = _b[1], reject = _b[2];
+                    acc = fn(acc);
+                });
+                queue = [];
+                resolve(acc);
+            }, delay);
+        });
+    };
+};
+exports.default = createBatch;

package/lib/camilize.d.ts

@@ -0,0 +1 @@
+export default function camilize(obj: any): any;

package/lib/camilize.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function camilize(obj) {
+    var camilizedObject = {};
+    if (typeof obj === 'number' || typeof obj === 'string') {
+        return obj;
+    }
+    for (var prop in obj) {
+        if (obj.hasOwnProperty(prop)) {
+            var p = obj[prop];
+            var camilizedProp = prop.substring(0, 1).toLowerCase() + prop.substring(1);
+            if (Object.prototype.toString.call(p) === '[object Array]') {
+                camilizedObject[camilizedProp] = [];
+                for (var i = 0, c = p.length; i < c; i++) {
+                    // tslint:disable-line no-increment-decrement
+                    camilizedObject[camilizedProp].push(camilize(p[i]));
+                }
+            }
+            else if (p !== null && typeof p === 'object') {
+                camilizedObject[camilizedProp] = camilize(p);
+            }
+            else {
+                camilizedObject[camilizedProp] = p;
+            }
+        }
+    }
+    return camilizedObject;
+}
+exports.default = camilize;

package/lib/category-trail.d.ts

@@ -0,0 +1,14 @@
+import { Container } from '@webprovisions/platform';
+declare type Item = {
+    id: string;
+    items?: Item[];
+    title: string;
+    symbol?: any;
+};
+declare type ChildParentStructure = {
+    [key: number]: string;
+};
+export declare function categoryTrail(id: string, items: Item[], ids?: string[], structure?: ChildParentStructure): string[];
+export declare const getCategoryTrailAsObjects: (trail: string[], categories: Item[]) => Map<string, Item>;
+export declare const buildCategoryTrail: (routeName: string, categoryIds: string | string[], container: Container, dataType?: 'guide-categories' | 'contact-method-categories') => Promise<any[]>;
+export {};

package/lib/category-trail.js

@@ -0,0 +1,96 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildCategoryTrail = exports.getCategoryTrailAsObjects = exports.categoryTrail = void 0;
+var create_params_1 = __importDefault(require("./create-params"));
+var find_category_by_id_1 = __importDefault(require("./find-category-by-id"));
+var format_url_1 = __importDefault(require("./format-url"));
+function childParentStructure(items, structure, parent) {
+    if (structure === void 0) { structure = {}; }
+    items.forEach(function (item) {
+        if (parent) {
+            structure[+item.id] = parent;
+        }
+        if (item.items) {
+            childParentStructure(item.items, structure, item.id);
+        }
+    });
+    return structure;
+}
+function categoryTrail(id, items, ids, structure) {
+    if (ids === void 0) { ids = [id]; }
+    if (structure === void 0) { structure = childParentStructure(items); }
+    var addAncestors = function (id) {
+        var parentId = structure[+id];
+        if (parentId) {
+            ids.unshift(parentId);
+            addAncestors(parentId);
+        }
+    };
+    var parentId = structure[+id];
+    if (parentId) {
+        ids.unshift(parentId);
+        addAncestors(parentId);
+    }
+    return ids;
+}
+exports.categoryTrail = categoryTrail;
+var getCategoryTrailAsObjects = function (trail, categories) {
+    if (typeof trail === 'undefined' || typeof categories === 'undefined') {
+        return new Map();
+    }
+    return new Map(trail.map(function (categoryId) {
+        var category = (0, find_category_by_id_1.default)(categoryId, categories);
+        return [categoryId, category];
+    }));
+};
+exports.getCategoryTrailAsObjects = getCategoryTrailAsObjects;
+var buildCategoryTrail = function (routeName, categoryIds, container, dataType) {
+    if (dataType === void 0) { dataType = 'guide-categories'; }
+    return container.getAsync('dataClient').then(function (dataClient) {
+        return dataClient
+            .fetch(dataType, { expandCategories: 'descendants' })
+            .then(function (_a) {
+            var categories = _a.categories;
+            var buildTrail = function (id) {
+                var trail = categoryTrail(id, categories);
+                var objectTrail = (0, exports.getCategoryTrailAsObjects)(trail, categories);
+                var result = [];
+                trail.forEach(function (categoryId) {
+                    var category = objectTrail.get(categoryId);
+                    if (category) {
+                        result.push({
+                            routeName: routeName,
+                            title: category.title,
+                            symbol: category.symbol,
+                            id: category.id,
+                            routeParams: dataType === 'contact-method-categories'
+                                ? (0, create_params_1.default)({
+                                    contactCategory: category.id,
+                                    uriName: (0, format_url_1.default)(category.title),
+                                })
+                                : (0, create_params_1.default)({
+                                    guideCategory: category.id,
+                                    uriName: (0, format_url_1.default)(category.title),
+                                }),
+                        });
+                    }
+                });
+                return result;
+            };
+            if (Array.isArray(categoryIds)) {
+                return categoryIds.reduce(function (acc, id) {
+                    var result = buildTrail(id);
+                    if (result.length > 0) {
+                        acc.push(result);
+                    }
+                    return acc;
+                }, []);
+            }
+            return buildTrail(categoryIds);
+        });
+    });
+};
+exports.buildCategoryTrail = buildCategoryTrail;

package/lib/create-params.d.ts

@@ -0,0 +1,21 @@
+export declare type Input = {
+    phrase?: string;
+    category?: ParamValue;
+    guideCategory?: ParamValue;
+    contactCategory?: ParamValue;
+    take?: number;
+    connectionKey?: string;
+    id?: string;
+    uriName?: string;
+    sorting?: string;
+    tag?: string;
+    tagId?: string | number;
+    tagTitle?: string;
+} & {
+    [key: string]: ParamValue;
+};
+export declare type ParamValue = string | number | any;
+export declare type Params = {
+    [key: string]: ParamValue;
+};
+export default function createParams(args?: Input): Params;

package/lib/create-params.js

@@ -0,0 +1,108 @@
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+function createParams(args) {
+    if (args === void 0) { args = {}; }
+    var _a = args.phrase, phrase = _a === void 0 ? '' : _a, category = args.category, guideCategory = args.guideCategory, contactCategory = args.contactCategory, take = args.take, connectionKey = args.connectionKey, accordion = args.accordion, id = args.id, uriName = args.uriName, sorting = args.sorting, tag = args.tag, tagId = args.tagId, tagTitle = args.tagTitle, other = __rest(args, ["phrase", "category", "guideCategory", "contactCategory", "take", "connectionKey", "accordion", "id", "uriName", "sorting", "tag", "tagId", "tagTitle"]);
+    var params = {};
+    Object.keys(other).forEach(function (k) {
+        if (typeof args[k] === 'string') {
+            params[k] = args[k];
+        }
+    });
+    if (typeof phrase === 'string' && phrase.length) {
+        params.phrase = phrase;
+    }
+    if (phrase === null) {
+        params.phrase = phrase;
+    }
+    if (typeof guideCategory === 'string' && guideCategory !== '0') {
+        params.guideCategory = guideCategory;
+    }
+    if (typeof guideCategory === 'number' && guideCategory !== 0) {
+        params.guideCategory = guideCategory;
+    }
+    if (typeof guideCategory === 'object' && guideCategory !== null) {
+        if (typeof guideCategory.id === 'string' && guideCategory.id !== '0') {
+            params.guideCategory = guideCategory.id;
+        }
+        if (typeof guideCategory.id === 'number' && guideCategory.id !== 0) {
+            params.guideCategory = guideCategory.id;
+        }
+    }
+    if (typeof contactCategory === 'string' && contactCategory !== '0') {
+        params.contactCategory = contactCategory;
+    }
+    if (typeof contactCategory === 'number' && contactCategory !== 0) {
+        params.contactCategory = contactCategory;
+    }
+    if (typeof contactCategory === 'object' && contactCategory !== null) {
+        if (typeof contactCategory.id === 'string' && contactCategory.id !== '0') {
+            params.contactCategory = contactCategory.id;
+        }
+        if (typeof contactCategory.id === 'number' && contactCategory.id !== 0) {
+            params.contactCategory = contactCategory.id;
+        }
+    }
+    if (typeof category === 'string' && category !== '0') {
+        params.category = category;
+    }
+    if (typeof category === 'number' && category !== 0) {
+        params.category = category;
+    }
+    if (typeof category === 'object' && category !== null) {
+        if (typeof category.id === 'string' && category.id !== '0') {
+            params.category = category.id;
+        }
+        if (typeof category.id === 'number' && category.id !== 0) {
+            params.category = category.id;
+        }
+    }
+    if (id) {
+        params.id = id;
+    }
+    if (uriName &&
+        (!!+params.category ||
+            !!+params.guideCategory ||
+            !!+params.guide ||
+            !!+params.contactCategory ||
+            !!+params.contactMethod)) {
+        params.uriName = uriName;
+    }
+    if (connectionKey) {
+        params.connectionKey = connectionKey;
+    }
+    if (take) {
+        params.take = take;
+    }
+    if (sorting) {
+        params.sorting = sorting;
+    }
+    if (typeof accordion === 'string' && accordion.length > 0) {
+        params.accordion = accordion;
+    }
+    if (typeof tag === 'string' && tag !== '0') {
+        params.tag = tag;
+    }
+    if (typeof tag === 'number' && tag !== 0) {
+        params.tag = tag;
+    }
+    if (typeof tagId === 'string' || typeof tagId === 'number') {
+        params.tagId = tagId;
+    }
+    if (typeof tagTitle === 'string') {
+        params.tagTitle = tagTitle;
+    }
+    return params;
+}
+exports.default = createParams;

package/lib/data-uri-to-blob.d.ts

@@ -0,0 +1,2 @@
+declare const dataURItoBlob: (dataURI: string) => Blob;
+export default dataURItoBlob;

package/lib/data-uri-to-blob.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var dataURItoBlob = function (dataURI) {
+    var byteString;
+    var mimestring;
+    if (dataURI.split(',')[0].indexOf('base64') !== -1) {
+        byteString = atob(dataURI.split(',')[1]);
+    }
+    else {
+        byteString = decodeURI(dataURI.split(',')[1]);
+    }
+    mimestring = dataURI.split(',')[0].split(':')[1].split(';')[0];
+    var content = [];
+    for (var i = 0; i < byteString.length; i++) {
+        // tslint:disable-line no-increment-decrement
+        content[i] = byteString.charCodeAt(i);
+    }
+    return new Blob([new Uint8Array(content)], { type: mimestring });
+};
+exports.default = dataURItoBlob;

package/lib/debug.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Checks if process.env.NODE_ENV === 'production'
+ * and passes arguments to console.warn().
+ */
+export declare function debugLog(...args: any[]): false | void;
+/**
+ * Simple internal log-handler
+ */
+export declare class Logger {
+    private keys;
+    private lookup;
+    /**
+     * Passes args to console.log
+     */
+    static log: (...args: any[]) => void;
+    /**
+     * Passes args to console.warn
+     */
+    static warn: (...args: any[]) => void;
+    /**
+     * Passes args to console.error
+     */
+    static error: (...args: any[]) => void;
+    /**
+     * Passes args to console.info
+     */
+    static info: (...args: any[]) => void;
+    /**
+     * Checks if key already has been logged.
+     * If not, passes following args to console.log
+     * and stores key in logged messages.
+     */
+    log: (key: string, ...args: any[]) => void;
+    /**
+     * Checks if key already has been logged.
+     * If not, passes following args to console.warn
+     * and stores key in logged messages.
+     */
+    warn: (key: string, ...args: any[]) => void;
+    /**
+     * Checks if key already has been logged.
+     * If not, passes following args to console.error
+     * and stores key in logged messages.
+     */
+    error: (key: string, ...args: any[]) => void;
+    /**
+     * Checks if key already has been logged.
+     * If not, passes following args to console.info
+     * and stores key in logged messages.
+     */
+    info: (key: string, ...args: any[]) => void;
+}

package/lib/debug.js

@@ -0,0 +1,155 @@
+"use strict";
+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 __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = exports.debugLog = void 0;
+/**
+ * Checks if process.env.NODE_ENV === 'production'
+ * and passes arguments to console.warn().
+ */
+function debugLog() {
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+    }
+    return process.env.NODE_ENV !== 'production' && console && console.warn.apply(console, __spreadArray([], __read(args), false));
+}
+exports.debugLog = debugLog;
+var print = function (print, msgOrObj) {
+    var args = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        args[_i - 2] = arguments[_i];
+    }
+    if (typeof msgOrObj === 'string') {
+        return print.apply(void 0, __spreadArray(["[humany] ".concat(msgOrObj)], __read(args), false));
+    }
+    return print.apply(void 0, __spreadArray([msgOrObj], __read(args), false));
+};
+/**
+ * Simple internal log-handler
+ */
+var Logger = /** @class */ (function () {
+    function Logger() {
+        var _this = this;
+        this.keys = [];
+        /**
+         * Checks if key already has been logged.
+         * If not, passes following args to console.log
+         * and stores key in logged messages.
+         */
+        this.log = function (key) {
+            var args = [];
+            for (var _i = 1; _i < arguments.length; _i++) {
+                args[_i - 1] = arguments[_i];
+            }
+            return _this.lookup(key, function () { return Logger.log.apply(Logger, __spreadArray([], __read(args), false)); });
+        };
+        /**
+         * Checks if key already has been logged.
+         * If not, passes following args to console.warn
+         * and stores key in logged messages.
+         */
+        this.warn = function (key) {
+            var args = [];
+            for (var _i = 1; _i < arguments.length; _i++) {
+                args[_i - 1] = arguments[_i];
+            }
+            return _this.lookup(key, function () { return Logger.warn.apply(Logger, __spreadArray([], __read(args), false)); });
+        };
+        /**
+         * Checks if key already has been logged.
+         * If not, passes following args to console.error
+         * and stores key in logged messages.
+         */
+        this.error = function (key) {
+            var args = [];
+            for (var _i = 1; _i < arguments.length; _i++) {
+                args[_i - 1] = arguments[_i];
+            }
+            return _this.lookup(key, function () { return Logger.error.apply(Logger, __spreadArray([], __read(args), false)); });
+        };
+        /**
+         * Checks if key already has been logged.
+         * If not, passes following args to console.info
+         * and stores key in logged messages.
+         */
+        this.info = function (key) {
+            var args = [];
+            for (var _i = 1; _i < arguments.length; _i++) {
+                args[_i - 1] = arguments[_i];
+            }
+            return _this.lookup(key, function () { return Logger.info.apply(Logger, __spreadArray([], __read(args), false)); });
+        };
+    }
+    Logger.prototype.lookup = function (key, fn) {
+        if (this.keys.indexOf(key) === -1) {
+            this.keys.push(key);
+            fn();
+        }
+    };
+    /**
+     * Passes args to console.log
+     */
+    Logger.log = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return print.apply(void 0, __spreadArray([console.log], __read(args), false));
+    };
+    /**
+     * Passes args to console.warn
+     */
+    Logger.warn = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return print.apply(void 0, __spreadArray([console.warn], __read(args), false));
+    };
+    /**
+     * Passes args to console.error
+     */
+    Logger.error = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return print.apply(void 0, __spreadArray([console.error], __read(args), false));
+    };
+    /**
+     * Passes args to console.info
+     */
+    Logger.info = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return print.apply(void 0, __spreadArray([console.info], __read(args), false));
+    };
+    return Logger;
+}());
+exports.Logger = Logger;

package/lib/deep-clone.d.ts

@@ -0,0 +1,2 @@
+declare const deepClone: <Type>(data: Type) => Type;
+export default deepClone;