custom-permutation 1.0.7 → 1.1.1

package/README.md

@@ -1,105 +1,121 @@
-# Fixed bugs
-25.09.2023 - unChoices did not reflect always, fixed now.
-
 # Custom Permutation Generator
 
-## 1. require / import
+## Usage
+
+### 1.1. `require`
+
+```ts
+const CustomPermutation = require('custom-permutation');
+```
+
+### 1.2. `import`
+
 ```ts
-const CustomPermutation = require('custom-permutation')
+import CustomPermutation from 'custom-permutation';
 ```
 
 ## 2. Constructor
+
 ```ts
-CustomPermutation(elList:[els...], choices:{ index: [els...]] }, nonChoices:{ index: [els...]] })
+CustomPermutation(
+    elList:[],
+    choices:{ index: [] },
+    nonChoices:{ index: [] }
+)
 ```
 
-## 3. Usage explanation
+## 3. Usage explanied
 
 _example:_
 
 ```ts
-CustomPermutation(['a', 'b', 'c'], {1: ['a', 'b']}, {0: ['a']})
+CustomPermutation(['a', 'b', 'c'], { '1': ['a', 'b'] }, { '0': ['a'] });
 ```
 
-Permutate 3 elements which are 'a', 'b' and 'c' with below rules
+Permutate 3 elements which are "a", "b" and "c" with below rules
+
+**`choices` rule:**
 
-__- choices rule:__
 ```json
-{ 1: ['a', 'b'] }
+{ "1": ["a", "b"] }
 ```
 
-    At index=1 there can only be the element 'a' or 'b'
+> At `index=1` there can only be the element `"a"` or `"b"`
+
+**`nonChoices` rule:**
 
-__- nonChoices rule:__
 ```json
-{ 0: ['a'] }
+{ "0": ["a"] }
 ```
 
-    At index=0 there can NOT be the element 'a'
+> At `index=0` there can NOT be the element `"a"`
 
 _Note: given index are considered as 0 based: [index=0, index=1, etc.]_
 
+| index |     all options     | after customization |
+| :---: | :-----------------: | :-----------------: |
+|   0   | `"a"`, `"b"`, `"c"` |    `"b"`, `"c"`     |
+|   1   | `"a"`, `"b"`, `"c"` |    `"a"`, `"b"`     |
+|   2   | `"a"`, `"b"`, `"c"` | `"a"`, `"b"`, `"c"` |
+
 ## 4. Result set explanation:
 
-Let's see all permutations, and which ones are valid or not.
-- `['a', 'b', 'c']` : violates nonChoices rule: _first element is `'a'`, but shouldn't be `'a'`
-- `['a', 'c', 'b']` : violates nonChoices rule: _first element is `'a'`, but shouldn't be `'a'`_
-- `['b', 'a', 'c']` : ok
-- `['b', 'c', 'a']` : violates choices rule: _second element is `'c'` but `'a'` or `'b'` is desired_
-- `['c', 'a', 'b']` : ok
-- `['c', 'b', 'a']` : ok
+Let's check all permutations, and see which ones are and are not valid.
+
+|    Permutation    | Is valid |  Violates  |                  Description                   |
+| :---------------: | :------: | :--------: | :--------------------------------------------: |
+| `["a", "b", "c"]` |    No    | nonChoices |         _first elemen can't be `"a"`_          |
+| `["a", "c", "b"]` |    No    | nonChoices |         _first elemen can't be `"a"`_          |
+| `["b", "a", "c"]` |   Yes    |     -      |                       -                        |
+| `["b", "c", "a"]` |    No    |  choices   | _second element is asked to be `"a"` or `"b"`_ |
+| `["c", "a", "b"]` |   Yes    |     -      |                       -                        |
+| `["c", "b", "a"]` |   Yes    |     -      |                       -                        |
 
-So there are just 3 results that should be generated with this parameters.
+So there are just **3** results that chould be generated with these parameters.
 
 ## 5. Complete example
 
-### 1. Create permutation
+### 5.1. Create object from `CustomPermutation` class
 
 ```ts
-let customPerm = new CustomPermutation(
-    ['a', 'b', 'c'],
-    { 1: ['a', 'b'] },
-    { 0: ['a'] }
-);
+let customPerm = new CustomPermutation(['a', 'b', 'c'], { '1': ['a', 'b'] }, { '0': ['a'] });
 ```
 
-### 2. Get next value
+### 5.2. Get next value
 
-#### 2.1. Use with next
+#### 5.2.1. With `next`
 
 ```ts
 let next = customPerm.next();
 
 while (next) {
-    // Use next
-    console.log(next)
-
-    // Get next
-    next = customPerm.next();
+  console.log(next);
+  next = customPerm.next();
 }
 ```
 
-#### 2.2. Or use with generator
+#### 5.2.2. With `generator`
 
 ```ts
 let generator = customPerm.generator();
 let next = generator.next();
 
 while (!next.done) {
-    // Use next.value
-    console.log(next.value)
-
-    // Generate next one
-    next = generator.next();
+  console.log(next.value);
+  next = generator.next();
 }
 ```
 
-### 3. Output
-
-__Console__
+**Output:**
 
 ```sh
-['b', 'a', 'c']\
-['c', 'a', 'b']\
-['c', 'b', 'a']
-```
+["b", "a", "c"]
+["c", "a", "b"]
+["c", "b", "a"]
+```
+
+## Fixed bugs
+
+11.06.2026 - Better typing implemented and more test coverage added.
+23.09.2024 - Edge cases are handled and the codespace is simplified.
+25.09.2023 - unChoices did not reflect always, fixed now.

package/lib/CustomPermutation.d.ts

@@ -1,13 +1,12 @@
-import { CustomPermutationGenerator } from "./CustomPermutationGenerator";
-export default class CustomPermutation {
+import { CustomPermutationGenerator } from './CustomPermutationGenerator';
+export default class CustomPermutation<T> {
     private listToPermutate;
     private choices;
     private nonChoices;
     private elementsOrderAbsolute?;
-    private elementsOrderRelative?;
     private passFn?;
-    customPermGen: CustomPermutationGenerator;
-    constructor(listToPermutate: any[], choices: object, nonChoices: object, elementsOrderAbsolute?: any[], elementsOrderRelative?: any[], passFn?: Function);
-    next(): any;
-    generator(): Generator<any, void, unknown>;
+    customPermGen: CustomPermutationGenerator<T>;
+    constructor(listToPermutate: T[], choices: Record<number, T[]>, nonChoices: Record<number, T[]>, elementsOrderAbsolute?: number[] | undefined, passFn?: ((items: T[]) => boolean) | undefined);
+    next(): T[] | null;
+    generator(): Generator<T[], void, unknown>;
 }

package/lib/CustomPermutation.js

@@ -1,74 +1,33 @@
 "use strict";
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-var CustomPermutationGenerator_1 = require("./CustomPermutationGenerator");
-var CustomPermutation = /** @class */ (function () {
-    function CustomPermutation(listToPermutate, choices, nonChoices, elementsOrderAbsolute, elementsOrderRelative, passFn) {
+const CustomPermutationGenerator_1 = require("./CustomPermutationGenerator");
+class CustomPermutation {
+    constructor(listToPermutate, choices, nonChoices, elementsOrderAbsolute, passFn) {
         this.listToPermutate = listToPermutate;
         this.choices = choices;
         this.nonChoices = nonChoices;
         this.elementsOrderAbsolute = elementsOrderAbsolute;
-        this.elementsOrderRelative = elementsOrderRelative;
         this.passFn = passFn;
         if (!(elementsOrderAbsolute === null || elementsOrderAbsolute === void 0 ? void 0 : elementsOrderAbsolute.length)) {
-            elementsOrderAbsolute = new Array(listToPermutate.length, 0).map(function (x, i) { return i; });
+            elementsOrderAbsolute = Array.from(listToPermutate).map((x, i) => i);
         }
-        if (!(elementsOrderRelative === null || elementsOrderRelative === void 0 ? void 0 : elementsOrderRelative.length)) {
-            elementsOrderRelative = new Array(listToPermutate.length, 0).map(function (x, i) { return i; });
-        }
-        this.customPermGen = new CustomPermutationGenerator_1.CustomPermutationGenerator(listToPermutate, choices, nonChoices, elementsOrderAbsolute, elementsOrderRelative, passFn);
+        this.customPermGen = new CustomPermutationGenerator_1.CustomPermutationGenerator(this.listToPermutate, this.choices, this.nonChoices, this.elementsOrderAbsolute, this.passFn);
     }
-    CustomPermutation.prototype.next = function () {
+    next() {
         return this.customPermGen.next();
-    };
-    CustomPermutation.prototype.generator = function () {
-        var nextPerm;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    nextPerm = null;
-                    _a.label = 1;
-                case 1:
-                    if (!true) return [3 /*break*/, 5];
-                    nextPerm = this.customPermGen.next();
-                    if (!nextPerm) return [3 /*break*/, 3];
-                    return [4 /*yield*/, nextPerm];
-                case 2:
-                    _a.sent();
-                    return [3 /*break*/, 4];
-                case 3: return [3 /*break*/, 5];
-                case 4: return [3 /*break*/, 1];
-                case 5: return [2 /*return*/];
+    }
+    *generator() {
+        let nextPerm = null;
+        while (true) {
+            nextPerm = this.customPermGen.next();
+            if (nextPerm) {
+                yield nextPerm;
             }
-        });
-    };
-    return CustomPermutation;
-}());
+            else {
+                break;
+            }
+        }
+    }
+}
 exports.default = CustomPermutation;
 //# sourceMappingURL=CustomPermutation.js.map

package/lib/CustomPermutation.js.map

@@ -1 +1 @@
-{"version":3,"file":"CustomPermutation.js","sourceRoot":"","sources":["../src/CustomPermutation.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,2EAA0E;AAE1E;IAGE,2BACU,eAAsB,EACtB,OAAe,EACf,UAAkB,EAClB,qBAA6B,EAC7B,qBAA6B,EAC7B,MAAiB;QALjB,oBAAe,GAAf,eAAe,CAAO;QACtB,YAAO,GAAP,OAAO,CAAQ;QACf,eAAU,GAAV,UAAU,CAAQ;QAClB,0BAAqB,GAArB,qBAAqB,CAAQ;QAC7B,0BAAqB,GAArB,qBAAqB,CAAQ;QAC7B,WAAM,GAAN,MAAM,CAAW;QAGzB,IAAI,CAAC,CAAA,qBAAqB,aAArB,qBAAqB,uBAArB,qBAAqB,CAAE,MAAM,CAAA,EAAE;YAClC,qBAAqB,GAAG,IAAI,KAAK,CAAC,eAAe,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,UAAC,CAAC,EAAE,CAAC,IAAK,OAAA,CAAC,EAAD,CAAC,CAAC,CAAC;SAC/E;QAED,IAAI,CAAC,CAAA,qBAAqB,aAArB,qBAAqB,uBAArB,qBAAqB,CAAE,MAAM,CAAA,EAAE;YAClC,qBAAqB,GAAG,IAAI,KAAK,CAAC,eAAe,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,UAAC,CAAC,EAAE,CAAC,IAAK,OAAA,CAAC,EAAD,CAAC,CAAC,CAAC;SAC/E;QAED,IAAI,CAAC,aAAa,GAAG,IAAI,uDAA0B,CAAC,eAAe,EAAE,OAAO,EAAE,UAAU,EAAE,qBAAqB,EAAE,qBAAqB,EAAE,MAAM,CAAC,CAAC;IAClJ,CAAC;IAED,gCAAI,GAAJ;QACE,OAAO,IAAI,CAAC,aAAa,CAAC,IAAI,EAAE,CAAC;IACnC,CAAC;IAEA,qCAAS,GAAV;;;;;oBACM,QAAQ,GAAG,IAAI,CAAC;;;yBAEb,IAAI;oBACT,QAAQ,GAAG,IAAI,CAAC,aAAa,CAAC,IAAI,EAAE,CAAC;yBACjC,QAAQ,EAAR,wBAAQ;oBACV,qBAAM,QAAQ,EAAA;;oBAAd,SAAc,CAAC;;wBAEf,wBAAM;;;;;KAGX;IAEH,wBAAC;AAAD,CAAC,AAxCD,IAwCC"}
+{"version":3,"file":"CustomPermutation.js","sourceRoot":"","sources":["../src/CustomPermutation.ts"],"names":[],"mappings":";;AAAA,6EAA0E;AAE1E,MAAqB,iBAAiB;IAGpC,YACU,eAAoB,EACpB,OAA4B,EAC5B,UAA+B,EAC/B,qBAAgC,EAChC,MAAgC;QAJhC,oBAAe,GAAf,eAAe,CAAK;QACpB,YAAO,GAAP,OAAO,CAAqB;QAC5B,eAAU,GAAV,UAAU,CAAqB;QAC/B,0BAAqB,GAArB,qBAAqB,CAAW;QAChC,WAAM,GAAN,MAAM,CAA0B;QAExC,IAAI,CAAC,CAAA,qBAAqB,aAArB,qBAAqB,uBAArB,qBAAqB,CAAE,MAAM,CAAA,EAAE,CAAC;YACnC,qBAAqB,GAAG,KAAK,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC;QACvE,CAAC;QAED,IAAI,CAAC,aAAa,GAAG,IAAI,uDAA0B,CACjD,IAAI,CAAC,eAAe,EACpB,IAAI,CAAC,OAAO,EACZ,IAAI,CAAC,UAAU,EACf,IAAI,CAAC,qBAAqB,EAC1B,IAAI,CAAC,MAAM,CACZ,CAAC;IACJ,CAAC;IAED,IAAI;QACF,OAAO,IAAI,CAAC,aAAa,CAAC,IAAI,EAAE,CAAC;IACnC,CAAC;IAED,CAAC,SAAS;QACR,IAAI,QAAQ,GAAG,IAAI,CAAC;QAEpB,OAAO,IAAI,EAAE,CAAC;YACZ,QAAQ,GAAG,IAAI,CAAC,aAAa,CAAC,IAAI,EAAE,CAAC;YACrC,IAAI,QAAQ,EAAE,CAAC;gBACb,MAAM,QAAQ,CAAC;YACjB,CAAC;iBAAM,CAAC;gBACN,MAAM;YACR,CAAC;QACH,CAAC;IACH,CAAC;CACF;AAvCD,oCAuCC"}

package/lib/CustomPermutationGenerator.d.ts

@@ -1,44 +1,38 @@
-export declare class CustomPermutationGenerator {
+import { PermutationGeneratorForSet } from './PermutationGeneratorForSet';
+export declare class CustomPermutationGenerator<T> {
     private elementList;
     private choicesByIndex;
     private nonChoicesByIndex;
-    private elementsOrderAbs?;
-    private elementsIndexRel;
+    private elementsOrderAbsolute?;
     private passFunction?;
-    private randomizechoices?;
-    set: any[];
-    setAsStr: string[];
-    permutationGenOfSet: any;
+    set: T[];
+    permutationGenOfSet: PermutationGeneratorForSet;
     nextIndexList: number[];
-    choicesByIndexInSet: {};
-    history: any[];
-    historyHashes: any[];
-    current: any[];
+    finalChoicesByIndexInSet: {
+        [key: string]: number[];
+    };
+    history: T[][];
+    historyHashes: string[];
+    current: T[];
     cursor: number;
-    constructor(elementList: any[], choicesByIndex?: object, // ChoicesByIndex is relative to sub-sch so we need elementsIndexRel, a index list of sub-sch
-    nonChoicesByIndex?: object, // nonChoices is also relative
-    elementsOrderAbs?: any[], // Actual orders in final schdule
-    elementsIndexRel?: any[], // Actual relative orders in sub-schedule
-    passFunction?: Function, randomizechoices?: boolean);
-    extendIndexesOfSameElements(choicesByIndex: any, indexesOfSameElements: any): void;
-    init(): void;
-    completeMissingChoicesIndexes(): void;
-    setChoicesIndexesInSet(): void;
+    constructor(elementList: T[], choicesByIndex: Record<number, T[]>, nonChoicesByIndex: Record<number, T[]>, elementsOrderAbsolute?: number[] | undefined, passFunction?: ((items: T[]) => boolean) | undefined);
     removeNonChoicesIndexes(): void;
-    getAllIndexesOfElementInList(el: any, list: any): any[];
-    prev(): any;
-    next(): any;
-    nextDistinct(): false | {
-        done: any;
-        value: any;
+    setChoicesIndexesInSet(): void;
+    getAllIndexesOfElementInList(el: unknown, list: unknown[]): number[];
+    completeRestOfIndexes(): void;
+    extendIndexesOfSameElements(choicesByIndex: Record<string | number, any[]>, indexesOfSameElements: Record<number, number[]>): void;
+    prev(): T[] | undefined;
+    next(): T[] | null;
+    nextDistinct(): {
+        value: T[] | undefined;
+        done: boolean;
     };
     saveCurrentToHistory(): void;
-    getHash(elList: any[]): string;
-    getElementListByInitialListIndexes(indexes: any): any[];
-    consecutiveDifferent(list: any[]): boolean;
+    getHash(elList: T[]): string;
+    getElementListByInitialListIndexes(indexes: number[]): T[];
     reset(): void;
-    getSet(): any[];
+    getSet(): T[];
     isEmpty(): boolean;
-    getCurrent(): any;
-    last(): any;
+    getCurrent(): T[] | null;
+    last(): T[];
 }