@softsky/utils 1.0.5 → 1.1.1

package/README.md

@@ -19,6 +19,10 @@ If compare returns > 0 it means we have to cut out bigger side of array.
 If compare returns < 0 it means we have to cut out smaller side of array.
 ### function chunk
 Split array into sub arrays of spicified size
+### function combinations
+Return all combinations of items in array
+### function permutations
+Return all permutations of items in array
 
 ## consts
 Some useful consts. That's it.
@@ -77,6 +81,8 @@ Random number between min and max. May enable float
 Same as parseInt but throws
 ### function parseFloat
 Same as parseFloat but throws
+### function factorial
+Factorial
 
 ## objects
 [object Object]
@@ -119,6 +125,8 @@ Find next cron tick after passed date
 Damn, I **love** TypeScript.
 ### type Optional
 Make keys in object optional
+### type Required
+Make keys in object required
 ### type Constructor
 Get contructor type of an instance
 ### type AwaitedObject

package/dist/arrays.d.ts

@@ -17,3 +17,7 @@ export declare function swap<T>(array: T[], index: number, index2: number): T[];
 export declare function binarySearch(size: number, compare: (index: number) => number): number;
 /** Split array into sub arrays of spicified size */
 export declare function chunk<T>(array: T[], chunkSize: number): T[][];
+/** Return all combinations of items in array */
+export declare function combinations<T>(array: T[]): T[][];
+/** Return all permutations of items in array */
+export declare function permutations<T>(array: T[]): T[][];

package/dist/arrays.js

@@ -58,3 +58,38 @@ export function chunk(array, chunkSize) {
         result.push(copy.splice(0, chunkSize));
     return result;
 }
+/** Return all combinations of items in array */
+export function combinations(array) {
+    const amount = 1 << array.length;
+    const combinations = new Array(amount);
+    for (let combinationIndex = 0; combinationIndex < amount; combinationIndex++) {
+        const combination = [];
+        for (let index = 0; index < array.length; index++)
+            if (combinationIndex >> index & 1)
+                combination.push(array[index]);
+        combinations[combinationIndex] = combination;
+    }
+    return combinations;
+}
+/** Return all permutations of items in array */
+export function permutations(array) {
+    const n = array.length;
+    const result = [];
+    const control = new Array(n).fill(0);
+    result.push([...array]);
+    let index = 0;
+    while (index < n) {
+        if (control[index] < index) {
+            const k = index % 2 === 0 ? 0 : control[index];
+            swap(array, index, k);
+            result.push([...array]);
+            control[index]++;
+            index = 0;
+        }
+        else {
+            control[index] = 0;
+            index++;
+        }
+    }
+    return result;
+}

package/dist/numbers.d.ts

@@ -4,3 +4,5 @@ export declare function random(min: number, max: number, float?: boolean): numbe
 export declare function parseInt(parameter: unknown, radix?: number): number;
 /** Same as parseFloat but throws */
 export declare function parseFloat(parameter: unknown): number;
+/** Factorial */
+export declare function factorial(n: number): number;

package/dist/numbers.js

@@ -23,3 +23,12 @@ export function parseFloat(parameter) {
         throw new ValidationError(`Can not parse "${parameter}" to float`);
     return n;
 }
+/** Factorial */
+export function factorial(n) {
+    if (n === 0 || n === 1)
+        return 1;
+    let result = 1;
+    for (let index = 2; index <= n; index++)
+        result *= index;
+    return result;
+}

package/dist/types.d.ts

@@ -2,7 +2,11 @@
  * Damn, I **love** TypeScript.
  */
 /** Make keys in object optional */
-export type Optional<T, K extends keyof any> = Omit<T, K & keyof T> & Partial<Pick<T, K & keyof T>>;
+export type Optional<T, K extends keyof T> = Omit<T, K & keyof T> & Partial<Pick<T, K & keyof T>>;
+/** Make keys in object required */
+export type Required<T, K extends keyof T> = Omit<T, K & keyof T> & {
+    [P in K]-?: T[P];
+};
 /** Get contructor type of an instance */
 export type Constructor<T> = abstract new (..._arguments: never[]) => T;
 /** Recursively resolves promises in objects and arrays */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@softsky/utils",
-  "version": "1.0.5",
+  "version": "1.1.1",
   "description": "JavaScript/TypeScript utilities",
   "main": "dist/index.js",
   "scripts": {
@@ -19,8 +19,8 @@
   },
   "homepage": "https://github.com/SoundOfTheSky/utils#readme",
   "devDependencies": {
-    "@softsky/configs": "^1.0.6",
-    "@types/bun": "^1.1.13"
+    "@softsky/configs": "^1.1.0",
+    "@types/bun": "^1.2.0"
   },
   "files": ["dist/**/*"]
 }