@sydsoft/base 1.57.0 → 1.59.0

package/dist/esm/_lib/baseFunctions.d.ts

@@ -0,0 +1,11 @@
+export declare const isDev: boolean;
+export declare const isServerReq: (context: any) => boolean;
+export declare const sleep: (ms?: number) => Promise<unknown>;
+export declare const padNumber: (num: number, padLength?: number, padString?: string) => string;
+export declare function inputTumuBuyukCevir(e: React.ChangeEvent<HTMLInputElement>): void;
+export declare function inputTumuKucukCevir(e: React.ChangeEvent<HTMLInputElement>): void;
+export declare const convertLowerCase: (text?: any) => any;
+export declare const convertForSearch: (value: string) => string;
+export declare function convertForSEO(e: React.ChangeEvent<HTMLInputElement>): void;
+export declare function getDomain(context?: any): string;
+export declare const uniqueID: (key?: string, length?: number) => string;

package/dist/esm/_lib/baseFunctions.js

@@ -0,0 +1,97 @@
+export var isDev = !process.env.NODE_ENV || process.env.NODE_ENV === 'development';
+export var isServerReq = function (context) { var _a, _b; return !((_b = (_a = context === null || context === void 0 ? void 0 : context.req) === null || _a === void 0 ? void 0 : _a.url) === null || _b === void 0 ? void 0 : _b.startsWith('/_next')); };
+export var sleep = function (ms) {
+    if (ms === void 0) { ms = 1000; }
+    return new Promise(function (resolve) { return setTimeout(resolve, ms); });
+};
+export var padNumber = function (num, padLength, padString) {
+    if (padLength === void 0) { padLength = 2; }
+    if (padString === void 0) { padString = '0'; }
+    return String(num).padStart(padLength, padString);
+};
+export function inputTumuBuyukCevir(e) {
+    var _a;
+    if ((e === null || e === void 0 ? void 0 : e.target) && ((_a = e === null || e === void 0 ? void 0 : e.target) === null || _a === void 0 ? void 0 : _a.setSelectionRange)) {
+        var start = e.target.selectionStart;
+        var end = e.target.selectionEnd;
+        e.target.value = e.target.value.toString().toLocaleUpperCase('tr-TR');
+        e.target.setSelectionRange(start, end);
+    }
+}
+export function inputTumuKucukCevir(e) {
+    var _a;
+    if ((e === null || e === void 0 ? void 0 : e.target) && ((_a = e === null || e === void 0 ? void 0 : e.target) === null || _a === void 0 ? void 0 : _a.setSelectionRange)) {
+        var start = e.target.selectionStart;
+        var end = e.target.selectionEnd;
+        e.target.value = e.target.value.toString().toLocaleLowerCase('tr-TR');
+        e.target.setSelectionRange(start, end);
+    }
+}
+export var convertLowerCase = function (text) {
+    if (text === void 0) { text = ''; }
+    return text.toString().toLocaleLowerCase('tr-TR');
+};
+export var convertForSearch = function (value) {
+    var data = value === null || value === void 0 ? void 0 : value.toString().toLocaleLowerCase('tr-TR');
+    data = data.replace(/ö/g, 'o');
+    data = data.replace(/ç/g, 'c');
+    data = data.replace(/ş/g, 's');
+    data = data.replace(/ı/g, 'i');
+    data = data.replace(/ğ/g, 'g');
+    data = data.replace(/ü/g, 'u');
+    data = data.replace(/[^a-z\d]/g, ''); // %_- are allowed
+    data = data.replace(/^\s+|\s+$/g, '');
+    return data;
+};
+export function convertForSEO(e) {
+    var _a;
+    if ((e === null || e === void 0 ? void 0 : e.target) && ((_a = e === null || e === void 0 ? void 0 : e.target) === null || _a === void 0 ? void 0 : _a.setSelectionRange)) {
+        var start = e.target.selectionStart;
+        var end = e.target.selectionEnd;
+        var string = e.target.value.toString().toLocaleLowerCase('tr');
+        var turkce = [' ', '-', 'ş', 'Ş', 'ı', 'ü', 'Ü', 'ö', 'Ö', 'ç', 'Ç', 'ş', 'Ş', 'ı', 'ğ', 'Ğ', 'İ', 'ö', 'Ö', 'Ç', 'ç', 'ü', 'Ü', 'â', 'ê', 'Â', '“', '”'];
+        var duzgun = ['-', '-', 's', 'S', 'i', 'u', 'U', 'o', 'O', 'c', 'C', 's', 'S', 'i', 'g', 'G', 'I', 'o', 'O', 'C', 'c', 'u', 'U', 'a', 'ê', 'a', '', ''];
+        for (var i = 0; i < turkce.length; i++) {
+            string = string.split(turkce[i]).join(duzgun[i]);
+        }
+        string = string.replace(/[^a-z0-9\-_şıüğçİŞĞÜÇ]+/gi, '_');
+        string = string.replace(/_+/g, '_');
+        string = string.replace(/^-/, '_');
+        string = string.replace(/-$/, '_');
+        e.target.value = string;
+        e.target.setSelectionRange(start, end);
+    }
+}
+export function getDomain(context) {
+    if (context === void 0) { context = null; }
+    var url = '';
+    if (context) {
+        url = context.req.headers.host;
+    }
+    else if (typeof window !== 'undefined') {
+        url = window.location.hostname;
+    }
+    if (url.length) {
+        var parts = url.split('.').reverse();
+        var cnt = parts.length;
+        if (cnt >= 3) {
+            // see if the second level domain is a common SLD.
+            if (parts[1].match(/^(com|edu|gov|net|mil|org|nom|co|name|info|biz)$/i)) {
+                var domain_1 = parts[2] + '.' + parts[1] + '.' + parts[0];
+                return domain_1.split(':')[0];
+            }
+        }
+        var domain = parts[1] + '.' + parts[0];
+        return domain.split(':')[0];
+    }
+    return url;
+}
+export var uniqueID = function (key, length) {
+    if (key === void 0) { key = ''; }
+    if (length === void 0) { length = 16; }
+    return (key +
+        parseInt(Math.ceil(Math.random() * Date.now())
+            .toPrecision(length)
+            .toString()
+            .replace('.', '')));
+};

package/dist/esm/_lib/inputMask.d.ts

@@ -0,0 +1,7 @@
+export declare const applyInputMask: (inputElement: any, mask: string, options?: any) => {
+    destroy: () => void;
+    setValue: (value: any) => void;
+    getValue: () => any;
+    getCleanValue: () => string;
+    applyMask: (inputValue: any) => string;
+} | null;

package/dist/esm/_lib/inputMask.js

@@ -0,0 +1,229 @@
+import { isDev } from "./baseFunctions";
+// Mask işleme core fonksiyonları
+var createMaskCore = function () {
+    var defaultTranslation = {
+        "0": { pattern: /\d/ },
+        "9": { pattern: /\d/, optional: true },
+        "#": { pattern: /\d/, recursive: true },
+        A: { pattern: /[a-zA-Z0-9]/ },
+        S: { pattern: /[a-zA-Z]/ },
+        U: { pattern: /[a-zA-Z]/, transform: function (char) { return char.toUpperCase(); } },
+        L: { pattern: /[a-zA-Z]/, transform: function (char) { return char.toLowerCase(); } },
+        X: { pattern: /[0-9a-fA-F]/ }
+    };
+    var parseMask = function (maskString, translation) {
+        if (translation === void 0) { translation = defaultTranslation; }
+        var tokens = [];
+        var i = 0;
+        while (i < maskString.length) {
+            var char = maskString[i];
+            if (translation[char]) {
+                tokens.push({
+                    type: "input",
+                    pattern: translation[char].pattern,
+                    optional: translation[char].optional,
+                    recursive: translation[char].recursive,
+                    transform: translation[char].transform
+                });
+            }
+            else {
+                tokens.push({
+                    type: "literal",
+                    char: char
+                });
+            }
+            i++;
+        }
+        return tokens;
+    };
+    var applyMask = function (inputValue, maskTokens, reverse) {
+        if (reverse === void 0) { reverse = false; }
+        if (!maskTokens.length)
+            return inputValue;
+        var normalizedValue = inputValue == null ? "" : String(inputValue);
+        var cleanValue = normalizedValue.replace(/[^\w\s]/g, "");
+        if (reverse) {
+            return applyReverseMask(cleanValue, maskTokens);
+        }
+        var result = "";
+        var valueIndex = 0;
+        var maskIndex = 0;
+        while (maskIndex < maskTokens.length && valueIndex < cleanValue.length) {
+            var token = maskTokens[maskIndex];
+            if (token.type === "literal") {
+                result += token.char;
+                maskIndex++;
+            }
+            else {
+                var char = cleanValue[valueIndex];
+                if (token.pattern.test(char)) {
+                    var transformedChar = token.transform ? token.transform(char) : char;
+                    result += transformedChar;
+                    valueIndex++;
+                    maskIndex++;
+                }
+                else if (token.optional) {
+                    maskIndex++;
+                }
+                else {
+                    valueIndex++;
+                }
+            }
+        }
+        while (maskIndex < maskTokens.length) {
+            var token = maskTokens[maskIndex];
+            if (token.type === "literal") {
+                result += token.char;
+            }
+            else if (!token.optional) {
+                break;
+            }
+            maskIndex++;
+        }
+        return result;
+    };
+    var applyReverseMask = function (inputValue, maskTokens) {
+        var reversedMask = maskTokens.slice().reverse();
+        var reversedValue = inputValue.split("").reverse().join("");
+        var result = "";
+        var valueIndex = 0;
+        var maskIndex = 0;
+        while (maskIndex < reversedMask.length && valueIndex < reversedValue.length) {
+            var token = reversedMask[maskIndex];
+            if (token.type === "literal") {
+                result = token.char + result;
+                maskIndex++;
+            }
+            else {
+                var char = reversedValue[valueIndex];
+                if (token.pattern.test(char)) {
+                    var transformedChar = token.transform ? token.transform(char) : char;
+                    result = transformedChar + result;
+                    valueIndex++;
+                    maskIndex++;
+                }
+                else if (token.optional) {
+                    maskIndex++;
+                }
+                else {
+                    valueIndex++;
+                }
+            }
+        }
+        return result;
+    };
+    var getCleanValue = function (maskedValue, maskTokens) {
+        if (!maskTokens.length)
+            return maskedValue;
+        var clean = "";
+        var valueIndex = 0;
+        var maskIndex = 0;
+        while (maskIndex < maskTokens.length && valueIndex < maskedValue.length) {
+            var token = maskTokens[maskIndex];
+            if (token.type === "literal") {
+                if (maskedValue[valueIndex] === token.char) {
+                    valueIndex++;
+                }
+                maskIndex++;
+            }
+            else {
+                clean += maskedValue[valueIndex];
+                valueIndex++;
+                maskIndex++;
+            }
+        }
+        return clean;
+    };
+    return {
+        parseMask: parseMask,
+        applyMask: applyMask,
+        getCleanValue: getCleanValue
+    };
+};
+// Fonksiyonel yaklaşım - herhangi bir input elementine mask uygula
+export var applyInputMask = function (inputElement, mask, options) {
+    if (options === void 0) { options = {}; }
+    if (!inputElement || !mask)
+        return null;
+    isDev && console.log("Input mask applied:", { inputElement: inputElement, mask: mask, options: options });
+    var translation = options.translation, _a = options.reverse, reverse = _a === void 0 ? false : _a, _b = options.clearIfNotMatch, clearIfNotMatch = _b === void 0 ? true : _b, _c = options.selectOnFocus, selectOnFocus = _c === void 0 ? false : _c, onChange = options.onChange;
+    var maskCore = createMaskCore();
+    var maskTokens = maskCore.parseMask(mask, translation);
+    var applyMaskToValue = function (inputValue) { return maskCore.applyMask(inputValue, maskTokens, reverse); };
+    var getCleanValue = function (maskedValue) { return maskCore.getCleanValue(maskedValue, maskTokens); };
+    var handleInputChange = function (e) {
+        var inputValue = e.target.value;
+        var maskedValue = applyMaskToValue(inputValue);
+        var cleanValue = getCleanValue(maskedValue);
+        e.target.value = maskedValue;
+        onChange === null || onChange === void 0 ? void 0 : onChange(maskedValue, cleanValue, e);
+    };
+    var handleKeyDown = function (e) {
+        var key = e.key, target = e.target;
+        var cursorStart = target.selectionStart;
+        var cursorEnd = target.selectionEnd;
+        if (key === "Backspace" || key === "Delete") {
+            e.preventDefault();
+            var newValue = target.value;
+            if (cursorStart !== cursorEnd) {
+                newValue = newValue.substring(0, cursorStart) + newValue.substring(cursorEnd);
+            }
+            else if (key === "Backspace" && cursorStart > 0) {
+                newValue = newValue.substring(0, cursorStart - 1) + newValue.substring(cursorStart);
+            }
+            else if (key === "Delete" && cursorStart < newValue.length) {
+                newValue = newValue.substring(0, cursorStart) + newValue.substring(cursorStart + 1);
+            }
+            var maskedValue = applyMaskToValue(newValue);
+            target.value = maskedValue;
+            var cleanValue = getCleanValue(maskedValue);
+            onChange === null || onChange === void 0 ? void 0 : onChange(maskedValue, cleanValue, e);
+            setTimeout(function () {
+                var newPos = key === "Backspace" ? Math.max(0, cursorStart - 1) : cursorStart;
+                target.setSelectionRange(newPos, newPos);
+            }, 0);
+        }
+    };
+    var handleFocus = function (e) {
+        if (selectOnFocus) {
+            setTimeout(function () {
+                e.target.select();
+            }, 0);
+        }
+    };
+    var handleBlur = function (e) {
+        if (clearIfNotMatch) {
+            var cleanValue = getCleanValue(e.target.value);
+            var expectedLength = maskTokens.filter(function (t) { return t.type === "input" && !t.optional; }).length;
+            if (cleanValue.length < expectedLength) {
+                e.target.value = "";
+                onChange === null || onChange === void 0 ? void 0 : onChange("", "", e);
+            }
+        }
+    };
+    // Event listener'ları ekle
+    inputElement.addEventListener("input", handleInputChange);
+    inputElement.addEventListener("keydown", handleKeyDown);
+    inputElement.addEventListener("focus", handleFocus);
+    inputElement.addEventListener("blur", handleBlur);
+    // Cleanup fonksiyonu
+    var destroy = function () {
+        inputElement.removeEventListener("input", handleInputChange);
+        inputElement.removeEventListener("keydown", handleKeyDown);
+        inputElement.removeEventListener("focus", handleFocus);
+        inputElement.removeEventListener("blur", handleBlur);
+    };
+    // Utility fonksiyonları
+    return {
+        destroy: destroy,
+        setValue: function (value) {
+            if (!value)
+                return;
+            var maskedValue = applyMaskToValue(value || "");
+            inputElement.value = maskedValue;
+        },
+        getValue: function () { return inputElement.value; },
+        getCleanValue: function () { return getCleanValue(inputElement.value); },
+        applyMask: applyMaskToValue
+    };
+};

package/dist/esm/_lib/listFunctions.d.ts

@@ -0,0 +1,2 @@
+export declare const onKeyboardSelection: ({ e, targetElement, itemClass, selectedClass, checkByValue, checkByInput, clear }: any) => null | undefined;
+export declare function setScrollListPosition(targetElement: any): void;

package/dist/esm/_lib/listFunctions.js

@@ -0,0 +1,114 @@
+export var onKeyboardSelection = function (_a) {
+    var e = _a.e, targetElement = _a.targetElement, _b = _a.itemClass, itemClass = _b === void 0 ? "item" : _b, _c = _a.selectedClass, selectedClass = _c === void 0 ? "selected" : _c, checkByValue = _a.checkByValue, checkByInput = _a.checkByInput, clear = _a.clear;
+    if (!targetElement.current)
+        return null;
+    var config = {
+        e: e,
+        itemClass: itemClass,
+        selectedClass: selectedClass,
+    };
+    function selectEnter() {
+        if (!targetElement.current)
+            return null;
+        var text = targetElement.current.querySelector("".concat(config.itemClass, ".").concat(config.selectedClass));
+        if (text) {
+            checkByValue(text.dataset.value);
+        }
+        else if (targetElement.current.querySelectorAll("".concat(config.itemClass)).length > 0) {
+            var target = targetElement.current.querySelectorAll("".concat(config.itemClass, ".").concat(config.selectedClass))[0];
+            checkByValue(target.dataset.value);
+        }
+        else {
+            clear(true, true);
+        }
+    }
+    function selectFirst() {
+        if (!targetElement.current)
+            return null;
+        var showList = targetElement.current.querySelectorAll("".concat(config.itemClass));
+        if (showList.length > 0) {
+            showList[0].classList.add(config.selectedClass);
+        }
+    }
+    function selectLast() {
+        if (!targetElement.current)
+            return null;
+        var showList = targetElement.current.querySelectorAll("".concat(config.itemClass));
+        if (showList.length > 0) {
+            showList[showList.length - 1].classList.add(config.selectedClass);
+        }
+    }
+    function selectNext(element) {
+        element.classList.remove(config.selectedClass);
+        var next = element.nextElementSibling;
+        if (next && next.nodeType !== -1) {
+            if (next.classList.contains("item")) {
+                next.classList.add(config.selectedClass);
+            }
+            else {
+                selectNext(next);
+            }
+        }
+        else {
+            selectFirst();
+        }
+    }
+    function selectPrev(element) {
+        element.classList.remove(config.selectedClass);
+        var next = element.previousElementSibling;
+        if (next && next.nodeType !== -1) {
+            if (next.classList.contains("item")) {
+                next.classList.add(config.selectedClass);
+            }
+            else {
+                selectPrev(next);
+            }
+        }
+        else {
+            selectLast();
+        }
+    }
+    var selected = targetElement.current.querySelector("".concat(config.itemClass, ".").concat(config.selectedClass));
+    if (e.which == 40) {
+        if (selected) {
+            selectNext(selected);
+        }
+        else {
+            selectFirst();
+        }
+    }
+    else if (e.which == 38) {
+        if (selected) {
+            selectPrev(selected);
+        }
+        else {
+            selectLast();
+        }
+    }
+    else if (e.which == 35) {
+        selectLast();
+    }
+    else if (e.which == 36) {
+        selectFirst();
+    }
+    else if (e.which == 13) {
+        selectEnter();
+    }
+    else if (e.which == 9) {
+        checkByInput();
+    }
+    setScrollListPosition(targetElement);
+};
+export function setScrollListPosition(targetElement) {
+    if (targetElement.current) {
+        var position = 0;
+        var text = targetElement.current.querySelector(".selected");
+        if (text) {
+            position = text.offsetTop - 35;
+        }
+        else if (targetElement.current.querySelector(".active")) {
+            position = targetElement.current.querySelector(".active").offsetTop - 35;
+        }
+        targetElement.current.scrollTop = position;
+    }
+}

package/dist/esm/_lib/storage/cookies.d.ts

@@ -0,0 +1,4 @@
+export declare const cerezOku: (context: any | null | undefined, key: string) => string | false;
+export declare const cerezKaydet: (context: any | null | undefined, key: string, value: string, time?: number) => void;
+export declare const cerezSil: (context: any | null | undefined, key: string) => void;
+export declare const cerezTumuSil: (context?: any | null) => void;

package/dist/esm/_lib/storage/cookies.js

@@ -0,0 +1,34 @@
+import { __assign } from "tslib";
+import nookies, { destroyCookie, parseCookies, setCookie } from 'nookies';
+import { getDomain } from '../baseFunctions';
+export var cerezOku = function (context, key) {
+    if (context === void 0) { context = null; }
+    var cookies = context ? nookies.get(context) : parseCookies();
+    return cookies[key] || false;
+};
+export var cerezKaydet = function (context, key, value, time) {
+    if (context === void 0) { context = null; }
+    if (time === void 0) { time = 0; }
+    var newConfig = checkDomain(context);
+    setCookie(context, key, value, __assign({ maxAge: time > 0 ? time : null }, newConfig));
+};
+export var cerezSil = function (context, key) {
+    if (context === void 0) { context = null; }
+    var newConfig = checkDomain(context);
+    destroyCookie(context, key, newConfig);
+};
+export var cerezTumuSil = function (context) {
+    if (context === void 0) { context = null; }
+    var cookies = parseCookies(context);
+    if (cookies) {
+        Object.keys(cookies).forEach(function (key) {
+            destroyCookie(context, key);
+        });
+    }
+};
+var checkDomain = function (context, config) {
+    if (context === void 0) { context = null; }
+    if (config === void 0) { config = {}; }
+    var cookieDomain = getDomain(context);
+    return __assign(__assign({}, config), { domain: '.' + cookieDomain, path: '/' });
+};

package/dist/esm/_lib/storage/encData.d.ts

@@ -0,0 +1,2 @@
+export declare const encData: (data: object | string | number, keys?: number[]) => string;
+export declare const decData: (data: string, keys?: number[]) => any;

package/dist/esm/_lib/storage/encData.js

@@ -0,0 +1,43 @@
+import { isDev } from "../baseFunctions";
+var encDecDataKeys = [3, 5, 8, 11, 15, 22];
+export var encData = function (data, keys) {
+    if (keys === void 0) { keys = encDecDataKeys; }
+    try {
+        var newJSON = { data: data };
+        var utf8Data = unescape(encodeURIComponent(JSON.stringify(newJSON))); // Dizeyi UTF-8'e dönüştür
+        var newData_1 = btoa(utf8Data);
+        keys.map(function (value) {
+            var randomChar = String.fromCharCode(Math.floor(Math.random() * (122 - 97 + 1)) + 97);
+            newData_1 = newData_1.slice(0, value) + randomChar + newData_1.slice(value);
+        });
+        return newData_1;
+    }
+    catch (e) {
+        isDev && console.log("ERROR => encData =>", e);
+        return "";
+    }
+};
+export var decData = function (data, keys) {
+    var _a;
+    if (keys === void 0) { keys = encDecDataKeys; }
+    try {
+        var decode_1 = data;
+        keys.map(function (value, index) {
+            var prevValue = keys[index - 1];
+            if (!prevValue) {
+                decode_1 = decode_1.slice(0, value) + decode_1.slice(value + 1);
+            }
+            else {
+                decode_1 = decode_1.slice(0, value - index) + decode_1.slice(value - index + 1);
+            }
+        });
+        var decodedString = atob(decode_1);
+        var utf8DecodedString = decodeURIComponent(escape(decodedString));
+        var parse = JSON.parse(utf8DecodedString);
+        return (_a = parse === null || parse === void 0 ? void 0 : parse.data) !== null && _a !== void 0 ? _a : "";
+    }
+    catch (e) {
+        isDev && console.log("ERROR => decData =>", e);
+        return "";
+    }
+};

package/dist/esm/_lib/storage/localStorage.d.ts

@@ -0,0 +1,6 @@
+export declare const setLocalStorage: (key: string, value: any) => boolean;
+export declare const getLocalStorage: (key: string) => any;
+export declare const removeLocalStorage: (key: string) => boolean;
+export declare const clearLocalStorage: () => boolean;
+export declare const getLocalStorageAllKeys: () => string[];
+export declare const getLocalStorageSize: () => number;

package/dist/esm/_lib/storage/localStorage.js

@@ -0,0 +1,69 @@
+import { decData, encData } from './encData';
+import { isDev } from '../baseFunctions';
+var storageAvailable = typeof Storage === 'undefined' || !window.localStorage ? false : true;
+export var setLocalStorage = function (key, value) {
+    if (!storageAvailable)
+        return false;
+    try {
+        localStorage.setItem(key, encData(value));
+        return true;
+    }
+    catch (e) {
+        isDev && console.log('ERROR => localStorage =>', e);
+        return false;
+    }
+};
+export var getLocalStorage = function (key) {
+    if (!storageAvailable)
+        return false;
+    try {
+        var saved = localStorage.getItem(key);
+        return saved ? decData(saved) : null;
+    }
+    catch (e) {
+        isDev && console.log('ERROR => localStorage =>', e);
+        return null;
+    }
+};
+export var removeLocalStorage = function (key) {
+    if (!storageAvailable)
+        return false;
+    try {
+        localStorage.removeItem(key);
+        return true;
+    }
+    catch (e) {
+        isDev && console.log('ERROR => localStorage =>', e);
+        return false;
+    }
+};
+export var clearLocalStorage = function () {
+    if (!storageAvailable)
+        return false;
+    try {
+        localStorage.clear();
+        return true;
+    }
+    catch (e) {
+        isDev && console.log('ERROR => localStorage =>', e);
+        return false;
+    }
+};
+// Tüm localStorage anahtarlarını getir
+export var getLocalStorageAllKeys = function () {
+    if (!storageAvailable)
+        return [];
+    return Object.keys(localStorage);
+};
+// Tüm localStorage boyutunu getir
+export var getLocalStorageSize = function () {
+    if (!storageAvailable)
+        return 0;
+    var total = 0;
+    for (var key in localStorage) {
+        if (localStorage.hasOwnProperty(key)) {
+            total += localStorage[key].length + key.length;
+        }
+    }
+    return total;
+};

package/dist/esm/_lib/storage/sessionStorage.d.ts

@@ -0,0 +1,6 @@
+export declare const setSessionStorage: (key: string, value: any) => boolean;
+export declare const getSessionStorage: (key: string) => any;
+export declare const removeSessionStorage: (key: string) => boolean;
+export declare const clearSessionStorage: () => boolean;
+export declare const getSessionStorageAllKeys: () => string[];
+export declare const getSessionStorageSize: () => number;