@telia-ace/widget-utilities 1.0.0

package/lib-esm/hash.d.ts

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

package/lib-esm/hash.js

@@ -0,0 +1,13 @@
+export default function (s) {
+    var hash = 0;
+    if (s.length === 0) {
+        return hash.toString();
+    }
+    // tslint:disable-next-line:no-increment-decrement
+    for (var i = 0; i < s.length; i++) {
+        var char = s.charCodeAt(i);
+        hash = (hash << 5) - hash + char;
+        hash = hash & hash;
+    }
+    return hash.toString();
+}

package/lib-esm/html-parent-contains.d.ts

@@ -0,0 +1,7 @@
+declare const _default: (parent: HTMLElement | Window, child: Element | null) => boolean;
+/**
+ * Checks whether or not the passed child is a descendant
+ * of the passed parent.
+ * Will return true if falsey parent or child.
+ */
+export default _default;

package/lib-esm/html-parent-contains.js

@@ -0,0 +1,19 @@
+/**
+ * Checks whether or not the passed child is a descendant
+ * of the passed parent.
+ * Will return true if falsey parent or child.
+ */
+export default (function (parent, child) {
+    if (!parent || !child) {
+        return true;
+    }
+    var node = child.parentNode;
+    var hasChild = false;
+    while (node !== null) {
+        if (node === parent) {
+            hasChild = true;
+        }
+        node = node.parentNode;
+    }
+    return hasChild;
+});

package/lib-esm/index.d.ts

@@ -0,0 +1,27 @@
+export { default as appendClassNames } from './append-class-names';
+export { default as createBatch } from './batch';
+export type { Batch, BatchFunction } from './batch';
+export { default as camilize } from './camilize';
+export { buildCategoryTrail, categoryTrail, getCategoryTrailAsObjects } from './category-trail';
+export { default as createParams } from './create-params';
+export type { Params, ParamValue } from './create-params';
+export { default as dataURItoBlob } from './data-uri-to-blob';
+export { debugLog, Logger } from './debug';
+export { default as deepClone } from './deep-clone';
+export { default as findAndActivateStoredWidgets } from './find-and-activate-stored-widgets';
+export { default as findCategoryById } from './find-category-by-id';
+export { default as formatDate } from './format-date';
+export { default as formatUrl } from './format-url';
+export { default as getCookie } from './get-cookie';
+export { default as hash } from './hash';
+export { default as htmlParentContains } from './html-parent-contains';
+export { default as kebabCase } from './kebab-case';
+export { default as lock } from './lock';
+export { default as mergeDeep } from './merge-deep';
+export { default as notifyDataLoaded } from './notify-data-loaded';
+export { default as removeNullAndUndefinedValues } from './remove-null-and-undefined-values';
+export { default as setCookie } from './set-cookie';
+export { default as shallowCompare } from './shallow-compare';
+export { default as uuid } from './uuid';
+export { default as WaitFor } from './wait-for';
+export type { WaitForOptions } from './wait-for';

package/lib-esm/index.js

@@ -0,0 +1,24 @@
+export { default as appendClassNames } from './append-class-names';
+export { default as createBatch } from './batch';
+export { default as camilize } from './camilize';
+export { buildCategoryTrail, categoryTrail, getCategoryTrailAsObjects } from './category-trail';
+export { default as createParams } from './create-params';
+export { default as dataURItoBlob } from './data-uri-to-blob';
+export { debugLog, Logger } from './debug';
+export { default as deepClone } from './deep-clone';
+export { default as findAndActivateStoredWidgets } from './find-and-activate-stored-widgets';
+export { default as findCategoryById } from './find-category-by-id';
+export { default as formatDate } from './format-date';
+export { default as formatUrl } from './format-url';
+export { default as getCookie } from './get-cookie';
+export { default as hash } from './hash';
+export { default as htmlParentContains } from './html-parent-contains';
+export { default as kebabCase } from './kebab-case';
+export { default as lock } from './lock';
+export { default as mergeDeep } from './merge-deep';
+export { default as notifyDataLoaded } from './notify-data-loaded';
+export { default as removeNullAndUndefinedValues } from './remove-null-and-undefined-values';
+export { default as setCookie } from './set-cookie';
+export { default as shallowCompare } from './shallow-compare';
+export { default as uuid } from './uuid';
+export { default as WaitFor } from './wait-for';

package/lib-esm/is-anchor-link.d.ts

@@ -0,0 +1,2 @@
+declare const isAnchorLink: (href: string) => boolean;
+export default isAnchorLink;

package/lib-esm/is-anchor-link.js

@@ -0,0 +1,7 @@
+// Determine if href starts with a hashtag
+var isAnchorLink = function (href) {
+    var re = new RegExp('^#', 'i');
+    var match = re.test(href);
+    return match;
+};
+export default isAnchorLink;

package/lib-esm/kebab-case.d.ts

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

package/lib-esm/kebab-case.js

@@ -0,0 +1,6 @@
+export default function kebabCase(string) {
+    return string
+        .replace(/([a-z])([A-Z])/g, '$1-$2')
+        .replace(/\s+/g, '-')
+        .toLowerCase();
+}

package/lib-esm/lock.d.ts

@@ -0,0 +1,9 @@
+declare type Task = () => Promise<any> | any;
+export declare type AddTask = (task: Task) => Promise<any>;
+/**
+ * Creates a lock for the specified owner that allows only one executing
+ * task simultaneously.
+ * @param key Lock owner.
+ */
+export default function lock(key: object, lockWarningTime?: number, lockErrorTime?: number): AddTask;
+export {};

package/lib-esm/lock.js

@@ -0,0 +1,75 @@
+import { Logger } from './debug';
+var Queue = /** @class */ (function () {
+    function Queue(lockWarningTime, lockErrorTime) {
+        this.lockWarningTime = lockWarningTime;
+        this.lockErrorTime = lockErrorTime;
+        this.tasks = [];
+        this.current = Promise.resolve();
+        this.next = this.next.bind(this);
+    }
+    Queue.prototype.add = function (task, resolve, reject, done) {
+        this.tasks.push({ task: task, resolve: resolve, reject: reject, done: done });
+        this.next();
+    };
+    Queue.prototype.next = function () {
+        var _this = this;
+        this.current = this.current.then(function () {
+            var next = _this.tasks.shift();
+            if (next) {
+                var errorTimeout_1; // NodeJS.Timeout
+                var warningTimeout_1 = setTimeout(function () {
+                    if (process.env.NODE_ENV !== 'production') {
+                        // tslint:disable-next-line max-line-length
+                        Logger.warn("A lock has exceeded ".concat(_this.lockWarningTime, " ms. Waiting additional ").concat(_this.lockErrorTime, " ms before rejecting the task."), next);
+                    }
+                    errorTimeout_1 = setTimeout(function () {
+                        next.reject('lock timeout exceeded');
+                    }, _this.lockErrorTime);
+                }, _this.lockWarningTime);
+                var taskPromise_1 = Promise.resolve(next.task()).then(function (result) {
+                    clearTimeout(warningTimeout_1);
+                    clearTimeout(errorTimeout_1);
+                    return result;
+                });
+                return Promise.resolve(taskPromise_1)
+                    .then(_this.next)
+                    .then(function () {
+                    return taskPromise_1.then(function (data) {
+                        next.done();
+                        next.resolve(data);
+                    });
+                })
+                    .catch(function (reason) {
+                    next.done();
+                    next.reject(reason);
+                    return _this.next();
+                });
+            }
+            return Promise.resolve();
+        });
+    };
+    return Queue;
+}());
+var locks = new WeakMap();
+/**
+ * Creates a lock for the specified owner that allows only one executing
+ * task simultaneously.
+ * @param key Lock owner.
+ */
+export default function lock(key, lockWarningTime, lockErrorTime) {
+    if (lockWarningTime === void 0) { lockWarningTime = 5000; }
+    if (lockErrorTime === void 0) { lockErrorTime = 1000; }
+    if (!locks.has(key)) {
+        locks.set(key, new Queue(lockWarningTime, lockErrorTime));
+    }
+    return function (task) {
+        return new Promise(function (resolve, reject) {
+            var queue = locks.get(key);
+            queue.add(task, resolve, reject, function () {
+                if (!queue.tasks.length) {
+                    locks.delete(key);
+                }
+            });
+        });
+    };
+}

package/lib-esm/merge-deep.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @param target Target to merge into
+ * @param sources Source to merge into target
+ * @returns Clone (new reference) with merged sources
+ */
+declare const mergeDeep: <Target, Source>(target: Target, ...sources: Source[]) => Target & Source;
+export default mergeDeep;

package/lib-esm/merge-deep.js

@@ -0,0 +1,67 @@
+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 deepClone from './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 = deepClone(target);
+    var clonedSources = deepClone(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));
+};
+export default mergeDeep;

package/lib-esm/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-esm/notify-data-loaded.js

@@ -0,0 +1,94 @@
+/**
+ * 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,
+            });
+        });
+    });
+};
+export default notifyDataLoaded;

package/lib-esm/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-esm/remove-null-and-undefined-values.js

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

package/lib-esm/set-cookie.d.ts

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

package/lib-esm/set-cookie.js

@@ -0,0 +1,9 @@
+export default 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=/");
+}

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

@@ -0,0 +1,23 @@
+export 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-esm/uuid.d.ts

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

package/lib-esm/uuid.js

@@ -0,0 +1,9 @@
+var s4 = function () {
+    return Math.floor((1 + Math.random()) * 0x10000)
+        .toString(16)
+        .substring(1);
+};
+export default function uuid() {
+    // tslint:disable-next-line prefer-template
+    return s4() + s4() + '-' + s4() + '-' + s4() + '-' + s4() + '-' + s4() + s4() + s4();
+}

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

@@ -0,0 +1,50 @@
+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;
+}());
+export default WaitFor;

package/package.json

@@ -0,0 +1,35 @@
+{
+    "name": "@telia-ace/widget-utilities",
+    "version": "1.0.0",
+    "description": "Internal utilities used by ACE Widget packages.",
+    "license": "SEE LICENSE IN LICENSE.txt",
+    "author": "Telia Company AB",
+    "keywords": [
+        "telia"
+    ],
+    "main": "lib/index.js",
+    "module": "lib-esm/index.js",
+    "files": [
+        "LICENSE.txt",
+        "README.md",
+        "lib/",
+        "lib-esm/"
+    ],
+    "publishConfig": {
+        "access": "public"
+    },
+    "scripts": {
+        "clean": "cleandir lib && cleandir lib-esm",
+        "compile": "tsc -p ./tsconfig.cjs.json && tsc -p ./tsconfig.esm.json"
+    },
+    "sideEffects": false,
+    "typings": "lib/index.d.ts",
+    "dependencies": {
+        "@webprovisions/platform": "^1.1.2"
+    },
+    "devDependencies": {
+        "@types/node": "^17.0.21",
+        "clean-dir": "^1.0.3",
+        "typescript": "^4.6.2"
+    }
+}