@telia-ace/widget-services 1.0.0

package/lib-esm/storage/utils.d.ts

@@ -0,0 +1,36 @@
+import { Container } from '@webprovisions/platform';
+import { Duration, StorageCategory, StorageMedium, Store, StoredValue } from './types';
+export declare const createEmptyStore: () => Store;
+export declare const isExpired: (isoDateString: string) => boolean;
+export declare const getValue: <Type>(store: Store, key: string) => Type | undefined;
+export declare const createValue: (value: any, category: StorageCategory, duration: Duration | string) => StoredValue;
+export declare const processStore: (store: Store, policy?: StorageCategory[] | undefined) => Store;
+/**
+ * @param category Storage Category.
+ * @param policy Current Storage Policy.
+ * @returns true if not allowed, false if allowed.
+ */
+export declare const isNotAllowedAsync: (container: Container, category?: StorageCategory | undefined) => Promise<boolean>;
+/**
+ * @param category Storage Category.
+ * @param policy Current Storage Policy.
+ * @returns true if not allowed, false if allowed.
+ */
+export declare const isNotAllowed: (policy?: StorageCategory[], category?: StorageCategory | undefined) => boolean;
+/**
+ * Processes storage and removes items if they are expired or if
+ * the storage policy is defined and the category of the stored
+ * value is not allowed.
+ * @param container Widget Container
+ */
+export declare const processStorage: (container: Container) => void;
+/**
+ * Creates an expiration date string with the passed options.
+ * @param options Duration options.
+ * @returns ISO formatted date string.
+ */
+export declare const createExpirationDate: (options?: Duration) => string;
+export declare const getCookieStoreAsync: (container: Container) => Promise<Store>;
+export declare const setCookieStoreAsync: (container: Container, store: Store) => Promise<any>;
+export declare const getApplicationStoreAsync: (container: Container, type: StorageMedium.Local | StorageMedium.Session) => Promise<Store>;
+export declare const setApplicationStoreAsync: (container: Container, type: StorageMedium.Local | StorageMedium.Session, store: Store) => Promise<void>;

package/lib-esm/storage/utils.js

@@ -0,0 +1,224 @@
+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;
+};
+import { deepClone, hash, lock, mergeDeep } from '@telia-ace/widget-utilities';
+import { readStorage } from './storage';
+import { StorageCategory, StorageMedium, } from './types';
+var hasEntries = function (object) {
+    return !!Object.entries(object).filter(function (_a) {
+        var _b = __read(_a, 2), _ = _b[0], value = _b[1];
+        return typeof value !== 'undefined';
+    }).length;
+};
+var cleanUndefined = function (object) {
+    return Object.entries(object)
+        .filter(function (_a) {
+        var _b = __read(_a, 2), _ = _b[0], value = _b[1];
+        return typeof value !== 'undefined';
+    })
+        .forEach(function (_a) {
+        var _b = __read(_a, 2), key = _b[0], value = _b[1].value;
+        if (typeof value === 'undefined') {
+            delete object[key];
+        }
+    });
+};
+var mergeAndClean = function (target, source) {
+    var merged = mergeDeep(target, source);
+    cleanUndefined(merged.tenant);
+    cleanUndefined(merged.implementation);
+    cleanUndefined(merged.widget);
+    return merged;
+};
+var getLongestExpirationDate = function (store) {
+    var expirationDates = Object.entries(store).reduce(function (acc, storeEntry) {
+        var _a = __read(storeEntry, 2), _ = _a[0], container = _a[1];
+        Object.entries(container).forEach(function (containerEntry) {
+            var _a = __read(containerEntry, 2), _ = _a[0], expiration = _a[1].expiration;
+            acc.push(expiration);
+        });
+        return acc;
+    }, []);
+    return (expirationDates
+        .slice()
+        .sort(function (a, b) { return new Date(b).valueOf() - new Date(a).valueOf(); })
+        .shift() || createExpirationDate());
+};
+var createStorageKeys = function (container) {
+    var _a = container.get('$widget'), widgetName = _a.name, _b = _a.implementation, implementationName = _b.name, tenantName = _b.tenant;
+    return [
+        "humany_".concat(tenantName),
+        "humany_".concat(hash(tenantName + implementationName)),
+        "humany_".concat(hash(tenantName + implementationName + widgetName)),
+    ];
+};
+var getCookie = function (cookieName) {
+    var regExp = new RegExp("(?:^|;)\\s?".concat(cookieName, "=(.*?)(?:;|$)"), 'i');
+    var cookie = document.cookie.match(regExp);
+    var value = cookie && cookie[1] && JSON.parse(cookie[1]);
+    return value || undefined;
+};
+var setCookie = function (cookieName, value, expires) {
+    var cookie = "".concat(cookieName, "=").concat(JSON.stringify(value).trim(), ";");
+    var expiration = "expires=".concat(new Date(expires).toUTCString(), ";");
+    var path = 'path=/';
+    return (document.cookie = "".concat(cookie, " ").concat(expiration, " ").concat(path));
+};
+var getCookieStore = function (container) {
+    var _a = __read(createStorageKeys(container), 3), tenantKey = _a[0], implementationKey = _a[1], widgetKey = _a[2];
+    var tenant = getCookie(tenantKey) || {};
+    var implementation = getCookie(implementationKey) || {};
+    var widget = getCookie(widgetKey) || {};
+    return {
+        tenant: tenant,
+        implementation: implementation,
+        widget: widget,
+    };
+};
+var setCookieStore = function (container, store) {
+    var current = getCookieStore(container);
+    var merged = mergeAndClean(current, store);
+    var _a = __read(createStorageKeys(container), 3), tenantKey = _a[0], implementationKey = _a[1], widgetKey = _a[2];
+    var tenant = merged.tenant, implementation = merged.implementation, widget = merged.widget;
+    var expirationDate = getLongestExpirationDate(store);
+    var deleteDate = createExpirationDate({ days: -1 });
+    setCookie(tenantKey, tenant, hasEntries(tenant) ? expirationDate : deleteDate);
+    setCookie(implementationKey, implementation, hasEntries(implementation) ? expirationDate : deleteDate);
+    setCookie(widgetKey, widget, hasEntries(widget) ? expirationDate : deleteDate);
+};
+var getApplicationStore = function (container, storage) {
+    var _a = __read(createStorageKeys(container), 3), tenantKey = _a[0], implementationKey = _a[1], widgetKey = _a[2];
+    var tenant = storage.getItem(tenantKey) || '{}';
+    var implementation = storage.getItem(implementationKey) || '{}';
+    var widget = storage.getItem(widgetKey) || '{}';
+    return {
+        tenant: JSON.parse(tenant),
+        implementation: JSON.parse(implementation),
+        widget: JSON.parse(widget),
+    };
+};
+var setApplicationStore = function (container, applicationStorage, store) {
+    var current = getApplicationStore(container, applicationStorage);
+    var merged = mergeAndClean(current, store);
+    var _a = __read(createStorageKeys(container), 3), tenantKey = _a[0], implementationKey = _a[1], widgetKey = _a[2];
+    var tenant = merged.tenant, implementation = merged.implementation, widget = merged.widget;
+    hasEntries(tenant)
+        ? applicationStorage.setItem(tenantKey, JSON.stringify(tenant))
+        : applicationStorage.removeItem(tenantKey);
+    hasEntries(implementation)
+        ? applicationStorage.setItem(implementationKey, JSON.stringify(implementation))
+        : applicationStorage.removeItem(implementationKey);
+    hasEntries(widget)
+        ? applicationStorage.setItem(widgetKey, JSON.stringify(widget))
+        : applicationStorage.removeItem(widgetKey);
+};
+export var createEmptyStore = function () { return ({ tenant: {}, implementation: {}, widget: {} }); };
+export var isExpired = function (isoDateString) {
+    return !!isoDateString && new Date() > new Date(isoDateString);
+};
+export var getValue = function (store, key) {
+    var storedValue = store.widget[key] || store.implementation[key] || store.tenant[key];
+    return storedValue === null || storedValue === void 0 ? void 0 : storedValue.value;
+};
+export var createValue = function (value, category, duration) {
+    return {
+        value: value,
+        category: category,
+        expiration: typeof duration === 'object' ? createExpirationDate(duration) : duration,
+    };
+};
+export var processStore = function (store, policy) {
+    var clone = deepClone(store);
+    Object.entries(clone).forEach(function (_a) {
+        var _b = __read(_a, 2), _ = _b[0], storageContainer = _b[1];
+        Object.entries(storageContainer).forEach(function (_a) {
+            var _b = __read(_a, 2), key = _b[0], storedValue = _b[1];
+            var expiration = storedValue.expiration, category = storedValue.category;
+            if (isExpired(expiration) || isNotAllowed(policy, category))
+                storageContainer[key] = createValue(undefined, category, expiration);
+        });
+    });
+    return clone;
+};
+/**
+ * @param category Storage Category.
+ * @param policy Current Storage Policy.
+ * @returns true if not allowed, false if allowed.
+ */
+export var isNotAllowedAsync = function (container, category) {
+    return readStorage(container, 'storagePolicy', StorageMedium.Cookie).then(function (policy) {
+        if (policy === void 0) { policy = [StorageCategory.Necessary]; }
+        return !!category && policy.indexOf(category) === -1;
+    });
+};
+/**
+ * @param category Storage Category.
+ * @param policy Current Storage Policy.
+ * @returns true if not allowed, false if allowed.
+ */
+export var isNotAllowed = function (policy, category) {
+    if (policy === void 0) { policy = [StorageCategory.Necessary]; }
+    return !!category && policy.indexOf(category) === -1;
+};
+/**
+ * Processes storage and removes items if they are expired or if
+ * the storage policy is defined and the category of the stored
+ * value is not allowed.
+ * @param container Widget Container
+ */
+export var processStorage = function (container) {
+    var cookieStore = getCookieStore(container);
+    var localStore = getApplicationStore(container, window.localStorage);
+    var sessionStore = getApplicationStore(container, sessionStorage);
+    var policy = getValue(cookieStore, 'storagePolicy');
+    var _a = __read([
+        cookieStore,
+        localStore,
+        sessionStore,
+    ].map(function (store) { return processStore(store, policy); }), 3), processedCookieStore = _a[0], processedLocalStore = _a[1], processedSessionStore = _a[2];
+    setCookieStore(container, processedCookieStore);
+    setApplicationStore(container, window.localStorage, processedLocalStore);
+    setApplicationStore(container, window.sessionStorage, processedSessionStore);
+};
+/**
+ * Creates an expiration date string with the passed options.
+ * @param options Duration options.
+ * @returns ISO formatted date string.
+ */
+export var createExpirationDate = function (options) {
+    if (options === void 0) { options = { days: 30 }; }
+    var _a = options.days, days = _a === void 0 ? 0 : _a, _b = options.hours, hours = _b === void 0 ? 0 : _b, _c = options.minutes, minutes = _c === void 0 ? 0 : _c, _d = options.seconds, seconds = _d === void 0 ? 0 : _d;
+    var date = new Date();
+    date.setTime(date.getTime() + hours * 60 * 60 * 1000);
+    date.setTime(date.getTime() + days * 24 * 60 * 60 * 1000);
+    date.setTime(date.getTime() + minutes * 60 * 1000);
+    date.setTime(date.getTime() + seconds * 1000);
+    return date.toISOString();
+};
+export var getCookieStoreAsync = function (container) {
+    return lock(document)(function () { return getCookieStore(container); });
+};
+export var setCookieStoreAsync = function (container, store) {
+    return lock(document)(function () { return setCookieStore(container, store); });
+};
+export var getApplicationStoreAsync = function (container, type) {
+    var storage = type === StorageMedium.Local ? window.localStorage : window.sessionStorage;
+    return lock(storage)(function () { return getApplicationStore(container, storage); });
+};
+export var setApplicationStoreAsync = function (container, type, store) {
+    var storage = type === StorageMedium.Local ? window.localStorage : window.sessionStorage;
+    return lock(storage)(function () { return setApplicationStore(container, storage, store); });
+};

package/package.json

@@ -0,0 +1,34 @@
+{
+    "name": "@telia-ace/widget-services",
+    "version": "1.0.0",
+    "description": "Services for ACE Widgets.",
+    "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": {
+        "@telia-ace/widget-utilities": "^1.0.1"
+    },
+    "devDependencies": {
+        "@webprovisions/platform": "^1.1.2"
+    },
+    "gitHead": "a45fde2bae0981a2a791a2362f2ecaf53430570b"
+}