@serwist/utils 10.0.0-preview.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018-2023 Google LLC, 2019-2023 ShadowWalker w@weiw.io https://weiw.io, 2020-2023 Anthony Fu <https://github.com/antfu>, 2023-PRESENT Serwist
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.js

@@ -0,0 +1,33 @@
+const nonNullable = (value)=>value !== null && value !== undefined;
+
+const parallel = async (limit, array, func)=>{
+    const work = array.map((item, index)=>({
+            index,
+            item
+        }));
+    const processor = async (res)=>{
+        const results = [];
+        while(true){
+            const next = work.pop();
+            if (!next) {
+                return res(results);
+            }
+            const result = await func(next.item);
+            results.push({
+                result: result,
+                index: next.index
+            });
+        }
+    };
+    const queues = Array.from({
+        length: limit
+    }, ()=>new Promise(processor));
+    const results = (await Promise.all(queues)).flat().sort((a, b)=>a.index < b.index ? -1 : 1).map((res)=>res.result);
+    return results;
+};
+
+const toUnix = (p)=>{
+    return p.replace(/\\/g, "/").replace(/(?<!^)\/+/g, "/");
+};
+
+export { nonNullable, parallel, toUnix };

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@serwist/utils",
+  "version": "10.0.0-preview.1",
+  "type": "module",
+  "description": "This module contains internal utilities used by Serwist packages.",
+  "files": [
+    "src"
+  ],
+  "keywords": [
+    "serwist",
+    "serwistjs",
+    "service worker",
+    "sw"
+  ],
+  "author": "Serwist <ducanh2912.rusty@gmail.com> (https://serwist.pages.dev/)",
+  "license": "MIT",
+  "repository": "https://github.com/serwist/serwist",
+  "bugs": "https://github.com/serwist/serwist/issues",
+  "homepage": "https://serwist.pages.dev",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "devDependencies": {
+    "rollup": "4.34.8",
+    "typescript": "5.7.3",
+    "@serwist/configs": "10.0.0-preview.1"
+  },
+  "scripts": {
+    "build": "rimraf dist && NODE_ENV=production rollup --config rollup.config.js",
+    "dev": "rollup --config rollup.config.js --watch",
+    "lint": "biome lint ./src",
+    "typecheck": "tsc"
+  }
+}

package/src/index.ts

@@ -0,0 +1,7 @@
+import { nonNullable } from "./nonNullable.js";
+import { parallel } from "./parallel.js";
+import { toUnix } from "./toUnix.js";
+
+export { nonNullable, parallel, toUnix };
+
+export type * from "./types.js";

package/src/nonNullable.ts

@@ -0,0 +1 @@
+export const nonNullable = <T>(value: T): value is NonNullable<T> => value !== null && value !== undefined;

package/src/parallel.ts

@@ -0,0 +1,42 @@
+// Source code: https://github.com/rayepps/radash/blob/03dd3152f560414e933cedcd3bda3c6db3e8306b/src/async.ts#L112-L147
+// License: MIT
+// Author: rayepps
+interface ItemResult<K> {
+  index: number;
+  result: K;
+}
+
+/**
+ * Executes many async functions in parallel. Returns the
+ * results from all functions as an array. Does not handle
+ * any error.
+ */
+export const parallel = async <T, K>(limit: number, array: readonly T[], func: (item: T) => Promise<K>): Promise<K[]> => {
+  const work = array.map((item, index) => ({
+    index,
+    item,
+  }));
+  // Process array items
+  const processor = async (res: (value: ItemResult<K>[]) => void) => {
+    const results: ItemResult<K>[] = [];
+    while (true) {
+      const next = work.pop();
+      if (!next) {
+        return res(results);
+      }
+      const result = await func(next.item);
+      results.push({
+        result: result,
+        index: next.index,
+      });
+    }
+  };
+  // Create queues
+  const queues = Array.from({ length: limit }, () => new Promise(processor));
+  // Wait for all queues to complete
+  const results = (await Promise.all(queues))
+    .flat()
+    .sort((a, b) => (a.index < b.index ? -1 : 1))
+    .map((res) => res.result);
+  return results;
+};

package/src/toUnix.ts

@@ -0,0 +1,3 @@
+export const toUnix = (p: string) => {
+  return p.replace(/\\/g, "/").replace(/(?<!^)\/+/g, "/");
+};

package/src/types.ts

@@ -0,0 +1,55 @@
+/**
+ * Makes certain fields in a object type required
+ *
+ * @example
+ *     interface A {
+ *         a?: string;
+ *         b?: string;
+ *         c?: string;
+ *     }
+ *     type B = RequiredFields<A, "b" | "c">;
+ *     const b: B = {
+ *         b: "hehe",
+ *         c: "hehe",
+ *     }; //valid
+ *     const b: B = { a: "hehe" }; //invalid
+ *     const c: B = { a: "hehe", b: "hehe" }; //invalid
+ */
+export type Require<T, U extends keyof T> = T & Required<Pick<T, U>>;
+
+/**
+ * Makes certain fields in a object type optional
+ *
+ * @example
+ *     interface A {
+ *         a: string;
+ *         b: string;
+ *         c: string;
+ *     }
+ *     type B = Optional<A, "b" | "c">;
+ *     const b: B = { a: "hehe" }; //valid
+ *     const b: B = {}; //invalid
+ */
+export type Optional<T, U extends keyof T> = Omit<T, U> & Partial<Pick<T, U>>;
+
+/**
+ * Makes an object type's hover overlay more readable
+ *
+ * @example
+ *
+ * interface A {
+ *   b: string;
+ *   c: boolean;
+ * }
+ *
+ * interface B {
+ *   c: number;
+ * }
+ *
+ * type D = A | B; // Displayed as is written
+ *
+ * type C = Prettify<A | B>; // { b: string; c: boolean; } | { c: number; }
+ */
+export type Prettify<T> = {
+  [K in keyof T]: T[K];
+} & {};