@softsky/utils 2.7.3 → 2.8.1

package/README.md

@@ -300,6 +300,12 @@ If isTarget is omitted becomes floodfill.
 Returns a target and map of parents.
 You can use `unfoldPathfindingResult()` to get array of nodes.
 
+---
+__function__ `dijkstra` - Dijkstra search. Like bfs but supports weight.
+If isTarget is omitted becomes floodfill (WITH WEIGHT).
+Returns a target and map of parents.
+You can use `unfoldPathfindingResult()` to get array of nodes.
+
 ---
 __function__ `knapsack` - Knapsack find best way to get maximum value in limited capacity
 
@@ -616,3 +622,11 @@ b: "b";
 ```
 
 ---
+__type__ `Tuple` - Create a tuple of size.
+
+```ts
+type a = Tuple<number, 3>
+type b = [number, number, number]
+```
+
+---

package/dist/arrays.js

@@ -48,7 +48,7 @@ export function binarySearch(size, compare, returnClosest) {
         else
             low = mid + 1;
     }
-    return returnClosest ? mid : -1;
+    return returnClosest ? low : -1;
 }
 /** Split array into sub arrays of spicified size */
 export function chunk(array, chunkSize) {

package/dist/graphs.d.ts

@@ -59,6 +59,26 @@ export declare function dfs<T>(options: {
     parents: Map<T, T>;
     target?: T;
 };
+/**
+ * Dijkstra search. Like bfs but supports weight.
+ * If isTarget is omitted becomes floodfill (WITH WEIGHT).
+ * Returns a target and map of parents.
+ * You can use `unfoldPathfindingResult()` to get array of nodes.
+ */
+export declare function dijkstra<T>(options: {
+    /** Start node */
+    start: T;
+    /** Get weight of node */
+    getWeight: (node: T) => number;
+    /** Get neighbors of node */
+    getNeighbors: (node: T) => T[];
+    /** Check if node is a target */
+    isTarget?: (node: T) => boolean;
+}): {
+    parents: Map<T, T>;
+    target?: T;
+    distance: Map<T, number>;
+};
 /** Knapsack find best way to get maximum value in limited capacity */
 export declare function knapsack(weights: number[], values: number[], capacity: number): {
     weight: number;

package/dist/graphs.js

@@ -109,6 +109,39 @@ export function dfs(options) {
         parents,
     };
 }
+/**
+ * Dijkstra search. Like bfs but supports weight.
+ * If isTarget is omitted becomes floodfill (WITH WEIGHT).
+ * Returns a target and map of parents.
+ * You can use `unfoldPathfindingResult()` to get array of nodes.
+ */
+export function dijkstra(options) {
+    const parents = new Map();
+    const distance = new Map();
+    const visited = new Set();
+    const queue = [[0, options.start]];
+    distance.set(options.start, 0);
+    while (queue.length > 0) {
+        const [distribution, node] = queue.shift();
+        if (visited.has(node))
+            continue;
+        visited.add(node);
+        if (options.isTarget?.(node))
+            return { parents, target: node, distance };
+        const neighbors = options.getNeighbors(node);
+        for (let index = 0; index < neighbors.length; index++) {
+            const neighbor = neighbors[index];
+            const cost = options.getWeight(neighbor);
+            const newDistribution = distribution + cost;
+            if (newDistribution < (distance.get(neighbor) ?? Infinity)) {
+                distance.set(neighbor, newDistribution);
+                parents.set(neighbor, node);
+                pushToSorted(queue, [newDistribution, neighbor], ([x]) => x - newDistribution);
+            }
+        }
+    }
+    return { parents, distance };
+}
 /** Knapsack find best way to get maximum value in limited capacity */
 export function knapsack(weights, values, capacity) {
     const n = weights.length;

package/dist/time.js

@@ -251,7 +251,6 @@ export class SpeedCalculator {
                     : {
                         speed,
                         percent: this.sum / this.size,
-                        // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-conversion
                         eta: ~~((this.size - this.sum) / speed) * 1000,
                     };
         }

package/dist/types.d.ts

@@ -8,9 +8,9 @@ export type AnyFunction = (...data: any[]) => any;
 /** Values that convert to false */
 export type Falsy = false | '' | 0 | null | undefined;
 /** Make keys in object optional */
-export type Optional<T, K extends keyof T> = Omit<T, K & keyof T> & Partial<Pick<T, K & keyof T>>;
+export type Optional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
 /** Make keys in object required */
-export type RequiredKey<T, K extends keyof T> = Omit<T, K & keyof T> & Required<Pick<T, K & keyof T>>;
+export type RequiredKey<T, K extends keyof T> = Omit<T, K> & Required<Pick<T, K>>;
 /** Get contructor type of an instance */
 export type Constructor<T> = new (..._arguments: any[]) => T;
 /** Recursively resolves promises in objects and arrays */
@@ -59,3 +59,12 @@ export type Concat<T, U> = T extends any[] ? U extends any[] ? [...T, ...U] : ne
 export type Prettify<T extends object> = {
     [k in keyof T]: T[k];
 } & {};
+/**
+ * Create a tuple of size.
+ *
+ * ```ts
+ * type a = Tuple<number, 3>
+ * type b = [number, number, number]
+ * ```
+ */
+export type Tuple<T, N extends number, R extends readonly T[] = []> = R['length'] extends N ? R : Tuple<T, N, [...R, T]>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@softsky/utils",
-  "version": "2.7.3",
+  "version": "2.8.1",
   "description": "JavaScript/TypeScript utilities",
   "main": "dist/index.js",
   "scripts": {
@@ -20,8 +20,8 @@
   },
   "homepage": "https://github.com/SoundOfTheSky/utils#readme",
   "devDependencies": {
-    "@softsky/configs": "^1.3.4",
-    "@types/bun": "^1.2.21"
+    "@softsky/configs": "^1.3.5",
+    "@types/bun": "^1.3.2"
   },
   "files": ["dist/**/*"]
 }