@softsky/utils 2.3.3 → 2.5.0

package/README.md

@@ -107,7 +107,13 @@ ${\textsf{\color{ForestGreen}const}}$ SEC_MS - Milliseconds in a second
 ## Control
 Utils related to code execution flow.
 
-${\textsf{\color{ForestGreen}const}}$ UUID - Get unique id
+${\textsf{\color{ForestGreen}const}}$ generateNumberId - Get unique number id
+
+---
+${\textsf{\color{CornflowerBlue}function}}$ UUID - Get universally unique string id
+
+---
+${\textsf{\color{CornflowerBlue}function}}$ extractUUIDDate - Extract exact date of uuid generation
 
 ---
 ${\textsf{\color{CornflowerBlue}function}}$ createCashedFunction - Creates cached function. All arguments/results are cached.
@@ -215,6 +221,31 @@ pipe(
 ---
 
 
+## Graphs
+Pos
+
+${\textsf{\color{CornflowerBlue}function}}$ unfoldPathfindingResult - Unfold pathfinding result to path array.
+
+---
+${\textsf{\color{CornflowerBlue}function}}$ aStar - Pathfind using aStar.
+Returns a target and map of parents.
+You can use `unfoldPathfindingResult()` to get array of nodes.
+
+---
+${\textsf{\color{CornflowerBlue}function}}$ bfs - Breadth-first search. Slower than dfs.
+If isTarget is omitted becomes floodfill.
+Returns a target and map of parents.
+You can use `unfoldPathfindingResult()` to get array of nodes.
+
+---
+${\textsf{\color{CornflowerBlue}function}}$ dfs - Depth-first search. Faster than bfs.
+If isTarget is omitted becomes floodfill.
+Returns a target and map of parents.
+You can use `unfoldPathfindingResult()` to get array of nodes.
+
+---
+
+
 ## Numbers
 Numbers, math, etc.
 

package/dist/arrays.js

@@ -33,24 +33,22 @@ export function swap(array, index, index2) {
  * If compare returns < 0 it means we have to cut out smaller side of array.
  */
 export function binarySearch(size, compare, returnClosest) {
+    if (size === 0)
+        return returnClosest ? 0 : -1;
     let low = 0;
     let high = size;
-    let position = -1;
-    while (high >= low) {
-        const mid = ((low + high) / 2) | 0;
-        if (returnClosest)
-            position = mid;
+    let mid = -1;
+    while (high > low) {
+        mid = ((low + high) / 2) | 0;
         const compared = compare(mid);
-        if (compared === 0) {
-            position = mid;
-            break;
-        }
+        if (compared === 0)
+            return mid;
         else if (compared > 0)
-            high = mid - 1;
+            high = mid;
         else
             low = mid + 1;
     }
-    return position;
+    return returnClosest ? mid : -1;
 }
 /** Split array into sub arrays of spicified size */
 export function chunk(array, chunkSize) {

package/dist/control.d.ts

@@ -2,8 +2,12 @@
  * Utils related to code execution flow.
  */
 import { AwaitedObject, JSONSerializable } from './types';
-/** Get unique id */
-export declare const UUID: () => number;
+/** Get unique number id */
+export declare const generateNumberId: () => number;
+/** Get universally unique string id */
+export declare function UUID(): string;
+/** Extract exact date of uuid generation */
+export declare function extractUUIDDate(uuid: string): Date;
 /**
  * Creates cached function. All arguments/results are cached.
  * Returns [

package/dist/control.js

@@ -2,8 +2,18 @@
  * Utils related to code execution flow.
  */
 let _uuid = Date.now() * 1000;
-/** Get unique id */
-export const UUID = () => _uuid++;
+/** Get unique number id */
+export const generateNumberId = () => _uuid++;
+const SESSION_ID = ((Math.random() * 2_147_483_648) | 0).toString(16);
+let stringIdInc = 0;
+/** Get universally unique string id */
+export function UUID() {
+    return `${Date.now().toString(36).padStart(11, '0')}${(++stringIdInc).toString(36).padStart(3, '0')}${SESSION_ID}`;
+}
+/** Extract exact date of uuid generation */
+export function extractUUIDDate(uuid) {
+    return new Date(Number.parseInt(uuid.slice(0, 11), 36));
+}
 /**
  * Creates cached function. All arguments/results are cached.
  * Returns [

package/dist/graphs.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Unfold pathfinding result to path array.
+ */
+export declare function unfoldPathfindingResult<T>({ target, parents, }: {
+    parents: Map<T, T>;
+    target?: T;
+}): T[];
+/**
+ * Pathfind using aStar.
+ * Returns a target and map of parents.
+ * You can use `unfoldPathfindingResult()` to get array of nodes.
+ */
+export declare function aStar<T>(options: {
+    /** Start node */
+    start: T;
+    /** Get weight of node */
+    getWeight: (node: T) => number;
+    /** Presumed cost of going to the target from node */
+    heuristic: (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;
+};
+/**
+ * Breadth-first search. Slower than dfs.
+ * If isTarget is omitted becomes floodfill.
+ * Returns a target and map of parents.
+ * You can use `unfoldPathfindingResult()` to get array of nodes.
+ */
+export declare function bfs<T>(options: {
+    /** Start node */
+    start: T;
+    /** Get neighbors of node */
+    getNeighbors: (parent: T) => T[];
+    /** Check if node is a target */
+    isTarget?: (child: T, parent: T) => boolean;
+}): {
+    parents: Map<T, T>;
+    target?: T;
+};
+/**
+ * Depth-first search. Faster than bfs.
+ * If isTarget is omitted becomes floodfill.
+ * Returns a target and map of parents.
+ * You can use `unfoldPathfindingResult()` to get array of nodes.
+ */
+export declare function dfs<T>(options: {
+    /** Start node */
+    start: T;
+    /** Get neighbors of node */
+    getNeighbors: (parent: T) => T[];
+    /** Check if node is a target */
+    isTarget?: (child: T, parent: T) => boolean;
+}): {
+    parents: Map<T, T>;
+    target?: T;
+};

package/dist/graphs.js

@@ -0,0 +1,111 @@
+import { pushToSorted } from './arrays';
+/**
+ * Unfold pathfinding result to path array.
+ */
+export function unfoldPathfindingResult({ target, parents, }) {
+    let node = target;
+    const path = [];
+    while (node) {
+        path.push(node);
+        node = parents.get(node);
+    }
+    return path.reverse();
+}
+/**
+ * Pathfind using aStar.
+ * Returns a target and map of parents.
+ * You can use `unfoldPathfindingResult()` to get array of nodes.
+ */
+export function aStar(options) {
+    const parents = new Map();
+    const queue = [
+        {
+            d: options.start,
+            g: 0,
+            h: options.heuristic(options.start),
+        },
+    ];
+    while (queue.length > 0) {
+        const node = queue.pop();
+        if (options.isTarget(node.d))
+            return {
+                parents,
+                target: node.d,
+            };
+        const neighbors = options.getNeighbors(node.d);
+        for (let index = 0; index < neighbors.length; index++) {
+            const neighbor = neighbors[index];
+            if (options.start === neighbor || parents.has(neighbor))
+                continue;
+            parents.set(neighbor, node.d);
+            const neighborNode = {
+                d: neighbor,
+                g: node.g + options.getWeight(neighbor),
+                h: options.heuristic(neighbor),
+            };
+            neighborNode.h += node.g;
+            pushToSorted(queue, neighborNode, (x) => neighborNode.h - x.h);
+        }
+    }
+    return {
+        parents,
+    };
+}
+/**
+ * Breadth-first search. Slower than dfs.
+ * If isTarget is omitted becomes floodfill.
+ * Returns a target and map of parents.
+ * You can use `unfoldPathfindingResult()` to get array of nodes.
+ */
+export function bfs(options) {
+    const queue = [options.start];
+    const parents = new Map();
+    for (let index = 0; index < queue.length; index++) {
+        const parent = queue[index];
+        const neighbors = options.getNeighbors(parent);
+        for (let index = 0; index < neighbors.length; index++) {
+            const neighbor = neighbors[index];
+            if (neighbor === options.start || parents.has(neighbor))
+                continue;
+            parents.set(neighbor, parent);
+            if (options.isTarget?.(neighbor, parent))
+                return {
+                    target: neighbor,
+                    parents,
+                };
+            queue.push(neighbor);
+        }
+    }
+    return {
+        parents,
+    };
+}
+/**
+ * Depth-first search. Faster than bfs.
+ * If isTarget is omitted becomes floodfill.
+ * Returns a target and map of parents.
+ * You can use `unfoldPathfindingResult()` to get array of nodes.
+ */
+export function dfs(options) {
+    const queue = [options.start];
+    const parents = new Map();
+    while (queue.length > 0) {
+        const node = queue.pop();
+        const neighbors = options.getNeighbors(node);
+        for (let index = 0; index < neighbors.length; index++) {
+            const neighbor = neighbors[index];
+            if (neighbor === options.start || parents.has(neighbor))
+                continue;
+            parents.set(neighbor, node);
+            if (options.isTarget?.(neighbor, node))
+                return {
+                    target: neighbor,
+                    parents,
+                };
+            queue.push(neighbor);
+        }
+    }
+    return {
+        parents,
+    };
+}

package/dist/index.d.ts

@@ -3,6 +3,7 @@ export * from './consts';
 export * from './control';
 export * from './errors';
 export * from './formatting';
+export * from './graphs';
 export * from './numbers';
 export * from './objects';
 export * from './signals';

package/dist/index.js

@@ -3,6 +3,7 @@ export * from './consts';
 export * from './control';
 export * from './errors';
 export * from './formatting';
+export * from './graphs';
 export * from './numbers';
 export * from './objects';
 export * from './signals';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@softsky/utils",
-  "version": "2.3.3",
+  "version": "2.5.0",
   "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.0",
-    "@types/bun": "^1.2.8"
+    "@softsky/configs": "^1.3.3",
+    "@types/bun": "^1.2.11"
   },
   "files": ["dist/**/*"]
 }