@telia-ace/widget-utilities 1.0.0

package/lib/merge-deep.js

@@ -0,0 +1,72 @@
+"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));
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var deep_clone_1 = __importDefault(require("./deep-clone"));
+var isObject = function (item) {
+    return !!item && typeof item === 'object' && !Array.isArray(item);
+};
+/**
+ * @param target Target to merge into
+ * @param sources Source to merge into target
+ * @returns Clone (new reference) with merged sources
+ */
+var mergeDeep = function (target) {
+    var sources = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        sources[_i - 1] = arguments[_i];
+    }
+    var clonedTarget = (0, deep_clone_1.default)(target);
+    var clonedSources = (0, deep_clone_1.default)(sources);
+    return mergeDeepRecursive.apply(void 0, __spreadArray([clonedTarget], __read(clonedSources), false));
+};
+var mergeDeepRecursive = function (target) {
+    var _a, _b;
+    var sources = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        sources[_i - 1] = arguments[_i];
+    }
+    if (!sources.length)
+        return target;
+    var source = sources.shift();
+    if (isObject(target) && isObject(source)) {
+        for (var key in source) {
+            if (isObject(source[key])) {
+                if (!target[key])
+                    Object.assign(target, (_a = {}, _a[key] = {}, _a));
+                mergeDeepRecursive(target[key], source[key]);
+            }
+            else {
+                Object.assign(target, (_b = {}, _b[key] = source[key], _b));
+            }
+        }
+    }
+    return mergeDeepRecursive.apply(void 0, __spreadArray([target], __read(sources), false));
+};
+exports.default = mergeDeep;

package/lib/notify-data-loaded.d.ts

@@ -0,0 +1,6 @@
+import { Container } from '@webprovisions/platform';
+/**
+ * Wait for all visible components to render
+ */
+declare const notifyDataLoaded: (viewOutletContainer: Container, widgetDOMElement: HTMLElement) => void;
+export default notifyDataLoaded;

package/lib/notify-data-loaded.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Dispatch widget:data-loaded event when all components
+ * is considered to be finished loading their initial data
+ */
+var watchForLoadingComplete = function (container, widgetDOMElement) {
+    var isLoading = function () { return widgetDOMElement.querySelectorAll('[data-loading=true]').length > 0; };
+    var complete = function () {
+        var dispatched = false;
+        return function () {
+            if (dispatched) {
+                return;
+            }
+            var widget = container.get('$widget');
+            widget.events.dispatch('widget:data-loaded', {
+                element: widgetDOMElement,
+            });
+            dispatched = true;
+        };
+    };
+    var handleComplete = complete();
+    if (!isLoading()) {
+        return handleComplete();
+    }
+    var observer = new MutationObserver(function (mutations, observer) {
+        var check = mutations.find(function (mutation) {
+            return mutation.type === 'attributes' && mutation.attributeName === 'data-loading';
+        });
+        if (check && !isLoading()) {
+            observer.disconnect();
+            handleComplete();
+        }
+    });
+    observer.observe(widgetDOMElement, {
+        attributes: true,
+        childList: true,
+        subtree: true,
+    });
+};
+/**
+ * Wait for all visible components to render
+ */
+var notifyDataLoaded = function (viewOutletContainer, widgetDOMElement) {
+    var widget = viewOutletContainer.get('$widget');
+    widget.container.getAsync('components').then(function (components) {
+        components.events.subscribeOnce('components:component-model-initialized', function () {
+            // Store the names of all visible components we should wait for
+            var waitingFor = components.nodes.visible.reduce(function (acc, node) {
+                if (!node.name ||
+                    !node.type ||
+                    node.type === 'view' ||
+                    node.type === 'root' ||
+                    node.attributes.layout.size === 'none') {
+                    return acc;
+                }
+                acc.push(node.name);
+                return acc;
+            }, []);
+            var complete = false;
+            var observer = new MutationObserver(function (mutations, observer) {
+                mutations.forEach(function (mutation) {
+                    if (mutation.addedNodes) {
+                        var componentElements_1 = Array.from(mutation.addedNodes).reduce(function (acc, element) {
+                            var dataName = element.getAttribute && element.getAttribute('data-name');
+                            if (dataName && waitingFor.indexOf(dataName) > -1) {
+                                acc.push(dataName);
+                            }
+                            return acc;
+                        }, []);
+                        // Remove added elements from the list of elements we are waiting for
+                        waitingFor = waitingFor.filter(function (name) {
+                            return componentElements_1.indexOf(name) === -1;
+                        });
+                        // When the list is empty, we are finished waiting for components to render
+                        if (!complete && waitingFor.length === 0) {
+                            complete = true;
+                            // Creates a new observer that observes data-loading changes
+                            watchForLoadingComplete(viewOutletContainer, widgetDOMElement);
+                            observer.disconnect();
+                        }
+                    }
+                });
+            });
+            observer.observe(widgetDOMElement, {
+                attributes: false,
+                characterData: false,
+                childList: true,
+                subtree: true,
+                attributeOldValue: false,
+                characterDataOldValue: false,
+            });
+        });
+    });
+};
+exports.default = notifyDataLoaded;

package/lib/remove-null-and-undefined-values.d.ts

@@ -0,0 +1,6 @@
+declare const removeNullAndUndefinedValues: (object?: {
+    [key: string]: any;
+}) => {
+    [key: string]: any;
+};
+export default removeNullAndUndefinedValues;

package/lib/remove-null-and-undefined-values.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var removeNullAndUndefinedValues = function (object) {
+    if (object === void 0) { object = {}; }
+    Object.keys(object).forEach(function (key) {
+        if (object[key] === null || typeof object[key] === 'undefined') {
+            delete object[key];
+        }
+    });
+    return object;
+};
+exports.default = removeNullAndUndefinedValues;

package/lib/set-cookie.d.ts

@@ -0,0 +1 @@
+export default function setCookie(cookieName: string, value: any, days: number): void;

package/lib/set-cookie.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function setCookie(cookieName, value, days) {
+    var expires = '';
+    if (days) {
+        var date = new Date();
+        date.setTime(date.getTime() + days * 24 * 60 * 60 * 1000);
+        expires = "; expires=".concat(date.toUTCString());
+    }
+    document.cookie = "".concat(cookieName, "=").concat(value).concat(expires, "; path=/");
+}
+exports.default = setCookie;

package/lib/shallow-compare.d.ts

@@ -0,0 +1,6 @@
+declare const _default: (a: {
+    [key: string]: any;
+}, b: {
+    [key: string]: any;
+}) => boolean;
+export default _default;

package/lib/shallow-compare.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = (function (a, b) {
+    var equal = true;
+    if (Object.keys(a).length !== Object.keys(b).length) {
+        return false;
+    }
+    var missingKey = Object.keys(a).some(function (key) {
+        var found = Object.keys(b).some(function (bKey) {
+            return key === bKey;
+        });
+        return !found;
+    });
+    if (missingKey) {
+        return false;
+    }
+    Object.keys(a).forEach(function (key) {
+        if (equal) {
+            var c = typeof a[key] === 'undefined' ? '' : a[key];
+            var d = typeof b[key] === 'undefined' ? '' : b[key];
+            equal = c.toString() === d.toString();
+        }
+    });
+    return equal;
+});

package/lib/uuid.d.ts

@@ -0,0 +1 @@
+export default function uuid(): string;

package/lib/uuid.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var s4 = function () {
+    return Math.floor((1 + Math.random()) * 0x10000)
+        .toString(16)
+        .substring(1);
+};
+function uuid() {
+    // tslint:disable-next-line prefer-template
+    return s4() + s4() + '-' + s4() + '-' + s4() + '-' + s4() + '-' + s4() + s4() + s4();
+}
+exports.default = uuid;

package/lib/wait-for.d.ts

@@ -0,0 +1,20 @@
+declare type Action = (...args: any[]) => Function | false;
+export declare type WaitForOptions = {
+    callCount?: number;
+};
+export default class WaitFor {
+    private queue;
+    private queueAttempt;
+    private queueAttemptCalls;
+    private callCount;
+    constructor(options?: WaitForOptions);
+    /**
+     * Add action to the queue
+     */
+    add: (action: Action) => void;
+    /**
+     * Go through queue and attempt to call each action
+     */
+    processQueue: () => void;
+}
+export {};

package/lib/wait-for.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var WaitFor = /** @class */ (function () {
+    function WaitFor(options) {
+        var _this = this;
+        this.queue = [];
+        this.queueAttemptCalls = 0;
+        this.callCount = 5;
+        /**
+         * Add action to the queue
+         */
+        this.add = function (action) {
+            _this.queue.push(action);
+            _this.queueAttempt = setInterval(_this.processQueue, 1000);
+        };
+        /**
+         * Go through queue and attempt to call each action
+         */
+        this.processQueue = function () {
+            if (_this.queue.length > 0) {
+                var indexOfActionsEmitted_1 = [];
+                _this.queue.forEach(function (queuedAction, index) {
+                    var evaluate = queuedAction();
+                    if (typeof evaluate === 'function') {
+                        evaluate();
+                        indexOfActionsEmitted_1.push(index);
+                    }
+                });
+                // clean up queue
+                _this.queue = _this.queue.filter(function (_, index) {
+                    if (indexOfActionsEmitted_1.indexOf(index) > -1) {
+                        return false;
+                    }
+                    return true;
+                });
+                if (_this.queueAttempt) {
+                    clearInterval(_this.queueAttempt);
+                }
+            }
+            if (_this.queueAttemptCalls > _this.callCount) {
+                clearInterval(_this.queueAttempt);
+                _this.queueAttemptCalls = 0;
+            }
+            _this.queueAttemptCalls = _this.queueAttemptCalls + 1;
+        };
+        if (options && options.callCount) {
+            this.callCount = options.callCount;
+        }
+    }
+    return WaitFor;
+}());
+exports.default = WaitFor;

package/lib-esm/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-esm/append-class-names.js

@@ -0,0 +1,77 @@
+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));
+};
+import { Logger } from '.';
+export function uniqueClassArray(classNames) {
+    var classArray = [];
+    classNames.forEach(function (c) {
+        if (classArray.indexOf(c) === -1) {
+            classArray.push(c);
+        }
+    });
+    return classArray;
+}
+export 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();
+}
+export 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;
+        }
+    }
+}
+export default 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') {
+                    Logger.warn.apply(Logger, __spreadArray(['appendClassNames: arguments either have' +
+                            'to be a string or [boolean, ...string[]]. Passed args:'], __read(args), false));
+                }
+            }
+        });
+    }
+    return className;
+}

package/lib-esm/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-esm/batch.js

@@ -0,0 +1,36 @@
+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 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);
+        });
+    };
+};
+export default createBatch;

package/lib-esm/camilize.d.ts

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

package/lib-esm/camilize.js

@@ -0,0 +1,26 @@
+export default 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;
+}

package/lib-esm/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-esm/category-trail.js

@@ -0,0 +1,87 @@
+import createParams from './create-params';
+import { default as findCategoryById } from './find-category-by-id';
+import formatUrl from './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;
+}
+export 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;
+}
+export var getCategoryTrailAsObjects = function (trail, categories) {
+    if (typeof trail === 'undefined' || typeof categories === 'undefined') {
+        return new Map();
+    }
+    return new Map(trail.map(function (categoryId) {
+        var category = findCategoryById(categoryId, categories);
+        return [categoryId, category];
+    }));
+};
+export 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 = 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'
+                                ? createParams({
+                                    contactCategory: category.id,
+                                    uriName: formatUrl(category.title),
+                                })
+                                : createParams({
+                                    guideCategory: category.id,
+                                    uriName: formatUrl(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);
+        });
+    });
+};

package/lib-esm/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;