@ezez/utils 1.6.0 → 1.8.0

package/src/later.spec.ts

@@ -0,0 +1,33 @@
+import { later } from "./later.js";
+
+describe("later", () => {
+    it("creates values synchronously", async () => {
+        const l = later();
+        l.must.have.property("promise");
+        l.must.have.property("resolve");
+        l.must.have.property("reject");
+    });
+
+    it("creates expected types", async () => {
+        const l = later();
+
+        l.promise.must.be.instanceof(Promise);
+        l.resolve.must.be.a.function();
+        l.reject.must.be.a.function();
+    });
+
+    it("resolves promise", async () => {
+        const l = later();
+        l.resolve(42);
+
+        const r = await l.promise;
+        r.must.equal(42);
+    });
+
+    it("rejects promise", async () => {
+        const l = later();
+        l.reject(new Error("foo"));
+
+        await l.promise.must.reject.with.error("foo");
+    });
+});

package/src/later.ts

@@ -0,0 +1,42 @@
+type Later<T> = {
+    /**
+     * The promise that will be resolved or rejected later.
+     */
+    promise: Promise<T>;
+    /**
+     * Promise resolver function
+     */
+    resolve: (result: T) => void;
+    /**
+     * Promise rejecter function
+     */
+    reject: (reason: Error) => void;
+};
+
+/**
+ * Creates a promise that can be resolved or rejected from outside the promise.
+ *
+ * @example In this example someFunction will return a promise that's typed to return number and myDependency will
+ * resolve it when it's ready.
+ * ```
+ * function someFunction() {
+ *   const l = later<number>();
+ *   myDependency.load(l);
+ *   return l.promise;
+ * }
+ * ```
+ */
+const later = <T>(): Later<T> => {
+    // @ts-expect-error This is expected - we fill the values later (no pun intended)
+    const res: Later<T> = {};
+
+    res.promise = new Promise((resolve, reject) => {
+        res.resolve = resolve;
+        res.reject = reject;
+    });
+
+    return res;
+};
+
+export type { Later };
+export { later };

package/src/mapAsync.ts

@@ -24,7 +24,7 @@ const mapAsync = async <T, Y>(
     const l = context.length;
 
     for (let i = 0; i < l; i++) {
-        const item = context[i];
+        const item = context[i]!;
         // eslint-disable-next-line callback-return
         result.push(callback(item, i, context));
         if (Date.now() - lastWaitMoment >= pauseEvery) {

package/src/mostFrequent.ts

@@ -19,6 +19,7 @@ const mostFrequent = <T>(array: T[]): T => {
         }
     });
 
+    // @ts-expect-error - idk if there is a good workaround for this with `noUncheckedIndexedAccess`
     return topValue;
 };
 

package/src/pull.ts

@@ -6,7 +6,7 @@
 const pull = <T>(array: T[], ...valuesToPull: T[]): T[] => {
     const len = array.length;
     for (let i = len - 1; i >= 0; i--) {
-        if (valuesToPull.includes(array[i])) {
+        if (valuesToPull.includes(array[i]!)) {
             array.splice(i, 1);
         }
     }

package/src/remove.ts

@@ -12,9 +12,9 @@ const remove = <T>(array: T[], fn: (elem: T, num: number, list: T[]) => boolean)
     const removedValues = [];
 
     for (let counter = 0; counter < len; counter++) {
-        if (fn(array[counter], counter, array)) {
+        if (fn(array[counter]!, counter, array)) {
             idsToRemove.push(counter - idsToRemove.length);
-            removedValues.push(array[counter]);
+            removedValues.push(array[counter]!);
         }
     }
 

package/src/replace.ts

@@ -11,7 +11,7 @@ import { escapeRegExp } from "./escapeRegExp.js";
 const replace = (source: string, replaceMap: Record<string, string>) => {
     /* eslint-enable max-len */
     const regex = new RegExp(Object.keys(replaceMap).map(escapeRegExp).join("|"), "g");
-    return source.replace(regex, (matched) => replaceMap[matched]);
+    return source.replace(regex, (matched) => replaceMap[matched]!);
 };
 
 export {

package/src/safe.spec.ts

@@ -40,7 +40,6 @@ describe("safe", () => {
     });
 
     it("doesn't 'work' with promises", () => {
-        // eslint-disable-next-line @typescript-eslint/require-await
         const result = safe(async () => {
             throw new Error("Boo!!!");
         });

package/src/set.ts

@@ -39,7 +39,7 @@ const set = (source: Source, path: string | string[], value: unknown): Source |
     let current: Source | unknown = result;
     for (let i = 0; i < len; i++) {
         const isLast = i === len - 1;
-        const key = pathParts[i];
+        const key = pathParts[i]!;
         if (isLast) {
             (current as Source)[key] = value;
             return result;

package/src/setImmutable.ts

@@ -80,7 +80,7 @@ const setImmutable = (source: Source, path: Path, value: unknown): Source | unkn
     let current: Source | unknown = result;
     for (let i = 0; i < len; i++) {
         const isLast = i === len - 1;
-        const key = pathParts[i];
+        const key = pathParts[i]!;
         if (isLast) {
             (current as Source)[key] = value;
             return result;

package/src/throttle.ts

@@ -61,7 +61,7 @@ const throttle = <RT, F extends (...args: any[]) => RT>( // eslint-disable-line
         throw new TypeError("`time` must be an array with at least one number.");
     }
 
-    const finalTime = typeof time === "number" ? time : time[time.length - 1];
+    const finalTime = typeof time === "number" ? time : time[time.length - 1]!;
 
     let lastRun = 0,
         timeoutId: ReturnType<typeof setTimeout> | null = null,