ts-client-lib 0.0.7

package/utils/TSPaginationMulti.js

@@ -0,0 +1,356 @@
+"use strict";
+/**
+ * Multi-feed cursor pagination — client-side emulation of legacy paginateMulti.
+ *
+ * Each feed keeps its own PGN-1 cursor; this module k-way merges by a shared sort field.
+ * Use for "All orders" / recent-activity views. Per-product tabs should use TSPagination alone.
+ *
+ * @see TSPagination.ts — single-feed cursor UI helpers
+ */
+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 };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TSPaginationMulti = exports.MultiFeedMergePaginator = void 0;
+exports.mergeConnectionsFirstPage = mergeConnectionsFirstPage;
+exports.toMergedCursorConnection = toMergedCursorConnection;
+var TSPagination_js_1 = require("./TSPagination.js");
+// ═══════════════════════════════════════════════════════════════════
+// Pure merge (first page / stateless)
+// ═══════════════════════════════════════════════════════════════════
+function sortValue(raw) {
+    if (raw == null)
+        return 0;
+    if (raw instanceof Date)
+        return raw.getTime();
+    if (typeof raw === 'number' && Number.isFinite(raw))
+        return raw;
+    if (typeof raw === 'string') {
+        var parsed = Date.parse(raw);
+        return Number.isNaN(parsed) ? 0 : parsed;
+    }
+    return 0;
+}
+function compareNodes(a, b, sortField, sortDir) {
+    var _a, _b, _c, _d;
+    var av = sortValue(a[sortField]);
+    var bv = sortValue(b[sortField]);
+    if (av !== bv)
+        return sortDir === 'desc' ? bv - av : av - bv;
+    var aid = String((_b = (_a = a['id']) !== null && _a !== void 0 ? _a : a['orderId']) !== null && _b !== void 0 ? _b : '');
+    var bid = String((_d = (_c = b['id']) !== null && _c !== void 0 ? _c : b['orderId']) !== null && _d !== void 0 ? _d : '');
+    return aid.localeCompare(bid);
+}
+/**
+ * Stateless merge — legacy paginateMulti page-1 equivalent.
+ * Parallel responses are merged, sorted, and sliced to `limit`.
+ */
+function mergeConnectionsFirstPage(responses, opts) {
+    var _a;
+    var sortDir = (_a = opts.sortDir) !== null && _a !== void 0 ? _a : 'desc';
+    var merged = [];
+    var feeds = {};
+    var totalSum = 0;
+    var allTotals = true;
+    for (var _i = 0, responses_1 = responses; _i < responses_1.length; _i++) {
+        var _b = responses_1[_i], key = _b.key, connection = _b.connection;
+        feeds[key] = {
+            pageInfo: connection.pageInfo,
+            buffered: connection.nodes.length
+        };
+        if (typeof connection.totalCount !== 'number')
+            allTotals = false;
+        else
+            totalSum += connection.totalCount;
+        for (var _c = 0, _d = connection.nodes; _c < _d.length; _c++) {
+            var node = _d[_c];
+            merged.push(__assign(__assign({}, node), { feedKey: key }));
+        }
+    }
+    merged.sort(function (a, b) { return compareNodes(a, b, opts.sortField, sortDir); });
+    var nodes = merged.slice(0, opts.limit);
+    var hasMore = merged.length > opts.limit ||
+        responses.some(function (_a) {
+            var connection = _a.connection;
+            return connection.pageInfo.hasNextPage;
+        });
+    return {
+        nodes: nodes,
+        totalCount: allTotals ? totalSum : undefined,
+        hasMore: hasMore,
+        feeds: feeds
+    };
+}
+/** Adapt merge result to ConnectionList / GraphQL connection shape. */
+function toMergedCursorConnection(result) {
+    var _a;
+    return {
+        nodes: result.nodes,
+        totalCount: (_a = result.totalCount) !== null && _a !== void 0 ? _a : result.nodes.length,
+        pageInfo: {
+            hasNextPage: result.hasMore,
+            hasPreviousPage: false,
+            startCursor: null,
+            endCursor: null
+        }
+    };
+}
+// ═══════════════════════════════════════════════════════════════════
+// Stateful k-way merge (page 2+)
+// ═══════════════════════════════════════════════════════════════════
+/**
+ * Maintains per-feed buffers and cursors; fetches the next globally sorted page.
+ */
+var MultiFeedMergePaginator = /** @class */ (function () {
+    function MultiFeedMergePaginator(sources, pageSize, sortField, sortDir) {
+        if (sortDir === void 0) { sortDir = 'desc'; }
+        this.sources = sources;
+        this.pageSize = pageSize;
+        this.sortField = sortField;
+        this.sortDir = sortDir;
+        this.buffers = [];
+        this.pageIndex = 0;
+    }
+    MultiFeedMergePaginator.prototype.reset = function () {
+        var _this = this;
+        this.buffers = this.sources.map(function (source) { return ({
+            key: source.key,
+            pending: [],
+            pageInfo: TSPaginationMulti.initialPageInfo(),
+            pagination: { first: _this.pageSize },
+            exhausted: false,
+            totalCount: undefined,
+            fetch: source.fetch,
+            mapNode: source.mapNode
+        }); });
+        this.pageIndex = 0;
+    };
+    /** Fetch the next merged page (call reset() before the first page). */
+    MultiFeedMergePaginator.prototype.fetchNextPage = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var page, head, feeds, totalSum, allTotals, _i, _a, buf, hasMore;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (this.buffers.length === 0)
+                            this.reset();
+                        page = [];
+                        _b.label = 1;
+                    case 1:
+                        if (!(page.length < this.pageSize)) return [3 /*break*/, 3];
+                        return [4 /*yield*/, this.peekBestHead()];
+                    case 2:
+                        head = _b.sent();
+                        if (!head)
+                            return [3 /*break*/, 3];
+                        page.push(__assign(__assign({}, head.node), { feedKey: head.buffer.key }));
+                        head.buffer.pending.shift();
+                        return [3 /*break*/, 1];
+                    case 3:
+                        this.pageIndex += 1;
+                        feeds = {};
+                        totalSum = 0;
+                        allTotals = true;
+                        for (_i = 0, _a = this.buffers; _i < _a.length; _i++) {
+                            buf = _a[_i];
+                            feeds[buf.key] = { pageInfo: buf.pageInfo, buffered: buf.pending.length };
+                            if (typeof buf.totalCount !== 'number')
+                                allTotals = false;
+                            else
+                                totalSum += buf.totalCount;
+                        }
+                        hasMore = this.buffers.some(function (b) { return b.pending.length > 0 || (!b.exhausted && b.pageInfo.hasNextPage); });
+                        return [2 /*return*/, {
+                                nodes: page,
+                                totalCount: allTotals ? totalSum : undefined,
+                                hasMore: hasMore,
+                                feeds: feeds
+                            }];
+                }
+            });
+        });
+    };
+    Object.defineProperty(MultiFeedMergePaginator.prototype, "currentPageIndex", {
+        get: function () {
+            return this.pageIndex;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    MultiFeedMergePaginator.prototype.peekBestHead = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var best, _i, _a, buffer, node;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, this.refillBuffersWhereNeeded()];
+                    case 1:
+                        _b.sent();
+                        best = null;
+                        for (_i = 0, _a = this.buffers; _i < _a.length; _i++) {
+                            buffer = _a[_i];
+                            node = buffer.pending[0];
+                            if (!node)
+                                continue;
+                            if (!best || compareNodes(node, best.node, this.sortField, this.sortDir) < 0) {
+                                best = { buffer: buffer, node: node };
+                            }
+                        }
+                        return [2 /*return*/, best];
+                }
+            });
+        });
+    };
+    MultiFeedMergePaginator.prototype.refillBuffersWhereNeeded = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var needsFetch, emptyActive;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        needsFetch = this.buffers.filter(function (b) { return !b.exhausted && b.pending.length === 0 && b.pageInfo.hasNextPage !== false; });
+                        if (!(needsFetch.length === 0)) return [3 /*break*/, 2];
+                        emptyActive = this.buffers.filter(function (b) { return !b.exhausted && b.pending.length === 0; });
+                        if (emptyActive.length === 0)
+                            return [2 /*return*/];
+                        return [4 /*yield*/, Promise.all(emptyActive.map(function (b) { return _this.fetchMore(b); }))];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                    case 2:
+                        if (!(this.pageIndex === 0)) return [3 /*break*/, 4];
+                        return [4 /*yield*/, Promise.all(this.buffers.map(function (b) { return _this.fetchMore(b); }))];
+                    case 3:
+                        _a.sent();
+                        return [3 /*break*/, 6];
+                    case 4: return [4 /*yield*/, Promise.all(needsFetch.map(function (b) { return _this.fetchMore(b); }))];
+                    case 5:
+                        _a.sent();
+                        _a.label = 6;
+                    case 6: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    MultiFeedMergePaginator.prototype.resolveFetchPagination = function (buffer, isFirstFetch) {
+        if (isFirstFetch)
+            return { first: this.pageSize };
+        if (buffer.pageInfo.hasNextPage && buffer.pageInfo.endCursor) {
+            return { first: this.pageSize, after: buffer.pageInfo.endCursor };
+        }
+        return { first: this.pageSize };
+    };
+    MultiFeedMergePaginator.prototype.fetchMore = function (buffer) {
+        return __awaiter(this, void 0, void 0, function () {
+            var isFirstFetch, pagination, connection, mapped;
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (buffer.exhausted)
+                            return [2 /*return*/];
+                        isFirstFetch = buffer.pending.length === 0 && !buffer.pageInfo.endCursor;
+                        pagination = this.resolveFetchPagination(buffer, isFirstFetch);
+                        if (!isFirstFetch && !buffer.pageInfo.hasNextPage) {
+                            buffer.exhausted = true;
+                            return [2 /*return*/];
+                        }
+                        return [4 /*yield*/, buffer.fetch(pagination)];
+                    case 1:
+                        connection = _b.sent();
+                        buffer.pageInfo = connection.pageInfo;
+                        buffer.pagination = pagination;
+                        if (typeof connection.totalCount === 'number')
+                            buffer.totalCount = connection.totalCount;
+                        mapped = connection.nodes.map(function (n) { return (buffer.mapNode ? buffer.mapNode(n) : n); });
+                        (_a = buffer.pending).push.apply(_a, mapped);
+                        if (!connection.pageInfo.hasNextPage && mapped.length === 0) {
+                            buffer.exhausted = true;
+                        }
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    return MultiFeedMergePaginator;
+}());
+exports.MultiFeedMergePaginator = MultiFeedMergePaginator;
+// ═══════════════════════════════════════════════════════════════════
+// Facade
+// ═══════════════════════════════════════════════════════════════════
+var TSPaginationMulti = /** @class */ (function () {
+    function TSPaginationMulti() {
+    }
+    TSPaginationMulti.initialPageInfo = function () {
+        return {
+            hasNextPage: false,
+            hasPreviousPage: false,
+            startCursor: null,
+            endCursor: null
+        };
+    };
+    /** One CursorPaginationState per feed key (tab mode). */
+    TSPaginationMulti.createFeedStates = function (keys, defaultPageSize) {
+        if (defaultPageSize === void 0) { defaultPageSize = 25; }
+        var out = {};
+        for (var _i = 0, keys_1 = keys; _i < keys_1.length; _i++) {
+            var key = keys_1[_i];
+            out[key] = { first: defaultPageSize };
+        }
+        return out;
+    };
+    TSPaginationMulti.createPaginator = function (sources, pageSize, sortField, sortDir) {
+        if (sortDir === void 0) { sortDir = 'desc'; }
+        return new MultiFeedMergePaginator(sources, pageSize, sortField, sortDir);
+    };
+    TSPaginationMulti.mergeFirstPage = mergeConnectionsFirstPage;
+    TSPaginationMulti.toCursorConnection = toMergedCursorConnection;
+    /** Re-export for merged views that share the same pagination bar helpers. */
+    TSPaginationMulti.getDisplay = TSPagination_js_1.TSPagination.getDisplay.bind(TSPagination_js_1.TSPagination);
+    TSPaginationMulti.getRangeStartAfterMove = TSPagination_js_1.TSPagination.getRangeStartAfterMove.bind(TSPagination_js_1.TSPagination);
+    return TSPaginationMulti;
+}());
+exports.TSPaginationMulti = TSPaginationMulti;

package/utils/TSString.d.ts

@@ -0,0 +1,10 @@
+export declare class TSString {
+    static slugify(text: string, join?: string, cut?: string): string;
+    static parseAndReplace(text: string, data?: any, cb?: (k: any, t?: any) => any, masks?: Array<string>): string;
+    static masks(kind: string, key?: string): RegExp;
+    static pad(string: string | number, length?: number, char?: any, append?: boolean): string;
+    static cfChar(string: string, char?: string): string;
+    static paramToJson(text: string): string;
+    static isJson(text: string): boolean;
+    static splitBy(term: string, match: string, kind?: 'first' | 'last'): string[];
+}

package/utils/TSString.js

@@ -0,0 +1,107 @@
+"use strict";
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TSString = void 0;
+var TSString = /** @class */ (function () {
+    function TSString() {
+    }
+    TSString.slugify = function (text, join, cut) {
+        if (join === void 0) { join = '-'; }
+        if (cut) {
+            text = text.toString().split(cut)[0];
+        }
+        text = text.toString().replace(/[^\w\s]/g, '');
+        if (join === 'cc') {
+            return text.split(/\.|_|\s+|\d+/).map(function (v, i) {
+                v = v.toLowerCase();
+                if (i > 0) {
+                    v = TSString.cfChar(v);
+                }
+                return v.length > 1 ? v : '';
+            }).filter(Boolean).join('');
+        }
+        return text.replace(/\s+/g, join).toLowerCase();
+    };
+    TSString.parseAndReplace = function (text, data, cb, masks) {
+        if (masks === void 0) { masks = ['braces']; }
+        if (data && Array.isArray(data)) {
+            data.forEach(function (v, i) { return text = text.replace(RegExp(('{' + i + '}').replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'g'), v); });
+        }
+        else if (data && typeof data === 'object') {
+            var keys = masks.reduce(function (a, k) { return Object.assign.apply(Object, __spreadArray([a], (text.match(TSString.masks(k, '.+?')) || []).map(function (s) {
+                var _a;
+                return (_a = {}, _a[s.slice(1, -1)] = s, _a);
+            }), false)); }, {});
+            for (var k in keys) {
+                if (Object.hasOwn(keys, k)) {
+                    var _a = k.split(/:(.+)/), key = _a[0], type = _a[1];
+                    text = text.replace(new RegExp(keys[k].replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'g'), cb ? cb(key, type) : data[key]);
+                }
+            }
+        }
+        masks.forEach(function (k) { return text = text.replace(TSString.masks(k), ''); });
+        return text;
+    };
+    TSString.masks = function (kind, key) {
+        if (key === void 0) { key = '.*'; }
+        if (kind === 'braces') {
+            return /(?:^|)\{([^{}]*)(\}(?!\}))/g;
+        }
+        else if (kind === 'parentheses') {
+            return new RegExp('\\(' + key + '\\)', 'g');
+        }
+        else if (kind === 'brackets') {
+            return new RegExp('\\[' + key + '\\]', 'g');
+        }
+        return new RegExp('%' + key + '%', 'g');
+    };
+    TSString.pad = function (string, length, char, append) {
+        if (length === void 0) { length = 2; }
+        if (char === void 0) { char = ' '; }
+        string = string.toString();
+        char = char.toString();
+        while (string.length < length) {
+            string = append ? string + char : char + string;
+        }
+        return string;
+    };
+    TSString.cfChar = function (string, char) {
+        string = string.toString();
+        if (char && string.indexOf(char) !== 0) {
+            string = char + string;
+        }
+        else {
+            string = string.charAt(0).toUpperCase() + string.slice(1);
+        }
+        return string;
+    };
+    TSString.paramToJson = function (text) {
+        return '{"' + text.replace(/"/g, '\\"').replace(/&/g, '","').replace(/=/g, '":"') + '"}';
+    };
+    TSString.isJson = function (text) {
+        return /^[\],:{}\s]*$/.test(text.replace(/\\["\\/bfnrtu]/g, '@')
+            .replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+-]?\d+)?/g, ']')
+            .replace(/(?:^|:|,)(?:\s*\[)+/g, ''));
+    };
+    TSString.splitBy = function (term, match, kind) {
+        if (kind === void 0) { kind = 'last'; }
+        var index;
+        if (kind === 'last') {
+            index = term.lastIndexOf(match);
+        }
+        else {
+            index = term.indexOf(match);
+        }
+        return [term.substring(0, index), term.substring(index + 1)];
+    };
+    return TSString;
+}());
+exports.TSString = TSString;

package/utils/TSValidator.d.ts

@@ -0,0 +1,16 @@
+export interface ITSValidator {
+    amount: number;
+    unit?: string;
+    min?: number;
+    max?: number;
+    balance?: number;
+}
+export declare class TSValidator {
+    options: ITSValidator;
+    constructor(options?: any);
+    static compareProperties(source: Record<string, unknown>, target: Record<string, unknown>): Record<string, unknown>[];
+    compare(prefix?: string): Array<any>;
+    compareOption(option: string, compare: (o: number, c: number) => boolean): any;
+    static condition(value: any, criteria?: any): boolean;
+    static message(option: string): string;
+}

package/utils/TSValidator.js

@@ -0,0 +1,74 @@
+"use strict";
+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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TSValidator = void 0;
+var TSObject_1 = require("./TSObject");
+var TSValidator = /** @class */ (function () {
+    function TSValidator(options) {
+        if (options === void 0) { options = {}; }
+        this.options = { amount: 0 };
+        if (options) {
+            this.options = __assign(__assign({}, this.options), options);
+        }
+    }
+    TSValidator.compareProperties = function (source, target) {
+        var validations = [];
+        TSObject_1.TSObject.forOwn(source, function (v, k) {
+            var _a;
+            if (!(k in target)) {
+                validations.push((_a = { message: TSValidator.message(String(k)) + 'IsMissed' }, _a[k] = v, _a));
+            }
+            else if (target[String(k)] !== v) {
+                validations.push({ message: TSValidator.message(String(k)) + 'NotMet', property: k, source: v, target: target[String(k)] });
+            }
+        });
+        return validations;
+    };
+    TSValidator.prototype.compare = function (prefix) {
+        if (prefix === void 0) { prefix = ''; }
+        return [
+            this.compareOption('amount', function (o) { return o > 0; }),
+            this.compareOption('balance', function (o, c) { return c <= o; }),
+            this.compareOption('min', function (o, c) { return c >= o; }),
+            this.compareOption('max', function (o, c) { return c <= o; })
+        ].filter(function (v) {
+            if (v) {
+                v.message = prefix + v.message;
+            }
+            return v;
+        });
+    };
+    TSValidator.prototype.compareOption = function (option, compare) {
+        var _a;
+        var opt = this.options;
+        var amount = (_a = this.options.amount) !== null && _a !== void 0 ? _a : 0;
+        if (typeof opt[option] !== 'undefined' && !compare(opt[option], amount)) {
+            return __assign({ message: "".concat(TSValidator.message(option), "VsAmountNotMet") }, this.options);
+        }
+        return false;
+    };
+    TSValidator.condition = function (value, criteria) {
+        if (value === undefined || value === null) {
+            return true;
+        }
+        if (criteria === undefined || criteria === null) {
+            return Boolean(value);
+        }
+        return value == criteria;
+    };
+    TSValidator.message = function (option) {
+        return option.charAt(0).toUpperCase() + option.slice(1);
+    };
+    return TSValidator;
+}());
+exports.TSValidator = TSValidator;

package/utils/TSWorker.d.ts

@@ -0,0 +1,3 @@
+export declare class TSWorker {
+    static create(WorkerFunction: new () => Worker): ((params: unknown) => Promise<unknown>) | undefined;
+}

package/utils/TSWorker.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TSWorker = void 0;
+var TSWorker = /** @class */ (function () {
+    function TSWorker() {
+    }
+    TSWorker.create = function (WorkerFunction) {
+        if ('Worker' in window) {
+            var worker_1 = new WorkerFunction();
+            var lastRequestId_1 = 0;
+            var pendingPromises_1 = new Map();
+            worker_1.onmessage = function (event) {
+                var _a = event.data, id = _a.id, result = _a.result;
+                if (pendingPromises_1.has(id)) {
+                    var resolve = pendingPromises_1.get(id);
+                    resolve(result);
+                    pendingPromises_1.delete(id);
+                }
+            };
+            return function (params) {
+                var requestId = ++lastRequestId_1;
+                var promise = new Promise(function (resolve) {
+                    pendingPromises_1.set(requestId, resolve);
+                    worker_1.postMessage({ id: requestId, params: params });
+                });
+                return promise;
+            };
+        }
+    };
+    return TSWorker;
+}());
+exports.TSWorker = TSWorker;

package/utils/diacritics-removal-map.d.ts

@@ -0,0 +1,5 @@
+export interface DiacriticsRemovalRule {
+    base: string;
+    letters: RegExp;
+}
+export declare const DIACRITICS_REMOVAL_MAP: DiacriticsRemovalRule[];