ts-client-lib 0.0.7

package/utils/TSCache.d.ts

@@ -0,0 +1,167 @@
+declare class BaseProvider {
+    /**  Accept keys as array e.g: {blogId:"2",action:"view"} and convert it to unique string */
+    generateKey(object: Record<string, unknown>): string;
+    /** Check if cache id already exist in saved context */
+    alreadyExist(storedContext: unknown[], cacheKey: unknown): boolean;
+    generateContextKey(key: string, value: unknown): string;
+    /**
+     * Get current time (compared to Epoch time) in seconds
+     */
+    getCurrentTime(): number;
+    /**
+     * Return default values
+     */
+    getDefault(): {
+        prefix: string;
+        ttl: number;
+    };
+    /**
+     * Return subscribers
+     *
+     * @returns {{cacheAdded: Array, cacheRemoved: Array}}
+     */
+    getEventSubscribers(): Record<string, ((payload: unknown) => void)[]>;
+    /**
+     * Dispatch event to subscribers
+     *
+     * @param event Event name
+     * @param object Object will be sent to subscriber
+     */
+    dispatchEvent(event: string, object: unknown): void;
+    /**
+     * Check if x is a function
+     *
+     * @param x
+     * @returns {boolean}
+     */
+    isFunction(x: unknown): boolean;
+}
+export declare class TSStorage {
+    extra: any;
+    support: string;
+    constructor(type?: string, extra?: any);
+    /** Where persisted values are stored for this instance. */
+    private storageKind;
+    toggle(key: string, value?: unknown): any;
+    storageAvailable(type: string): string;
+    private createCookie;
+    private readCookie;
+    private serialize;
+    private deserialize;
+    private byteCount;
+}
+declare class StorageProvider extends BaseProvider {
+    storage: TSStorage;
+    constructor(type?: string, extra?: unknown);
+    get(key: unknown): any;
+    set(key: unknown, value: unknown, ttl?: number, contexts?: Record<string, unknown>): void;
+    removeByKey(key: unknown): void;
+    removeByContext(context: Record<string, unknown>): void;
+    private clearCachesForIds;
+}
+declare class ArrayProvider extends BaseProvider {
+    cacheArray: Record<string, {
+        data: unknown;
+        ttl: number;
+        createdAt: number;
+    }>;
+    cacheContexts: Record<string, string[]>;
+    constructor();
+    get(key: unknown): any;
+    set(key: unknown, value: unknown, ttl?: number | null, contexts?: Record<string, unknown>): void;
+    removeByKey(key: unknown): void;
+    removeByContext(context: Record<string, unknown>): void;
+    private clearArrayCachesForContext;
+}
+declare class ProviderManager {
+    DEFAULT: string;
+    storageProvider?: StorageProvider;
+    arrayProvider: ArrayProvider;
+    constructor(type?: string, extra?: unknown);
+    use(provider: string): void;
+    getProvider(name?: string): StorageProvider | ArrayProvider;
+}
+/**
+ * Class TSCache - Core to work with cache
+ */
+export declare class TSCache {
+    /**
+     * Default values served as model
+     */
+    static model: {
+        DEFAULT: {
+            prefix: string;
+            ttl: number;
+        };
+        eventSubscribers: Record<string, Array<(payload: unknown) => void>>;
+    };
+    providerManager: ProviderManager;
+    constructor(type?: string, extra?: unknown);
+    /**
+     * Switch provider. available providers are: 'storage','array'
+     *
+     * @param provider
+     */
+    use(provider: string): any;
+    /**
+     * Get cache by array key
+     *
+     * @param key - Array key
+     * @returns {string}
+     * @example
+     * TSCache.get({blogId:"2",action:"view"});
+     */
+    get(key: any): any;
+    /**
+     * Save render for key
+     *
+     * @param key - Array key
+     * @param value - value must be a string
+     * @param ttl - Time to live in seconds
+     * @param contexts - Contexts
+     * @returns {TSCache}
+     */
+    set(key: any, value: any, ttl?: number, contexts?: any): any;
+    /**
+     * Set prefix for cache key (default: _cache)
+     *
+     * @param prefix
+     * @returns {TSCache}
+     */
+    setPrefix(prefix: string): any;
+    /**
+     * Get prefix for cache key
+     *
+     * @returns {string}
+     */
+    getPrefix(): string;
+    /**
+     * Remove by key from the cache
+     *
+     * @param key
+     * @returns {TSCache}
+     */
+    removeByKey(key: any): any;
+    /**
+     * Remove by context from the cache
+     *
+     * @param context
+     * @returns {TSCache}
+     */
+    removeByContext(context: any): any;
+    /**
+     * Subscribe to an event
+     *
+     * @param event
+     * @param callback
+     */
+    on(event: string, callback: (payload: unknown) => void): void;
+    /**
+     * Unsubscribe to an event
+     *
+     * @param event
+     * @param callback
+     */
+    unsubscribe(event: string, callback: (payload: unknown) => void): void;
+}
+export {};

package/utils/TSCache.js

@@ -0,0 +1,531 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TSCache = exports.TSStorage = void 0;
+var BaseProvider = /** @class */ (function () {
+    function BaseProvider() {
+    }
+    /**  Accept keys as array e.g: {blogId:"2",action:"view"} and convert it to unique string */
+    BaseProvider.prototype.generateKey = function (object) {
+        var generatedKey = this.getDefault().prefix + '_';
+        var keyArray = [];
+        for (var key in object) {
+            if (Object.hasOwn(object, key)) {
+                keyArray.push(key);
+            }
+        }
+        keyArray.sort();
+        for (var i = 0; i < keyArray.length; i++) {
+            generatedKey += keyArray[i] + '_' + object[keyArray[i]];
+            if (i !== (keyArray.length - 1)) {
+                generatedKey += '__';
+            }
+        }
+        return generatedKey;
+    };
+    /** Check if cache id already exist in saved context */
+    BaseProvider.prototype.alreadyExist = function (storedContext, cacheKey) {
+        return storedContext.indexOf(cacheKey) >= 0;
+    };
+    BaseProvider.prototype.generateContextKey = function (key, value) {
+        return this.getDefault().prefix + '_c_' + key + '_' + value; // _c_ stands for _context_
+    };
+    /**
+     * Get current time (compared to Epoch time) in seconds
+     */
+    BaseProvider.prototype.getCurrentTime = function () {
+        return Math.floor(new Date().getTime() / 1000);
+    };
+    /**
+     * Return default values
+     */
+    BaseProvider.prototype.getDefault = function () {
+        return TSCache.model.DEFAULT;
+    };
+    /**
+     * Return subscribers
+     *
+     * @returns {{cacheAdded: Array, cacheRemoved: Array}}
+     */
+    BaseProvider.prototype.getEventSubscribers = function () {
+        return TSCache.model.eventSubscribers;
+    };
+    /**
+     * Dispatch event to subscribers
+     *
+     * @param event Event name
+     * @param object Object will be sent to subscriber
+     */
+    BaseProvider.prototype.dispatchEvent = function (event, object) {
+        var subscribers = this.getEventSubscribers();
+        var callbacks = subscribers[event];
+        if (!callbacks || callbacks.length < 1) {
+            return;
+        }
+        for (var i = 0; i < callbacks.length; i++) {
+            if (typeof (callbacks[i]) !== 'undefined' && this.isFunction(callbacks[i])) {
+                callbacks[i](object);
+            }
+        }
+    };
+    /**
+     * Check if x is a function
+     *
+     * @param x
+     * @returns {boolean}
+     */
+    BaseProvider.prototype.isFunction = function (x) {
+        return Object.prototype.toString.call(x) === '[object Function]';
+    };
+    return BaseProvider;
+}());
+var TSStorage = /** @class */ (function () {
+    function TSStorage(type, extra) {
+        if (type === void 0) { type = 'localStorage'; }
+        if (extra === void 0) { extra = {}; }
+        this.extra = extra;
+        this.extra = Object.assign({
+            serialize: function (data) {
+                if (typeof data === 'object') {
+                    data = JSON.stringify(data);
+                }
+                return data;
+            },
+            deserialize: function (data) {
+                if (data == null) {
+                    return data;
+                }
+                try {
+                    return JSON.parse(data);
+                }
+                catch (_a) {
+                    return data;
+                }
+            }
+        }, this.extra);
+        this.support = this.storageAvailable(type);
+    }
+    /** Where persisted values are stored for this instance. */
+    TSStorage.prototype.storageKind = function () {
+        if (this.support.localeCompare('localStorage') === 0)
+            return 'local';
+        if (this.support.localeCompare('sessionStorage') === 0)
+            return 'session';
+        return 'cookie';
+    };
+    TSStorage.prototype.toggle = function (key, value) {
+        // If value is detected, set new or modify store
+        if (typeof value !== 'undefined' && value !== null) {
+            var data = this.serialize(value);
+            var k_1 = this.storageKind();
+            if (k_1 === 'local')
+                window.localStorage.setItem(key, data);
+            else if (k_1 === 'session')
+                window.sessionStorage.setItem(key, data);
+            else
+                this.createCookie(key, data, 30);
+            return value;
+        }
+        if (typeof value === 'undefined') {
+            var data = void 0;
+            var k_2 = this.storageKind();
+            if (k_2 === 'local')
+                data = window.localStorage.getItem(key);
+            else if (k_2 === 'session')
+                data = window.sessionStorage.getItem(key);
+            else
+                data = this.readCookie(key);
+            return this.deserialize(data);
+        }
+        // value === null: remove
+        var k = this.storageKind();
+        if (k === 'local')
+            setTimeout(function () { return window.localStorage.removeItem(key); }, 90);
+        else if (k === 'session')
+            setTimeout(function () { return window.sessionStorage.removeItem(key); }, 90);
+        else
+            this.createCookie(key, '', -1);
+    };
+    TSStorage.prototype.storageAvailable = function (type) {
+        // Use try catch to allow storage to work on private mode
+        if (type === 'cookie') {
+            return 'cookie';
+        }
+        try {
+            var storage = window[type], x = '__storage_test__';
+            storage.setItem(x, x);
+            storage.removeItem(x);
+            return type;
+        }
+        catch (_a) {
+            return 'cookie';
+        }
+    };
+    TSStorage.prototype.createCookie = function (key, value, exp) {
+        var date = new Date();
+        date.setTime(date.getTime() + (exp * 24 * 60 * 60 * 1000));
+        var c = "".concat(key, "=").concat(value, "; expires=").concat(date.toUTCString(), "; path=/; SameSite=None; Secure");
+        if (this.extra.domain) {
+            c += "; domain=.".concat(this.extra.domain);
+        }
+        if (this.byteCount(c) < 4096) {
+            window.document.cookie = c;
+        }
+    };
+    TSStorage.prototype.readCookie = function (key) {
+        var nameEQ = key + '=', ca = window.document.cookie.split(';');
+        for (var i = 0, max = ca.length; i < max; i++) {
+            var c = ca[i];
+            while (c.charAt(0) === ' ') {
+                c = c.substring(1, c.length);
+            }
+            if (c.indexOf(nameEQ) === 0) {
+                return c.substring(nameEQ.length, c.length);
+            }
+        }
+        return null;
+    };
+    TSStorage.prototype.serialize = function (data) {
+        return this.extra && this.extra.serialize ? this.extra.serialize(data) : data;
+    };
+    TSStorage.prototype.deserialize = function (data) {
+        return this.extra && this.extra.deserialize ? this.extra.deserialize(data) : data;
+    };
+    TSStorage.prototype.byteCount = function (s) {
+        return encodeURI(s).split(/%..|./).length - 1;
+    };
+    return TSStorage;
+}());
+exports.TSStorage = TSStorage;
+var StorageProvider = /** @class */ (function (_super) {
+    __extends(StorageProvider, _super);
+    function StorageProvider(type, extra) {
+        if (type === void 0) { type = 'localStorage'; }
+        var _this = _super.call(this) || this;
+        _this.storage = new TSStorage(type, extra);
+        return _this;
+    }
+    StorageProvider.prototype.get = function (key) {
+        var generatedKey = this.generateKey(key), object = this.storage.toggle(generatedKey);
+        if (object !== null) {
+            // Check if the cache is expired
+            if ((this.getCurrentTime() - object.createdAt) >= object.ttl) {
+                this.storage.toggle(generatedKey, null);
+                return null;
+            }
+            return object.data;
+        }
+        return null;
+    };
+    StorageProvider.prototype.set = function (key, value, ttl, contexts) {
+        ttl = ttl || this.getDefault().ttl;
+        var cacheKey = this.generateKey(key);
+        this.storage.toggle(cacheKey, { data: value, ttl: ttl, createdAt: this.getCurrentTime() });
+        var ctx = contexts !== null && contexts !== void 0 ? contexts : {};
+        for (var context in ctx) {
+            if (!Object.hasOwn(ctx, context)) {
+                continue;
+            }
+            var contextKey = this.generateContextKey(context, ctx[context]);
+            var storedContext = this.storage.toggle(contextKey);
+            if (storedContext !== null && !this.alreadyExist(storedContext, cacheKey)) {
+                storedContext.push(cacheKey);
+            }
+            else {
+                storedContext = [cacheKey];
+            }
+            this.storage.toggle(contextKey, storedContext);
+        }
+        this.dispatchEvent('cacheAdded', {
+            key: key, value: value, ttl: ttl, contexts: contexts || null
+        });
+    };
+    StorageProvider.prototype.removeByKey = function (key) {
+        var generatedKey = this.generateKey(key), cache = this.storage.toggle(generatedKey);
+        if (cache !== null) {
+            this.storage.toggle(generatedKey, null);
+            this.dispatchEvent('cacheRemoved', {
+                generatedKey: generatedKey, value: cache.data, ttl: cache.ttl
+            });
+        }
+    };
+    StorageProvider.prototype.removeByContext = function (context) {
+        for (var key in context) {
+            if (!Object.hasOwn(context, key))
+                continue;
+            var contextKey = this.generateContextKey(key, context[key]);
+            var storedContext = this.storage.toggle(contextKey);
+            if (storedContext === null)
+                return;
+            var cacheIds = JSON.parse(storedContext);
+            this.clearCachesForIds(contextKey, cacheIds);
+        }
+    };
+    StorageProvider.prototype.clearCachesForIds = function (contextKey, cacheIds) {
+        for (var i = 0; i < cacheIds.length; i++) {
+            var raw = localStorage.getItem(cacheIds[i]);
+            var cache = raw != null ? JSON.parse(raw) : null;
+            if (!cache) {
+                continue;
+            }
+            this.storage.toggle(cacheIds[i], null);
+            this.dispatchEvent('cacheRemoved', {
+                generatedKey: cacheIds[i], value: cache.data, ttl: cache.ttl
+            });
+        }
+        this.storage.toggle(contextKey, null);
+    };
+    return StorageProvider;
+}(BaseProvider));
+var ArrayProvider = /** @class */ (function (_super) {
+    __extends(ArrayProvider, _super);
+    function ArrayProvider() {
+        var _this = _super.call(this) || this;
+        _this.cacheArray = {};
+        _this.cacheContexts = {};
+        return _this;
+    }
+    ArrayProvider.prototype.get = function (key) {
+        var generatedKey = this.generateKey(key);
+        if (Object.hasOwn(this.cacheArray, generatedKey)) {
+            var object = this.cacheArray[generatedKey];
+            // Check if the cache is expired
+            if ((this.getCurrentTime() - object.createdAt) >= object.ttl) {
+                delete this.cacheArray[generatedKey];
+                return null;
+            }
+            return object.data;
+        }
+        else {
+            return null;
+        }
+    };
+    ArrayProvider.prototype.set = function (key, value, ttl, contexts) {
+        var generatedKey = this.generateKey(key);
+        ttl = ttl === null || typeof (ttl) === 'undefined' ? this.getDefault().ttl : ttl;
+        this.cacheArray[generatedKey] = {
+            data: value, ttl: ttl, createdAt: this.getCurrentTime()
+        };
+        var ctx = contexts !== null && contexts !== void 0 ? contexts : {};
+        for (var context in ctx) {
+            if (!Object.hasOwn(ctx, context)) {
+                continue;
+            }
+            var contextKey = this.generateContextKey(context, ctx[context]);
+            var storedContext = Object.hasOwn(this.cacheContexts, contextKey) ? this.cacheContexts[contextKey] : null;
+            if (storedContext !== null && !this.alreadyExist(storedContext, generatedKey)) {
+                storedContext.push(generatedKey);
+            }
+            else {
+                storedContext = [generatedKey];
+            }
+            this.cacheContexts[contextKey] = storedContext;
+        }
+        this.dispatchEvent('cacheAdded', {
+            key: key, value: value, ttl: ttl, contexts: contexts || null
+        });
+    };
+    ArrayProvider.prototype.removeByKey = function (key) {
+        var generatedKey = this.generateKey(key);
+        if (Object.hasOwn(this.cacheArray, generatedKey)) {
+            var cache = this.cacheArray[generatedKey];
+            delete this.cacheArray[generatedKey];
+            this.dispatchEvent('cacheRemoved', {
+                generatedKey: generatedKey, value: cache.data, ttl: cache.ttl
+            });
+        }
+    };
+    ArrayProvider.prototype.removeByContext = function (context) {
+        for (var key in context) {
+            if (!Object.hasOwn(context, key))
+                continue;
+            var contextKey = this.generateContextKey(key, context[key]);
+            var storedContext = Object.hasOwn(this.cacheContexts, contextKey) ? this.cacheContexts[contextKey] : null;
+            if (storedContext === null)
+                return;
+            this.clearArrayCachesForContext(contextKey, storedContext);
+        }
+    };
+    ArrayProvider.prototype.clearArrayCachesForContext = function (contextKey, storedContext) {
+        for (var i = 0; i < storedContext.length; i++) {
+            var cache = this.cacheArray[storedContext[i]];
+            if (!cache) {
+                continue;
+            }
+            delete this.cacheArray[storedContext[i]];
+            this.dispatchEvent('cacheRemoved', {
+                generatedKey: storedContext[i], value: cache.data, ttl: cache.ttl
+            });
+        }
+        delete this.cacheContexts[contextKey];
+    };
+    return ArrayProvider;
+}(BaseProvider));
+var ProviderManager = /** @class */ (function () {
+    function ProviderManager(type, extra) {
+        if (type === void 0) { type = 'localStorage'; }
+        this.DEFAULT = 'storage';
+        if (typeof window !== 'undefined') {
+            this.storageProvider = new StorageProvider(type, extra);
+        }
+        this.arrayProvider = new ArrayProvider();
+    }
+    ProviderManager.prototype.use = function (provider) {
+        this.DEFAULT = provider;
+    };
+    ProviderManager.prototype.getProvider = function (name) {
+        var _a;
+        var n = name || this.DEFAULT;
+        if (typeof window === 'undefined') {
+            n = 'array';
+        }
+        switch (n) {
+            case 'storage':
+                return (_a = this.storageProvider) !== null && _a !== void 0 ? _a : this.arrayProvider;
+            case 'array':
+                return this.arrayProvider;
+            default:
+                return this.arrayProvider;
+        }
+    };
+    return ProviderManager;
+}());
+/**
+ * Class TSCache - Core to work with cache
+ */
+var TSCache = /** @class */ (function () {
+    function TSCache(type, extra) {
+        if (type === void 0) { type = 'localStorage'; }
+        this.providerManager = new ProviderManager(type, extra);
+    }
+    /**
+     * Switch provider. available providers are: 'storage','array'
+     *
+     * @param provider
+     */
+    TSCache.prototype.use = function (provider) {
+        this.providerManager.use(provider);
+        return this;
+    };
+    /**
+     * Get cache by array key
+     *
+     * @param key - Array key
+     * @returns {string}
+     * @example
+     * TSCache.get({blogId:"2",action:"view"});
+     */
+    TSCache.prototype.get = function (key) {
+        return this.providerManager.getProvider().get(key);
+    };
+    /**
+     * Save render for key
+     *
+     * @param key - Array key
+     * @param value - value must be a string
+     * @param ttl - Time to live in seconds
+     * @param contexts - Contexts
+     * @returns {TSCache}
+     */
+    TSCache.prototype.set = function (key, value, ttl, contexts) {
+        try {
+            this.providerManager.getProvider().set(key, value, ttl, contexts);
+        }
+        catch (_a) {
+            return null;
+        }
+        return this;
+    };
+    /**
+     * Set prefix for cache key (default: _cache)
+     *
+     * @param prefix
+     * @returns {TSCache}
+     */
+    TSCache.prototype.setPrefix = function (prefix) {
+        TSCache.model.DEFAULT.prefix = prefix;
+        return this;
+    };
+    /**
+     * Get prefix for cache key
+     *
+     * @returns {string}
+     */
+    TSCache.prototype.getPrefix = function () {
+        return TSCache.model.DEFAULT.prefix;
+    };
+    /**
+     * Remove by key from the cache
+     *
+     * @param key
+     * @returns {TSCache}
+     */
+    TSCache.prototype.removeByKey = function (key) {
+        this.providerManager.getProvider().removeByKey(key);
+        return this;
+    };
+    /**
+     * Remove by context from the cache
+     *
+     * @param context
+     * @returns {TSCache}
+     */
+    TSCache.prototype.removeByContext = function (context) {
+        this.providerManager.getProvider().removeByContext(context);
+        return this;
+    };
+    /**
+     * Subscribe to an event
+     *
+     * @param event
+     * @param callback
+     */
+    TSCache.prototype.on = function (event, callback) {
+        var subs = TSCache.model.eventSubscribers;
+        if (!subs[event]) {
+            subs[event] = [];
+        }
+        subs[event].push(callback);
+    };
+    /**
+     * Unsubscribe to an event
+     *
+     * @param event
+     * @param callback
+     */
+    TSCache.prototype.unsubscribe = function (event, callback) {
+        var callbacks = TSCache.model.eventSubscribers[event];
+        if (!callbacks) {
+            return;
+        }
+        for (var i = 0; i < callbacks.length; i++) {
+            if (callbacks[i] === callback) {
+                delete callbacks[i];
+                break;
+            }
+        }
+    };
+    /**
+     * Default values served as model
+     */
+    TSCache.model = {
+        DEFAULT: { prefix: '_c', ttl: 604800 },
+        eventSubscribers: { cacheAdded: [], cacheRemoved: [] }
+    };
+    return TSCache;
+}());
+exports.TSCache = TSCache;

package/utils/TSDate.d.ts

@@ -0,0 +1,8 @@
+export declare class TSDate {
+    static utc(type: string, data: number, set?: Array<number>): Date;
+    static key(max?: number, date?: Date): string;
+    static parse(date: string, data?: number, set?: number[]): string;
+    static yyyymmddhhss(date: string | Date | number): Date;
+    static format(timestamp: number | undefined, format: string, cb?: (data: any) => any): string;
+    static timer(milliseconds: number, format: string, cb?: (data: any) => any): string;
+}