sortism 1.2.0 → 1.3.0

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-export type InternalSortFunction = <T>(arr: T[], func: (v: T) => number, order: "ascending" | "descending") => T[];
-export type ExportSortFunction<T> = (order: "ascending" | "descending", func?: (v: T) => number) => T[];
+export type InternalSortFunction = <T>(arr: T[], func: (v: T) => number, order: "ascending" | "descending") => T[] | Promise<T[]>;
+export type SortFunction<T> = (order: "ascending" | "descending", func?: (v: T) => number) => T[] | Promise<T[]>;
 /**
  * You can use sortism through this function.
  */
@@ -7,33 +7,37 @@ export default function sortism<T = any>(array: T[], func?: (v: T) => number): {
     /**
      * Time: O(n^2)
      */
-    bubble: ExportSortFunction<T>;
+    bubble: SortFunction<T>;
     /**
      * Time: O(n^2)
      */
-    selection: ExportSortFunction<T>;
+    selection: SortFunction<T>;
     /**
      * Time: O(n log n)
      */
-    merge: ExportSortFunction<T>;
+    merge: SortFunction<T>;
     /**
      * Time: O(n log n)
      */
-    quick: ExportSortFunction<T>;
+    quick: SortFunction<T>;
     /**
      * Time: O(n * n!)
      */
-    bogo: ExportSortFunction<T>;
+    bogo: SortFunction<T>;
     /**
      * Time: O(N)
      */
-    stalin: ExportSortFunction<T>;
+    stalin: SortFunction<T>;
     /**
      * Time: O(Infinity)
      */
-    miracle: ExportSortFunction<T>;
+    miracle: SortFunction<T>;
     /**
      * Time: O(N)
      */
-    thanos: ExportSortFunction<T>;
+    thanos: SortFunction<T>;
+    /**
+     * Time: O(max(N, maxValue))
+     */
+    sleep: SortFunction<T>;
 };

package/dist/index.js

@@ -4,6 +4,7 @@ import merge from "./sorts/merge";
 import miracle from "./sorts/miracle";
 import quick from "./sorts/quick";
 import selection from "./sorts/selection";
+import sleep from "./sorts/sleep";
 import stalin from "./sorts/stalin";
 import thanos from "./sorts/thanos";
 /**
@@ -44,5 +45,9 @@ export default function sortism(array, func) {
          * Time: O(N)
          */
         "thanos": (order => thanos(array, f, order)),
+        /**
+         * Time: O(max(N, maxValue))
+         */
+        "sleep": (order => sleep(array, f, order))
     };
 }

package/dist/sorts/sleep.d.ts

@@ -0,0 +1,3 @@
+import type { InternalSortFunction } from "..";
+declare const sleep: InternalSortFunction;
+export default sleep;

package/dist/sorts/sleep.js

@@ -0,0 +1,18 @@
+const sleep = async (arr, func, order) => {
+    const indexMap = arr.map(v => ({
+        index: func(v),
+        value: v
+    }));
+    const isAsc = order === "ascending";
+    const promises = indexMap.map(v => new Promise(resolve => {
+        const delay = Math.max(0, v.index);
+        setTimeout(() => {
+            resolve(v);
+        }, delay);
+    }));
+    const result = await Promise.all(promises);
+    return isAsc
+        ? result.map(v => v.value)
+        : result.reverse().map(v => v.value);
+};
+export default sleep;

package/package.json

@@ -2,7 +2,7 @@
   "name": "sortism",
   "description": "The easiest way to sort an array.",
   "main": "./dist/index.js",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "type": "module",
   "keywords": [
     "sort",

package/src/index.ts

@@ -4,6 +4,7 @@ import merge from "./sorts/merge";
 import miracle from "./sorts/miracle";
 import quick from "./sorts/quick";
 import selection from "./sorts/selection";
+import sleep from "./sorts/sleep";
 import stalin from "./sorts/stalin";
 import thanos from "./sorts/thanos";
 
@@ -11,12 +12,12 @@ export type InternalSortFunction = <T>(
     arr: T[],
     func: (v: T) => number,
     order: "ascending" | "descending",
-) => T[];
+) => T[] | Promise<T[]>;
 
-export type ExportSortFunction<T> = (
+export type SortFunction<T> = (
     order: "ascending" | "descending",
     func?: (v: T) => number,
-) => T[];
+) => T[] | Promise<T[]>;
 
 /**
  * You can use sortism through this function.
@@ -28,34 +29,38 @@ export default function sortism<T = any>(array: T[], func?: (v: T) => number) {
         /**
          * Time: O(n^2)
          */
-        "bubble": (order => bubble(array, f, order)) as ExportSortFunction<T>,
+        "bubble": (order => bubble(array, f, order)) as SortFunction<T>,
         /**
          * Time: O(n^2)
          */
-        "selection": (order => selection(array, f, order)) as ExportSortFunction<T>,
+        "selection": (order => selection(array, f, order)) as SortFunction<T>,
         /**
          * Time: O(n log n)
          */
-        "merge": (order => merge(array, f, order)) as ExportSortFunction<T>,
+        "merge": (order => merge(array, f, order)) as SortFunction<T>,
         /**
          * Time: O(n log n)
          */
-        "quick": (order => quick(array, f, order)) as ExportSortFunction<T>,
+        "quick": (order => quick(array, f, order)) as SortFunction<T>,
         /**
          * Time: O(n * n!)
          */
-        "bogo": (order => bogo(array, f, order)) as ExportSortFunction<T>,
+        "bogo": (order => bogo(array, f, order)) as SortFunction<T>,
         /**
          * Time: O(N)
          */
-        "stalin": (order => stalin(array, f, order)) as ExportSortFunction<T>,
+        "stalin": (order => stalin(array, f, order)) as SortFunction<T>,
         /**
          * Time: O(Infinity)
          */
-        "miracle": (order => miracle(array, f, order)) as ExportSortFunction<T>,
+        "miracle": (order => miracle(array, f, order)) as SortFunction<T>,
         /**
          * Time: O(N)
          */
-        "thanos": (order => thanos(array, f, order)) as ExportSortFunction<T>,
+        "thanos": (order => thanos(array, f, order)) as SortFunction<T>,
+        /**
+         * Time: O(max(N, maxValue))
+         */
+        "sleep": (order => sleep(array, f, order)) as SortFunction<T>
     };
 }

package/src/sorts/sleep.ts

@@ -0,0 +1,28 @@
+import type { InternalSortFunction } from "..";
+
+const sleep: InternalSortFunction = async (arr, func, order) => {
+    const indexMap = arr.map(v => ({
+        index: func(v),
+        value: v
+    }));
+
+    const isAsc = order === "ascending";
+
+    const promises = indexMap.map(v =>
+        new Promise<typeof indexMap[number]>(resolve => {
+            const delay = Math.max(0, v.index);
+
+            setTimeout(() => {
+                resolve(v);
+            }, delay);
+        })
+    );
+
+    const result = await Promise.all(promises);
+
+    return isAsc
+        ? result.map(v => v.value)
+        : result.reverse().map(v => v.value);
+};
+
+export default sleep;

package/tests/index.ts

@@ -1,8 +1,10 @@
 import sortism from './../dist';
 
-const arr = [0,15,126,74,4,2234,235,23,574,4578,2];
+const arr = [0, 15, 126, 74, 4, 2234, 235, 23, 574, 4578, 2];
 const sort = sortism(arr);
 
-const result = sort.thanos("ascending");
+(async () => {
+    const result = await sort.sleep("ascending");
 
-console.log(result);
+    console.log(result);
+})();

package/bun.lock

@@ -1,26 +0,0 @@
-{
-  "lockfileVersion": 1,
-  "configVersion": 1,
-  "workspaces": {
-    "": {
-      "name": "sortism",
-      "devDependencies": {
-        "@types/bun": "latest",
-      },
-      "peerDependencies": {
-        "typescript": "^5",
-      },
-    },
-  },
-  "packages": {
-    "@types/bun": ["@types/bun@1.3.11", "", { "dependencies": { "bun-types": "1.3.11" } }, "sha512-5vPne5QvtpjGpsGYXiFyycfpDF2ECyPcTSsFBMa0fraoxiQyMJ3SmuQIGhzPg2WJuWxVBoxWJ2kClYTcw/4fAg=="],
-
-    "@types/node": ["@types/node@25.5.0", "", { "dependencies": { "undici-types": "~7.18.0" } }, "sha512-jp2P3tQMSxWugkCUKLRPVUpGaL5MVFwF8RDuSRztfwgN1wmqJeMSbKlnEtQqU8UrhTmzEmZdu2I6v2dpp7XIxw=="],
-
-    "bun-types": ["bun-types@1.3.11", "", { "dependencies": { "@types/node": "*" } }, "sha512-1KGPpoxQWl9f6wcZh57LvrPIInQMn2TQ7jsgxqpRzg+l0QPOFvJVH7HmvHo/AiPgwXy+/Thf6Ov3EdVn1vOabg=="],
-
-    "typescript": ["typescript@5.9.3", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw=="],
-
-    "undici-types": ["undici-types@7.18.2", "", {}, "sha512-AsuCzffGHJybSaRrmr5eHr81mwJU3kjw6M+uprWvCXiNeN9SOGwQ3Jn8jb8m3Z6izVgknn1R0FTCEAP2QrLY/w=="],
-  }
-}