@softsky/utils 2.7.2 → 2.8.0

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 and target is required.
+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
 

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/control.d.ts

@@ -126,5 +126,5 @@ export declare function withTimeout<T>(run: () => Promise<T>, ms: number): Promi
 /** Promisify a function with callback */
 export declare function promisify<A extends any[], R extends any[]>(handler: (...handlerArguments: [...A, (...results: R) => void]) => void): (...handlerArguments: A) => Promise<R extends [infer U] ? U : R>;
 /** Create a promise out of EventSource */
-export declare function promisifyEventSource<T = unknown>(target: EventSource, resolveEvents: string[], rejectEvents?: string[]): Promise<T>;
+export declare function promisifyEventSource<T = unknown>(target: object, resolveEvents: string[], rejectEvents?: string[], subName?: string): Promise<T>;
 export {};

package/dist/control.js

@@ -297,12 +297,15 @@ export function promisify(handler) {
     });
 }
 /** Create a promise out of EventSource */
-export function promisifyEventSource(target, resolveEvents, rejectEvents = ['error']) {
+export function promisifyEventSource(target, resolveEvents, rejectEvents = ['error'], subName = 'addEventListener') {
     return new Promise((resolve, reject) => {
         for (let index = 0; index < resolveEvents.length; index++)
             // @ts-ignore
-            target.addEventListener(resolveEvents[index], resolve);
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+            target[subName]?.(resolveEvents[index], resolve);
         for (let index = 0; index < rejectEvents.length; index++)
-            target.addEventListener(rejectEvents[index], reject);
+            // @ts-ignore
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+            target[subName]?.(rejectEvents[index], reject);
     });
 }

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 and target is required.
+ * 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 and target is required.
+ * 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@softsky/utils",
-  "version": "2.7.2",
+  "version": "2.8.0",
   "description": "JavaScript/TypeScript utilities",
   "main": "dist/index.js",
   "scripts": {
@@ -21,7 +21,7 @@
   "homepage": "https://github.com/SoundOfTheSky/utils#readme",
   "devDependencies": {
     "@softsky/configs": "^1.3.4",
-    "@types/bun": "^1.2.21"
+    "@types/bun": "^1.2.23"
   },
   "files": ["dist/**/*"]
 }