@fajarmaulana/komerce-lp-helper 0.1.0

package/dist/utils/api.js

@@ -0,0 +1,503 @@
+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 __());
+    };
+})();
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+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;
+};
+export var buildURL = function (url, params) {
+    if (!params)
+        return url;
+    var queryString = Object.entries(params)
+        .map(function (_a) {
+        var _b = __read(_a, 2), key = _b[0], value = _b[1];
+        if (Array.isArray(value)) {
+            var joined = value.map(function (v) { return encodeURIComponent(v); }).join(",");
+            return "".concat(encodeURIComponent(key), "=").concat(joined);
+        }
+        return "".concat(encodeURIComponent(key), "=").concat(encodeURIComponent(value));
+    })
+        .join("&");
+    return url.includes("?") ? "".concat(url, "&").concat(queryString) : "".concat(url, "?").concat(queryString);
+};
+var ApiMeta = /** @class */ (function (_super) {
+    __extends(ApiMeta, _super);
+    function ApiMeta(code, message, status) {
+        var _this = _super.call(this, message) || this;
+        _this.code = code;
+        _this.status = status;
+        return _this;
+    }
+    return ApiMeta;
+}(Error));
+export { ApiMeta };
+var ApiInstance = /** @class */ (function () {
+    function ApiInstance(options) {
+        if (options === void 0) { options = {}; }
+        this.interceptors = {};
+        this.baseURL = options.baseURL || "";
+        this.defaultHeaders = options.headers || {};
+        this.source = "komcards-".concat(options.source || "default");
+        this.cache = new Map();
+        this.maxCacheSize = options.maxCacheSize || 100;
+        this.cacheAccessOrder = [];
+    }
+    ApiInstance.prototype.setInterceptors = function (interceptors) {
+        this.interceptors = interceptors;
+    };
+    ApiInstance.prototype.hash = function (str) {
+        var hash = 0;
+        for (var i = 0; i < str.length; i++) {
+            var char = str.charCodeAt(i);
+            hash = (hash << 5) - hash + char;
+            hash = hash & hash;
+        }
+        return hash.toString(36);
+    };
+    ApiInstance.prototype.buildcacheKey = function (config) {
+        var keyObj = {
+            url: config.url,
+            params: config.params,
+        };
+        var keyString = JSON.stringify(keyObj);
+        if (keyString.length > 200) {
+            return "".concat(this.source, ":").concat(this.hash(keyString));
+        }
+        return "".concat(this.source, ":").concat(keyString);
+    };
+    ApiInstance.prototype.fetchWithXHR = function (input, init, onUpload, onDownload) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, new Promise(function (resolve, reject) {
+                        var xhr = new XMLHttpRequest();
+                        var method = (init.method || "GET").toUpperCase();
+                        xhr.open(method, input);
+                        if (init.headers) {
+                            var headers = new Headers(init.headers);
+                            headers.forEach(function (value, key) {
+                                xhr.setRequestHeader(key, value);
+                            });
+                        }
+                        if (onUpload && xhr.upload) {
+                            xhr.upload.addEventListener("progress", function (e) {
+                                var total = e.lengthComputable ? e.total : 0;
+                                var percentage = e.lengthComputable ? Math.round((e.loaded / e.total) * 100) : 0;
+                                onUpload({
+                                    loaded: e.loaded,
+                                    total: total,
+                                    percentage: percentage,
+                                });
+                            });
+                        }
+                        if (onDownload) {
+                            xhr.responseType = "blob";
+                            xhr.addEventListener("progress", function (e) {
+                                var total = e.lengthComputable ? e.total : 0;
+                                var percentage = e.lengthComputable ? Math.round((e.loaded / e.total) * 100) : 0;
+                                onDownload({
+                                    loaded: e.loaded,
+                                    total: total,
+                                    percentage: percentage,
+                                });
+                            });
+                        }
+                        if (init.signal) {
+                            init.signal.addEventListener("abort", function () {
+                                xhr.abort();
+                                reject(new DOMException("The operation was aborted.", "AbortError"));
+                            });
+                        }
+                        xhr.onload = function () {
+                            var headers = new Headers();
+                            xhr
+                                .getAllResponseHeaders()
+                                .split("\r\n")
+                                .forEach(function (line) {
+                                var parts = line.split(": ");
+                                if (parts.length === 2) {
+                                    headers.append(parts[0], parts[1]);
+                                }
+                            });
+                            var response = new Response(xhr.response, {
+                                status: xhr.status,
+                                statusText: xhr.statusText,
+                                headers: headers,
+                            });
+                            resolve(response);
+                        };
+                        xhr.onerror = function () { return reject(new TypeError("Network request failed")); };
+                        xhr.ontimeout = function () { return reject(new TypeError("Network request timeout")); };
+                        xhr.send(init.body);
+                    })];
+            });
+        });
+    };
+    ApiInstance.prototype.fetchWithRetry = function (input, init, retry, signal, onUpload, onDownload) {
+        return __awaiter(this, void 0, void 0, function () {
+            var attempt, lastErr, _loop_1, this_1, state_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        attempt = 0;
+                        _loop_1 = function () {
+                            var res, clonedRes, error, code, message, status_1, err_1, delay_1;
+                            return __generator(this, function (_b) {
+                                switch (_b.label) {
+                                    case 0:
+                                        _b.trys.push([0, 7, , 9]);
+                                        res = void 0;
+                                        if (!(onUpload || onDownload)) return [3 /*break*/, 2];
+                                        return [4 /*yield*/, this_1.fetchWithXHR(input, __assign(__assign({}, init), { signal: signal }), onUpload, onDownload)];
+                                    case 1:
+                                        res = _b.sent();
+                                        return [3 /*break*/, 4];
+                                    case 2: return [4 /*yield*/, fetch(input, __assign(__assign({}, init), { signal: signal }))];
+                                    case 3:
+                                        res = _b.sent();
+                                        _b.label = 4;
+                                    case 4:
+                                        if (!!res.ok) return [3 /*break*/, 6];
+                                        clonedRes = res.clone();
+                                        return [4 /*yield*/, clonedRes.json()];
+                                    case 5:
+                                        error = _b.sent();
+                                        if (error.meta || error.status) {
+                                            code = error.code || error.meta.code || res.status;
+                                            message = error.message || error.meta.message || JSON.stringify(error);
+                                            status_1 = error.status || error.meta.status || res.statusText;
+                                            throw new ApiMeta(code, message, status_1);
+                                        }
+                                        throw error;
+                                    case 6: return [2 /*return*/, { value: res }];
+                                    case 7:
+                                        err_1 = _b.sent();
+                                        if (err_1 instanceof Error && err_1.name === "AbortError") {
+                                            throw err_1;
+                                        }
+                                        lastErr = err_1;
+                                        if (attempt === retry)
+                                            throw lastErr;
+                                        delay_1 = Math.pow(2, attempt) * 200;
+                                        return [4 /*yield*/, new Promise(function (r) { return setTimeout(r, delay_1); })];
+                                    case 8:
+                                        _b.sent();
+                                        attempt++;
+                                        return [3 /*break*/, 9];
+                                    case 9: return [2 /*return*/];
+                                }
+                            });
+                        };
+                        this_1 = this;
+                        _a.label = 1;
+                    case 1:
+                        if (!(attempt <= retry)) return [3 /*break*/, 3];
+                        return [5 /*yield**/, _loop_1()];
+                    case 2:
+                        state_1 = _a.sent();
+                        if (typeof state_1 === "object")
+                            return [2 /*return*/, state_1.value];
+                        return [3 /*break*/, 1];
+                    case 3: throw lastErr;
+                }
+            });
+        });
+    };
+    ApiInstance.prototype.handleInterceptors = function (config) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this.interceptors.request) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.interceptors.request(config)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                    case 2: return [2 /*return*/, config];
+                }
+            });
+        });
+    };
+    ApiInstance.prototype.handleResponse = function (response) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this.interceptors.response) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.interceptors.response(response)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                    case 2: return [2 /*return*/, response];
+                }
+            });
+        });
+    };
+    ApiInstance.prototype.handleError = function (error) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this.interceptors.error) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.interceptors.error(error)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                    case 2: throw error;
+                }
+            });
+        });
+    };
+    ApiInstance.prototype.getCacheEntry = function (key) {
+        var entry = this.cache.get(key);
+        if (entry) {
+            var index = this.cacheAccessOrder.indexOf(key);
+            if (index > -1) {
+                this.cacheAccessOrder.splice(index, 1);
+            }
+            this.cacheAccessOrder.push(key);
+        }
+        return entry;
+    };
+    ApiInstance.prototype.setCacheEntry = function (key, entry) {
+        if (this.cache.size >= this.maxCacheSize && !this.cache.has(key)) {
+            var oldestKey = this.cacheAccessOrder.shift();
+            if (oldestKey) {
+                this.cache.delete(oldestKey);
+            }
+        }
+        this.cache.set(key, entry);
+        var index = this.cacheAccessOrder.indexOf(key);
+        if (index > -1) {
+            this.cacheAccessOrder.splice(index, 1);
+        }
+        this.cacheAccessOrder.push(key);
+    };
+    ApiInstance.prototype.removeCacheEntry = function (key) {
+        this.cache.delete(key);
+        var index = this.cacheAccessOrder.indexOf(key);
+        if (index > -1) {
+            this.cacheAccessOrder.splice(index, 1);
+        }
+    };
+    ApiInstance.prototype.request = function (config) {
+        return __awaiter(this, void 0, void 0, function () {
+            var finalConfig, cacheKey, cached, expired, url, finalURL, isFormData, response, finalResponse, error, code, message, status_2, _a, errorText, contentType, data, error_1;
+            var _b, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        _d.trys.push([0, 15, , 16]);
+                        return [4 /*yield*/, this.handleInterceptors(config)];
+                    case 1:
+                        finalConfig = _d.sent();
+                        cacheKey = this.buildcacheKey(finalConfig);
+                        if (finalConfig.cache && finalConfig.cache.enabled && finalConfig.method === "GET") {
+                            cached = this.getCacheEntry(cacheKey);
+                            if (cached) {
+                                expired = cached.ttl && Date.now() - cached.timestamp > cached.ttl;
+                                if (!expired) {
+                                    return [2 /*return*/, { data: cached.data, cacheKey: cacheKey, fromCache: true }];
+                                }
+                                this.removeCacheEntry(cacheKey);
+                            }
+                        }
+                        url = this.baseURL ? "".concat(this.baseURL).concat(finalConfig.url) : finalConfig.url;
+                        finalURL = buildURL(url, finalConfig.params);
+                        isFormData = finalConfig.body instanceof FormData;
+                        return [4 /*yield*/, this.fetchWithRetry(finalURL, {
+                                method: finalConfig.method || "GET",
+                                headers: __assign(__assign(__assign({}, (isFormData ? {} : { "Content-Type": "application/json" })), this.defaultHeaders), finalConfig.headers),
+                                body: isFormData
+                                    ? finalConfig.body
+                                    : finalConfig.body
+                                        ? JSON.stringify(finalConfig.body)
+                                        : undefined,
+                            }, (_b = finalConfig.retry) !== null && _b !== void 0 ? _b : 0, finalConfig.signal, finalConfig.onUpload, finalConfig.onDownload)];
+                    case 2:
+                        response = _d.sent();
+                        return [4 /*yield*/, this.handleResponse(response)];
+                    case 3:
+                        finalResponse = _d.sent();
+                        if (!!finalResponse.ok) return [3 /*break*/, 8];
+                        _d.label = 4;
+                    case 4:
+                        _d.trys.push([4, 6, , 8]);
+                        return [4 /*yield*/, finalResponse.clone().json()];
+                    case 5:
+                        error = _d.sent();
+                        if (error.meta || error.status) {
+                            code = error.code || error.meta.code || finalResponse.status;
+                            message = error.message || error.meta.message || JSON.stringify(error);
+                            status_2 = error.status || error.meta.status || finalResponse.statusText;
+                            throw new ApiMeta(code, message, status_2);
+                        }
+                        throw error;
+                    case 6:
+                        _a = _d.sent();
+                        return [4 /*yield*/, finalResponse.text()];
+                    case 7:
+                        errorText = _d.sent();
+                        throw new Error(errorText || finalResponse.statusText);
+                    case 8:
+                        contentType = finalResponse.headers.get("content-type") || "";
+                        data = void 0;
+                        if (!contentType.includes("application/json")) return [3 /*break*/, 10];
+                        return [4 /*yield*/, finalResponse.json()];
+                    case 9:
+                        data = (_d.sent());
+                        return [3 /*break*/, 14];
+                    case 10:
+                        if (!contentType.includes("text/")) return [3 /*break*/, 12];
+                        return [4 /*yield*/, finalResponse.text()];
+                    case 11:
+                        data = (_d.sent());
+                        return [3 /*break*/, 14];
+                    case 12: return [4 /*yield*/, finalResponse.blob()];
+                    case 13:
+                        data = (_d.sent());
+                        _d.label = 14;
+                    case 14:
+                        if (finalConfig.cache && finalConfig.cache.enabled && finalConfig.method === "GET") {
+                            this.setCacheEntry(cacheKey, {
+                                data: data,
+                                timestamp: Date.now(),
+                                ttl: (_c = finalConfig.cache) === null || _c === void 0 ? void 0 : _c.revalidate,
+                            });
+                        }
+                        return [2 /*return*/, { data: data, cacheKey: cacheKey, fromCache: false }];
+                    case 15:
+                        error_1 = _d.sent();
+                        return [2 /*return*/, this.handleError(error_1)];
+                    case 16: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    ApiInstance.prototype.get = function (url, config) {
+        if (config === void 0) { config = {}; }
+        return this.request(__assign(__assign({}, config), { url: url, method: "GET" }));
+    };
+    ApiInstance.prototype.post = function (url, body, config) {
+        if (config === void 0) { config = {}; }
+        return this.request(__assign(__assign({}, config), { url: url, method: "POST", body: body }));
+    };
+    ApiInstance.prototype.put = function (url, body, config) {
+        if (config === void 0) { config = {}; }
+        return this.request(__assign(__assign({}, config), { url: url, method: "PUT", body: body }));
+    };
+    ApiInstance.prototype.patch = function (url, body, config) {
+        if (config === void 0) { config = {}; }
+        return this.request(__assign(__assign({}, config), { url: url, method: "PATCH", body: body }));
+    };
+    ApiInstance.prototype.delete = function (url, body, config) {
+        if (config === void 0) { config = {}; }
+        return this.request(__assign(__assign({}, config), { url: url, method: "DELETE", body: body }));
+    };
+    ApiInstance.prototype.getCache = function (key) {
+        var entry = this.getCacheEntry(key);
+        return entry === null || entry === void 0 ? void 0 : entry.data;
+    };
+    ApiInstance.prototype.setCache = function (key, data, ttl) {
+        this.setCacheEntry(key, { data: data, timestamp: Date.now(), ttl: ttl });
+    };
+    ApiInstance.prototype.removeCache = function (key) {
+        this.removeCacheEntry(key);
+    };
+    ApiInstance.prototype.clearCache = function () {
+        this.cache.clear();
+        this.cacheAccessOrder = [];
+    };
+    return ApiInstance;
+}());
+export { ApiInstance };
+var instance = new ApiInstance();
+var http = {
+    get: function (url, config) { return instance.get(url, config); },
+    post: function (url, body, config) {
+        return instance.post(url, body, config);
+    },
+    put: function (url, body, config) {
+        return instance.put(url, body, config);
+    },
+    patch: function (url, body, config) {
+        return instance.patch(url, body, config);
+    },
+    delete: function (url, body, config) {
+        return instance.delete(url, body, config);
+    },
+    getCache: function (key) { return instance.getCache(key); },
+    setCache: function (key, data, ttl) { return instance.setCache(key, data, ttl); },
+    removeCache: function (key) { return instance.removeCache(key); },
+    clearCache: function () { return instance.clearCache(); },
+    request: function (config) { return instance.request(config); },
+    create: function (options) {
+        if (options === void 0) { options = {}; }
+        return new ApiInstance(options);
+    },
+};
+export default http;

package/dist/utils/cookie.d.ts

@@ -0,0 +1,50 @@
+type TCookie<T> = {
+    key: string;
+    value: T;
+    maxAge?: number;
+};
+/**
+ * Sets a cookie with the specified key, value, and optional max age.
+ *
+ * @param key - The cookie key.
+ * @param value - The cookie value (will be JSON-stringified).
+ * @param maxAge - Optional max age of the cookie in seconds.
+ */
+export declare const setCookie: <T>({ key, value, maxAge }: TCookie<T>) => void;
+/**
+ * Sets multiple cookies from an array of cookie objects.
+ *
+ * @param items - Array of cookies to set.
+ */
+export declare const setCookies: (items: TCookie<unknown>[]) => void;
+/**
+ * Gets the value of a cookie by key and parses it from JSON.
+ *
+ * @param key - The key of the cookie to get.
+ * @returns The parsed cookie value, or null if not found.
+ */
+export declare const getCookie: <T>(key: string) => T | null;
+/**
+ * Retrieves multiple cookies by keys.
+ *
+ * @param keys - Array of keys to retrieve.
+ * @returns Object with keys and their corresponding parsed values.
+ */
+export declare const getCookies: <T extends Record<string, unknown>, K extends keyof T = keyof T>(keys: readonly K[]) => { [P in K]: T[P] | null; };
+/**
+ * Removes a cookie by key by setting its max age to 0.
+ *
+ * @param key - The key of the cookie to remove.
+ */
+export declare const removeCookie: (key: string) => void;
+/**
+ * Removes multiple cookies by keys.
+ *
+ * @param keys - Array of keys to remove.
+ */
+export declare const removeCookies: (keys: string[]) => void;
+/**
+ * Clears all cookies by setting their max age to 0.
+ */
+export declare const clearCookies: () => void;
+export {};

package/dist/utils/cookie.js

@@ -0,0 +1,75 @@
+/**
+ * Sets a cookie with the specified key, value, and optional max age.
+ *
+ * @param key - The cookie key.
+ * @param value - The cookie value (will be JSON-stringified).
+ * @param maxAge - Optional max age of the cookie in seconds.
+ */
+export var setCookie = function (_a) {
+    var key = _a.key, value = _a.value, maxAge = _a.maxAge;
+    var serializedValue = JSON.stringify(value);
+    document.cookie = "".concat(key, "=").concat(serializedValue).concat(maxAge ? "; Max-Age=".concat(maxAge) : '', "; Secure; SameSite=Strict; path=/");
+};
+/**
+ * Sets multiple cookies from an array of cookie objects.
+ *
+ * @param items - Array of cookies to set.
+ */
+export var setCookies = function (items) {
+    items.forEach(function (item) { return setCookie(item); });
+};
+/**
+ * Gets the value of a cookie by key and parses it from JSON.
+ *
+ * @param key - The key of the cookie to get.
+ * @returns The parsed cookie value, or null if not found.
+ */
+export var getCookie = function (key) {
+    var match = document.cookie.match(new RegExp('(^| )' + key + '=([^;]+)'));
+    if (!match)
+        return null;
+    try {
+        return JSON.parse(decodeURIComponent(match[2]));
+    }
+    catch (_a) {
+        return decodeURIComponent(match[2]);
+    }
+};
+/**
+ * Retrieves multiple cookies by keys.
+ *
+ * @param keys - Array of keys to retrieve.
+ * @returns Object with keys and their corresponding parsed values.
+ */
+export var getCookies = function (keys) {
+    return keys.reduce(function (acc, key) {
+        acc[key] = getCookie(key);
+        return acc;
+    }, {});
+};
+/**
+ * Removes a cookie by key by setting its max age to 0.
+ *
+ * @param key - The key of the cookie to remove.
+ */
+export var removeCookie = function (key) {
+    document.cookie = "".concat(key, "=; Max-Age=0; Secure; SameSite=Strict; path=/");
+};
+/**
+ * Removes multiple cookies by keys.
+ *
+ * @param keys - Array of keys to remove.
+ */
+export var removeCookies = function (keys) {
+    keys.forEach(function (key) { return removeCookie(key); });
+};
+/**
+ * Clears all cookies by setting their max age to 0.
+ */
+export var clearCookies = function () {
+    document.cookie.split('; ').forEach(function (cookie) {
+        var eqPos = cookie.indexOf('=');
+        var key = eqPos > -1 ? cookie.substring(0, eqPos) : cookie;
+        removeCookie(key);
+    });
+};