svelte-ag 1.0.12 → 1.0.13

package/dist/lib/api/query/query.svelte.js

@@ -1,275 +1,157 @@
-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 __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _Query_TIMEOUT, _Query_path, _Query_method, _Query_input, _Query_inputString, _Query_cacheKey, _Query_requestor, _Query_cache, _Query_pendingRequest, _Query_status, _Query_data, _Query_errorData, _Requestor_batchDelay, _Requestor_path, _Requestor_method, _Requestor_request, _Requestor_canBatch, _Requestor_batchInput, _Requestor_unBatchOutput, _Requestor_limiter, _Requestor_cache, _Requestor_batchQueue, _Requestor_batchTimers;
 import { stringify } from 'devalue';
 import Bottleneck from 'bottleneck';
 import * as env from '$env/static/public';
 import { sleep } from 'radash';
 import { cacheKey } from './utils.svelte.js';
-var Query = /** @class */ (function () {
+export class Query {
+    // -------- Constants --------
+    #TIMEOUT = 1000 * 60 * 5; // 5 minutes
+    // -------- Set in constructor --------
+    #path;
+    #method;
+    #input;
+    #inputString;
+    #cacheKey;
+    #requestor;
+    #cache;
+    // -------- State --------
+    // Requesting state
+    #pendingRequest = null;
+    // Response state
+    #status = $state('idle');
+    #data = $state(null);
+    #errorData = $state(null);
     // -------- Functions --------
-    function Query(_a) {
-        var path = _a.path, method = _a.method, input = _a.input, requestor = _a.requestor, cache = _a.cache;
-        // -------- Constants --------
-        _Query_TIMEOUT.set(this, 1000 * 60 * 5); // 5 minutes
-        // -------- Set in constructor --------
-        _Query_path.set(this, void 0);
-        _Query_method.set(this, void 0);
-        _Query_input.set(this, void 0);
-        _Query_inputString.set(this, void 0);
-        _Query_cacheKey.set(this, void 0);
-        _Query_requestor.set(this, void 0);
-        _Query_cache.set(this, void 0);
-        // -------- State --------
-        // Requesting state
-        _Query_pendingRequest.set(this, null);
-        // Response state
-        _Query_status.set(this, $state('idle'));
-        _Query_data.set(this, $state(null));
-        _Query_errorData.set(this, $state(null));
-        __classPrivateFieldSet(this, _Query_requestor, requestor, "f");
-        __classPrivateFieldSet(this, _Query_cache, cache, "f");
-        __classPrivateFieldSet(this, _Query_path, path, "f");
-        __classPrivateFieldSet(this, _Query_method, method, "f");
+    constructor({ path, method, input, requestor, cache }) {
+        this.#requestor = requestor;
+        this.#cache = cache;
+        this.#path = path;
+        this.#method = method;
         // if (this.#cachekey) this.#cache.deregister(this.#cachekey);
-        __classPrivateFieldSet(this, _Query_input, input, "f");
-        __classPrivateFieldSet(this, _Query_inputString, stringify(input), "f");
-        __classPrivateFieldSet(this, _Query_cacheKey, cacheKey(path, method, input), "f");
-        __classPrivateFieldGet(this, _Query_cache, "f").register(__classPrivateFieldGet(this, _Query_cacheKey, "f"), { timeout: __classPrivateFieldGet(this, _Query_TIMEOUT, "f") });
+        this.#input = input;
+        this.#inputString = stringify(input);
+        this.#cacheKey = cacheKey(path, method, input);
+        this.#cache.register(this.#cacheKey, { timeout: this.#TIMEOUT });
     }
-    Query.prototype.request = function () {
-        return __awaiter(this, void 0, Promise, function () {
-            var cachedValue, res, body, body;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        cachedValue = __classPrivateFieldGet(this, _Query_cache, "f").get(__classPrivateFieldGet(this, _Query_cacheKey, "f"));
-                        if (cachedValue !== null) {
-                            return [2 /*return*/, cachedValue];
-                        }
-                        __classPrivateFieldSet(this, _Query_status, 'loading', "f");
-                        if (__classPrivateFieldGet(this, _Query_pendingRequest, "f") === null) {
-                            __classPrivateFieldSet(this, _Query_pendingRequest, __classPrivateFieldGet(this, _Query_requestor, "f").request(__classPrivateFieldGet(this, _Query_input, "f")), "f");
-                        }
-                        return [4 /*yield*/, __classPrivateFieldGet(this, _Query_pendingRequest, "f")];
-                    case 1:
-                        res = _a.sent();
-                        __classPrivateFieldSet(this, _Query_pendingRequest, null, "f");
-                        __classPrivateFieldGet(this, _Query_cache, "f").set(__classPrivateFieldGet(this, _Query_cacheKey, "f"), res);
-                        if (!(res.ok === false)) return [3 /*break*/, 3];
-                        return [4 /*yield*/, res.json()];
-                    case 2:
-                        body = _a.sent();
-                        __classPrivateFieldSet(this, _Query_status, 'error', "f");
-                        // @ts-expect-error Generics not working for some reason
-                        __classPrivateFieldSet(this, _Query_errorData, body, "f");
-                        return [2 /*return*/, res];
-                    case 3: return [4 /*yield*/, res.json()];
-                    case 4:
-                        body = _a.sent();
-                        __classPrivateFieldSet(this, _Query_status, 'success', "f");
-                        __classPrivateFieldSet(this, _Query_data, body, "f");
-                        return [2 /*return*/, res];
-                }
-            });
-        });
-    };
-    Object.defineProperty(Query.prototype, "cacheKey", {
-        get: function () {
-            return __classPrivateFieldGet(this, _Query_cacheKey, "f");
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Query.prototype, "isCached", {
-        get: function () {
-            return __classPrivateFieldGet(this, _Query_cache, "f").has(__classPrivateFieldGet(this, _Query_cacheKey, "f"));
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Query.prototype.resetCache = function () {
+    async request() {
+        const cachedValue = this.#cache.get(this.#cacheKey);
+        if (cachedValue !== null) {
+            return cachedValue;
+        }
+        this.#status = 'loading';
+        if (this.#pendingRequest === null) {
+            this.#pendingRequest = this.#requestor.request(this.#input);
+        }
+        const res = await this.#pendingRequest;
+        this.#pendingRequest = null;
+        this.#cache.set(this.#cacheKey, res);
+        if (res.ok === false) {
+            const body = await res.json();
+            this.#status = 'error';
+            // @ts-expect-error Generics not working for some reason
+            this.#errorData = body;
+            return res;
+        }
+        else {
+            const body = await res.json();
+            this.#status = 'success';
+            this.#data = body;
+            return res;
+        }
+    }
+    get cacheKey() {
+        return this.#cacheKey;
+    }
+    get isCached() {
+        return this.#cache.has(this.#cacheKey);
+    }
+    resetCache() {
         if (this.isCached) {
-            __classPrivateFieldGet(this, _Query_cache, "f").reset(__classPrivateFieldGet(this, _Query_cacheKey, "f"));
+            this.#cache.reset(this.#cacheKey);
         }
-    };
-    Object.defineProperty(Query.prototype, "status", {
-        get: function () {
-            return __classPrivateFieldGet(this, _Query_status, "f");
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Query.prototype, "data", {
-        get: function () {
-            return __classPrivateFieldGet(this, _Query_data, "f");
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Query.prototype, "errorData", {
-        get: function () {
-            return __classPrivateFieldGet(this, _Query_errorData, "f");
-        },
-        enumerable: false,
-        configurable: true
-    });
-    return Query;
-}());
-export { Query };
-_Query_TIMEOUT = new WeakMap(), _Query_path = new WeakMap(), _Query_method = new WeakMap(), _Query_input = new WeakMap(), _Query_inputString = new WeakMap(), _Query_cacheKey = new WeakMap(), _Query_requestor = new WeakMap(), _Query_cache = new WeakMap(), _Query_pendingRequest = new WeakMap(), _Query_status = new WeakMap(), _Query_data = new WeakMap(), _Query_errorData = new WeakMap();
-var Requestor = /** @class */ (function () {
-    function Requestor(path, method, request, cache, batchDetails) {
-        // -------- Constants --------
-        _Requestor_batchDelay.set(this, 100);
-        // -------- Set in constructor --------
-        _Requestor_path.set(this, void 0);
-        _Requestor_method.set(this, void 0);
-        _Requestor_request.set(this, void 0);
-        _Requestor_canBatch.set(this, void 0);
-        _Requestor_batchInput.set(this, void 0);
-        _Requestor_unBatchOutput.set(this, void 0);
-        _Requestor_limiter.set(this, void 0);
-        _Requestor_cache.set(this, void 0);
-        // -------- State --------
-        _Requestor_batchQueue.set(this, {});
-        _Requestor_batchTimers.set(this, {});
-        __classPrivateFieldSet(this, _Requestor_path, path, "f");
-        __classPrivateFieldSet(this, _Requestor_method, method, "f");
-        __classPrivateFieldSet(this, _Requestor_request, request, "f");
-        __classPrivateFieldSet(this, _Requestor_limiter, new Bottleneck({
+    }
+    get status() {
+        return this.#status;
+    }
+    get data() {
+        return this.#data;
+    }
+    get errorData() {
+        return this.#errorData;
+    }
+}
+export class Requestor {
+    // -------- Constants --------
+    #batchDelay = 100;
+    // -------- Set in constructor --------
+    #path;
+    #method;
+    #request;
+    #canBatch;
+    #batchInput;
+    #unBatchOutput;
+    #limiter;
+    #cache;
+    // -------- State --------
+    #batchQueue = {};
+    #batchTimers = {};
+    constructor(path, method, request, cache, batchDetails) {
+        this.#path = path;
+        this.#method = method;
+        this.#request = request;
+        this.#limiter = new Bottleneck({
             maxConcurrent: 5,
             minTime: 100
-        }), "f");
-        __classPrivateFieldSet(this, _Requestor_cache, cache, "f");
+        });
+        this.#cache = cache;
         // TODO
-        __classPrivateFieldSet(this, _Requestor_canBatch, batchDetails ? batchDetails.canBatch : function () { return false; }, "f");
-        __classPrivateFieldSet(this, _Requestor_batchInput, batchDetails ? batchDetails.batchInput : function (inputs) { return inputs; }, "f");
-        __classPrivateFieldSet(this, _Requestor_unBatchOutput, batchDetails ? batchDetails.unBatchOutput : function (inputs, output) { return [output]; }, "f");
+        this.#canBatch = batchDetails ? batchDetails.canBatch : () => false;
+        this.#batchInput = batchDetails ? batchDetails.batchInput : (inputs) => inputs;
+        this.#unBatchOutput = batchDetails ? batchDetails.unBatchOutput : (inputs, output) => [output];
     }
     // Makes the actual call to the api
-    Requestor.prototype.fetch = function (input) {
-        return __awaiter(this, void 0, Promise, function () {
-            var _this = this;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (!('PUBLIC_ENVIRONMENT' in env && env.PUBLIC_ENVIRONMENT === 'development')) return [3 /*break*/, 2];
-                        return [4 /*yield*/, sleep(1000)];
-                    case 1:
-                        _a.sent();
-                        _a.label = 2;
-                    case 2: return [4 /*yield*/, __classPrivateFieldGet(this, _Requestor_limiter, "f").schedule(function () { return __classPrivateFieldGet(_this, _Requestor_request, "f").call(_this, __classPrivateFieldGet(_this, _Requestor_path, "f"), __classPrivateFieldGet(_this, _Requestor_method, "f"), input); })];
-                    case 3: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
-    };
+    async fetch(input) {
+        if ('PUBLIC_ENVIRONMENT' in env && env.PUBLIC_ENVIRONMENT === 'development') {
+            await sleep(1000);
+        }
+        return await this.#limiter.schedule(() => this.#request(this.#path, this.#method, input));
+    }
     /**
      * Empties the batch queue for the id by combining the inputs.
      * Then it separates the outputs and resolves each of the promises
      */
-    Requestor.prototype.flushBatchQueue = function (batchId) {
-        return __awaiter(this, void 0, Promise, function () {
-            var queue, batchedInput, res, output;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        queue = __classPrivateFieldGet(this, _Requestor_batchQueue, "f")[batchId].splice(0);
-                        batchedInput = __classPrivateFieldGet(this, _Requestor_batchInput, "f").call(this, queue.map(function (q) { return q.input; }));
-                        return [4 /*yield*/, this.fetch(batchedInput)];
-                    case 1:
-                        res = _a.sent();
-                        return [4 /*yield*/, __classPrivateFieldGet(this, _Requestor_unBatchOutput, "f").call(this, queue.map(function (q) { return q.input; }), res)];
-                    case 2:
-                        output = _a.sent();
-                        queue.forEach(function (_a, i) {
-                            var resolve = _a.resolve, reject = _a.reject;
-                            if (output[i].ok === true) {
-                                resolve(output[i]);
-                            }
-                            else {
-                                reject(output[i]);
-                            }
-                        });
-                        return [2 /*return*/];
-                }
-            });
+    async flushBatchQueue(batchId) {
+        const queue = this.#batchQueue[batchId].splice(0);
+        const batchedInput = this.#batchInput(queue.map((q) => q.input));
+        const res = await this.fetch(batchedInput);
+        const output = await this.#unBatchOutput(queue.map((q) => q.input), res);
+        queue.forEach(({ resolve, reject }, i) => {
+            if (output[i].ok === true) {
+                resolve(output[i]);
+            }
+            else {
+                reject(output[i]);
+            }
         });
-    };
+    }
     // Performs a request for a given input. Batches it if possible
-    Requestor.prototype.request = function (input) {
-        return __awaiter(this, void 0, Promise, function () {
-            var batchId;
-            var _this = this;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        batchId = __classPrivateFieldGet(this, _Requestor_canBatch, "f").call(this, input);
-                        if (!(batchId !== false)) return [3 /*break*/, 1];
-                        return [2 /*return*/, new Promise(function (resolve, reject) {
-                                if (!__classPrivateFieldGet(_this, _Requestor_batchQueue, "f")[batchId])
-                                    __classPrivateFieldGet(_this, _Requestor_batchQueue, "f")[batchId] = [];
-                                __classPrivateFieldGet(_this, _Requestor_batchQueue, "f")[batchId].push({ input: input, resolve: resolve, reject: reject });
-                                if (!__classPrivateFieldGet(_this, _Requestor_batchTimers, "f")[batchId]) {
-                                    __classPrivateFieldGet(_this, _Requestor_batchTimers, "f")[batchId] = setTimeout(function () {
-                                        _this.flushBatchQueue(batchId);
-                                        delete __classPrivateFieldGet(_this, _Requestor_batchTimers, "f")[batchId];
-                                    }, __classPrivateFieldGet(_this, _Requestor_batchDelay, "f"));
-                                }
-                            })];
-                    case 1: return [4 /*yield*/, this.fetch(input)];
-                    case 2: return [2 /*return*/, _a.sent()];
+    async request(input) {
+        const batchId = this.#canBatch(input);
+        if (batchId !== false) {
+            return new Promise((resolve, reject) => {
+                if (!this.#batchQueue[batchId])
+                    this.#batchQueue[batchId] = [];
+                this.#batchQueue[batchId].push({ input, resolve, reject });
+                if (!this.#batchTimers[batchId]) {
+                    this.#batchTimers[batchId] = setTimeout(() => {
+                        this.flushBatchQueue(batchId);
+                        delete this.#batchTimers[batchId];
+                    }, this.#batchDelay);
                 }
             });
-        });
-    };
-    return Requestor;
-}());
-export { Requestor };
-_Requestor_batchDelay = new WeakMap(), _Requestor_path = new WeakMap(), _Requestor_method = new WeakMap(), _Requestor_request = new WeakMap(), _Requestor_canBatch = new WeakMap(), _Requestor_batchInput = new WeakMap(), _Requestor_unBatchOutput = new WeakMap(), _Requestor_limiter = new WeakMap(), _Requestor_cache = new WeakMap(), _Requestor_batchQueue = new WeakMap(), _Requestor_batchTimers = new WeakMap();
+        }
+        else {
+            return await this.fetch(input);
+        }
+    }
+}

package/dist/lib/api/query/utils.svelte.d.ts

@@ -1,2 +1,3 @@
 export declare function batchQueryKey(path: string, method: string): string;
 export declare function cacheKey(path: string, method: string, input: any): string;
+//# sourceMappingURL=utils.svelte.d.ts.map

package/dist/lib/api/query/utils.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.svelte.d.ts","sourceRoot":"","sources":["../../../../src/lib/api/query/utils.svelte.ts"],"names":[],"mappings":"AAEA,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,UAEzD;AAED,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,UAEhE"}

package/dist/lib/api/query/utils.svelte.js

@@ -1,7 +1,7 @@
 import { stringify } from 'devalue';
 export function batchQueryKey(path, method) {
-    return "".concat(path, "_").concat(method);
+    return `${path}_${method}`;
 }
 export function cacheKey(path, method, input) {
-    return "".concat(path, "_").concat(method, "_").concat(stringify(input));
+    return `${path}_${method}_${stringify(input)}`;
 }

package/dist/lib/bits/internal/arrays.d.ts

@@ -87,9 +87,10 @@ export declare function backward<T>(array: T[], index: number, decrement: number
  * @param currentMatch - The currently selected/matched item, if any
  * @returns The next matching value that should be selected, or undefined if no match is found
  */
-export declare function getNextMatch(values: string[], search: string, currentMatch?: string): string;
+export declare function getNextMatch(values: string[], search: string, currentMatch?: string): string | undefined;
 /**
  * Wraps an array around itself at a given start index
  * Example: `wrapArray(['a', 'b', 'c', 'd'], 2) === ['c', 'd', 'a', 'b']`
  */
 export declare function wrapArray<T>(array: T[], startIndex: number): T[];
+//# sourceMappingURL=arrays.d.ts.map

package/dist/lib/bits/internal/arrays.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arrays.d.ts","sourceRoot":"","sources":["../../../../src/lib/bits/internal/arrays.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,wBAAgB,cAAc,CAAC,CAAC,SAAS,KAAK,CAAC,OAAO,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,GAAG,OAAO,CAMlF;AAiDD;;;;;;;;;;GAUG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,EAAE,IAAI,EAAE,MAAM,GAAG,CAAC,EAAE,EAAE,CAUtD;AAED;;;;;GAKG;AAEH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,OAAO,EAAE,WAEzD;AAED;;;;;GAKG;AACH;;;;;;GAMG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,UAAO,GAAG,CAAC,GAAG,SAAS,CAW7E;AAED;;;;;;GAMG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,UAAO,GAAG,CAAC,GAAG,SAAS,CAW7E;AAED;;;;;;;;;GASG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,IAAI,UAAO,GAAG,CAAC,GAAG,SAAS,CAgBnG;AAED;;;;;;;;;GASG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,IAAI,UAAO,GAAG,CAAC,GAAG,SAAS,CAgBpG;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,MAAM,sBA8DnF;AAED;;;GAGG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,UAAU,EAAE,MAAM,GACqB,CAAC,EAAE,CAClF"}

package/dist/lib/bits/internal/arrays.js

@@ -5,7 +5,7 @@ export function arraysAreEqual(arr1, arr2) {
     if (arr1.length !== arr2.length) {
         return false;
     }
-    return arr1.every(function (value, index) { return isEqual(value, arr2[index]); });
+    return arr1.every((value, index) => isEqual(value, arr2[index]));
 }
 /**
  * A utility function that compares two values for equality.
@@ -29,13 +29,12 @@ function isDeepEqual(a, b) {
     if (typeof a !== 'object' || typeof b !== 'object' || a === null || b === null) {
         return false;
     }
-    var aKeys = Object.keys(a);
-    var bKeys = Object.keys(b);
+    const aKeys = Object.keys(a);
+    const bKeys = Object.keys(b);
     if (aKeys.length !== bKeys.length) {
         return false;
     }
-    for (var _i = 0, aKeys_1 = aKeys; _i < aKeys_1.length; _i++) {
-        var key = aKeys_1[_i];
+    for (const key of aKeys) {
         if (!bKeys.includes(key)) {
             return false;
         }
@@ -60,8 +59,8 @@ export function chunk(arr, size) {
     if (size <= 0) {
         return [];
     }
-    var result = [];
-    for (var i = 0; i < arr.length; i += size) {
+    const result = [];
+    for (let i = 0; i < arr.length; i += size) {
         result.push(arr.slice(i, i + size));
     }
     return result;
@@ -88,8 +87,7 @@ export function isValidIndex(index, arr) {
  * @param index the index of the current element.
  * @param loop loop to the beginning of the array if the next index is out of bounds?
  */
-export function next(array, index, loop) {
-    if (loop === void 0) { loop = true; }
+export function next(array, index, loop = true) {
     if (array.length === 0 || index < 0 || index >= array.length) {
         return undefined;
     }
@@ -108,8 +106,7 @@ export function next(array, index, loop) {
  * @param index the index of the current element.
  * @param loop loop to the end of the array if the previous index is out of bounds?
  */
-export function prev(array, index, loop) {
-    if (loop === void 0) { loop = true; }
+export function prev(array, index, loop = true) {
     if (array.length === 0 || index < 0 || index >= array.length) {
         return undefined;
     }
@@ -131,12 +128,11 @@ export function prev(array, index, loop) {
  * @param increment the number of elements to move forward (can be negative).
  * @param loop loop around the array if the target index is out of bounds?
  */
-export function forward(array, index, increment, loop) {
-    if (loop === void 0) { loop = true; }
+export function forward(array, index, increment, loop = true) {
     if (array.length === 0 || index < 0 || index >= array.length) {
         return undefined;
     }
-    var targetIndex = index + increment;
+    let targetIndex = index + increment;
     if (loop) {
         // Ensure positive modulus
         targetIndex = ((targetIndex % array.length) + array.length) % array.length;
@@ -157,12 +153,11 @@ export function forward(array, index, increment, loop) {
  * @param decrement the number of elements to move backward (can be negative).
  * @param loop loop around the array if the target index is out of bounds?
  */
-export function backward(array, index, decrement, loop) {
-    if (loop === void 0) { loop = true; }
+export function backward(array, index, decrement, loop = true) {
     if (array.length === 0 || index < 0 || index >= array.length) {
         return undefined;
     }
-    var targetIndex = index - decrement;
+    let targetIndex = index - decrement;
     if (loop) {
         // Ensure positive modulus
         targetIndex = ((targetIndex % array.length) + array.length) % array.length;
@@ -196,54 +191,54 @@ export function backward(array, index, decrement, loop) {
  * @returns The next matching value that should be selected, or undefined if no match is found
  */
 export function getNextMatch(values, search, currentMatch) {
-    var lowerSearch = search.toLowerCase();
+    const lowerSearch = search.toLowerCase();
     if (lowerSearch.endsWith(' ')) {
-        var searchWithoutSpace_1 = lowerSearch.slice(0, -1);
-        var matchesWithoutSpace = values.filter(function (value) { return value.toLowerCase().startsWith(searchWithoutSpace_1); });
+        const searchWithoutSpace = lowerSearch.slice(0, -1);
+        const matchesWithoutSpace = values.filter((value) => value.toLowerCase().startsWith(searchWithoutSpace));
         /**
          * If there's only one match for the prefix without space, we don't
          * watch to match with space.
          */
         if (matchesWithoutSpace.length <= 1) {
-            return getNextMatch(values, searchWithoutSpace_1, currentMatch);
+            return getNextMatch(values, searchWithoutSpace, currentMatch);
         }
-        var currentMatchLowercase = currentMatch === null || currentMatch === void 0 ? void 0 : currentMatch.toLowerCase();
+        const currentMatchLowercase = currentMatch?.toLowerCase();
         /**
          * If the current match already starts with the search prefix and has a space afterward,
          * and the user has only typed up to that space, keep the current match until they
          * disambiguate.
          */
         if (currentMatchLowercase &&
-            currentMatchLowercase.startsWith(searchWithoutSpace_1) &&
-            currentMatchLowercase.charAt(searchWithoutSpace_1.length) === ' ' &&
-            search.trim() === searchWithoutSpace_1) {
+            currentMatchLowercase.startsWith(searchWithoutSpace) &&
+            currentMatchLowercase.charAt(searchWithoutSpace.length) === ' ' &&
+            search.trim() === searchWithoutSpace) {
             return currentMatch;
         }
         /**
          * With multiple matches, find items that match the full search string with space
          */
-        var spacedMatches = values.filter(function (value) { return value.toLowerCase().startsWith(lowerSearch); });
+        const spacedMatches = values.filter((value) => value.toLowerCase().startsWith(lowerSearch));
         /**
          * If we found matches with the space, use the first one that's not the current match
          */
         if (spacedMatches.length > 0) {
-            var currentMatchIndex_1 = currentMatch ? values.indexOf(currentMatch) : -1;
-            var wrappedMatches = wrapArray(spacedMatches, Math.max(currentMatchIndex_1, 0));
+            const currentMatchIndex = currentMatch ? values.indexOf(currentMatch) : -1;
+            let wrappedMatches = wrapArray(spacedMatches, Math.max(currentMatchIndex, 0));
             // return the first match that is not the current one.
-            var nextMatch_1 = wrappedMatches.find(function (match) { return match !== currentMatch; });
+            const nextMatch = wrappedMatches.find((match) => match !== currentMatch);
             // fallback to current if no other is found.
-            return nextMatch_1 || currentMatch;
+            return nextMatch || currentMatch;
         }
     }
-    var isRepeated = search.length > 1 && Array.from(search).every(function (char) { return char === search[0]; });
-    var normalizedSearch = isRepeated ? search[0] : search;
-    var normalizedLowerSearch = normalizedSearch.toLowerCase();
-    var currentMatchIndex = currentMatch ? values.indexOf(currentMatch) : -1;
-    var wrappedValues = wrapArray(values, Math.max(currentMatchIndex, 0));
-    var excludeCurrentMatch = normalizedSearch.length === 1;
+    const isRepeated = search.length > 1 && Array.from(search).every((char) => char === search[0]);
+    const normalizedSearch = isRepeated ? search[0] : search;
+    const normalizedLowerSearch = normalizedSearch.toLowerCase();
+    const currentMatchIndex = currentMatch ? values.indexOf(currentMatch) : -1;
+    let wrappedValues = wrapArray(values, Math.max(currentMatchIndex, 0));
+    const excludeCurrentMatch = normalizedSearch.length === 1;
     if (excludeCurrentMatch)
-        wrappedValues = wrappedValues.filter(function (v) { return v !== currentMatch; });
-    var nextMatch = wrappedValues.find(function (value) { return value === null || value === void 0 ? void 0 : value.toLowerCase().startsWith(normalizedLowerSearch); });
+        wrappedValues = wrappedValues.filter((v) => v !== currentMatch);
+    const nextMatch = wrappedValues.find((value) => value?.toLowerCase().startsWith(normalizedLowerSearch));
     return nextMatch !== currentMatch ? nextMatch : undefined;
 }
 /**
@@ -251,5 +246,5 @@ export function getNextMatch(values, search, currentMatch) {
  * Example: `wrapArray(['a', 'b', 'c', 'd'], 2) === ['c', 'd', 'a', 'b']`
  */
 export function wrapArray(array, startIndex) {
-    return array.map(function (_, index) { return array[(startIndex + index) % array.length]; });
+    return array.map((_, index) => array[(startIndex + index) % array.length]);
 }

package/dist/lib/bits/internal/arrays.test.d.ts

@@ -1 +1,2 @@
 export {};
+//# sourceMappingURL=arrays.test.d.ts.map

package/dist/lib/bits/internal/arrays.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arrays.test.d.ts","sourceRoot":"","sources":["../../../../src/lib/bits/internal/arrays.test.ts"],"names":[],"mappings":""}