custom-permutation 1.0.7 → 1.1.0

package/README.md

@@ -1,12 +1,21 @@
+# Version
+1.1.0
+
 # Fixed bugs
+23.09.2024 - Edge cases are handled and the codespace is simplified.
 25.09.2023 - unChoices did not reflect always, fixed now.
 
 # Custom Permutation Generator
 
-## 1. require / import
+## 1.1. `require`
 ```ts
 const CustomPermutation = require('custom-permutation')
 ```
+## 1.2. ,`import`
+
+```ts
+import CustomPermutation from "custom-permutation";
+```
 
 ## 2. Constructor
 ```ts
@@ -18,36 +27,36 @@ CustomPermutation(elList:[els...], choices:{ index: [els...]] }, nonChoices:{ in
 _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:__
 ```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:__
 ```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.]_
 
 ## 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
+- [ ] `["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"`_
+- [x] `["b", "a", "c"]`
+- [ ] `["b", "c", "a"]` // violates choices rule: _second element is `"c"` but `"a"` or `"b"` is desired_
+- [x] `["c", "a", "b"]`
+- [x] `["c", "b", "a"]`
 
 So there are just 3 results that should be generated with this parameters.
 
@@ -57,9 +66,9 @@ So there are just 3 results that should be generated with this parameters.
 
 ```ts
 let customPerm = new CustomPermutation(
-    ['a', 'b', 'c'],
-    { 1: ['a', 'b'] },
-    { 0: ['a'] }
+    ["a", "b", "c"],
+    { "1": ["a", "b"] },
+    { "0": ["a"] }
 );
 ```
 
@@ -71,10 +80,7 @@ let customPerm = new CustomPermutation(
 let next = customPerm.next();
 
 while (next) {
-    // Use next
     console.log(next)
-
-    // Get next
     next = customPerm.next();
 }
 ```
@@ -86,10 +92,7 @@ let generator = customPerm.generator();
 let next = generator.next();
 
 while (!next.done) {
-    // Use next.value
     console.log(next.value)
-
-    // Generate next one
     next = generator.next();
 }
 ```
@@ -99,7 +102,7 @@ while (!next.done) {
 __Console__
 
 ```sh
-['b', 'a', 'c']\
-['c', 'a', 'b']\
-['c', 'b', 'a']
+["b", "a", "c"]
+["c", "a", "b"]
+["c", "b", "a"]
 ```

package/lib/CustomPermutation.d.ts

@@ -1,13 +1,12 @@
-import { CustomPermutationGenerator } from "./CustomPermutationGenerator";
+import { CustomPermutationGenerator } from './CustomPermutationGenerator';
 export default class CustomPermutation {
     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);
+    constructor(listToPermutate: any[], choices: object, nonChoices: object, elementsOrderAbsolute?: any[], passFn?: (items: any[]) => boolean);
     next(): any;
     generator(): Generator<any, 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,eAAsB,EACtB,OAAe,EACf,UAAkB,EAClB,qBAA6B,EAC7B,MAAkC;QAJlC,oBAAe,GAAf,eAAe,CAAO;QACtB,YAAO,GAAP,OAAO,CAAQ;QACf,eAAU,GAAV,UAAU,CAAQ;QAClB,0BAAqB,GAArB,qBAAqB,CAAQ;QAC7B,WAAM,GAAN,MAAM,CAA4B;QAE1C,IAAI,CAAC,CAAA,qBAAqB,aAArB,qBAAqB,uBAArB,qBAAqB,CAAE,MAAM,CAAA,EAAE;YAClC,qBAAqB,GAAG,KAAK,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC;SACtE;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;YACX,QAAQ,GAAG,IAAI,CAAC,aAAa,CAAC,IAAI,EAAE,CAAC;YACrC,IAAI,QAAQ,EAAE;gBACZ,MAAM,QAAQ,CAAC;aAChB;iBAAM;gBACL,MAAM;aACP;SACF;IACH,CAAC;CACF;AAvCD,oCAuCC"}

package/lib/CustomPermutationGenerator.d.ts

@@ -2,40 +2,28 @@ export declare class CustomPermutationGenerator {
     private elementList;
     private choicesByIndex;
     private nonChoicesByIndex;
-    private elementsOrderAbs?;
-    private elementsIndexRel;
+    private elementsOrderAbsolute?;
     private passFunction?;
-    private randomizechoices?;
     set: any[];
-    setAsStr: string[];
     permutationGenOfSet: any;
     nextIndexList: number[];
-    choicesByIndexInSet: {};
+    finalChoicesByIndexInSet: {};
     history: any[];
     historyHashes: any[];
     current: any[];
     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: any[], choicesByIndex?: object, nonChoicesByIndex?: object, elementsOrderAbsolute?: any[], passFunction?: (items: any[]) => boolean);
     removeNonChoicesIndexes(): void;
+    setChoicesIndexesInSet(): void;
     getAllIndexesOfElementInList(el: any, list: any): any[];
+    completeRestOfIndexes(): void;
+    extendIndexesOfSameElements(choicesByIndex: any, indexesOfSameElements: any): void;
     prev(): any;
     next(): any;
-    nextDistinct(): false | {
-        done: any;
-        value: any;
-    };
+    nextDistinct(): any;
     saveCurrentToHistory(): void;
     getHash(elList: any[]): string;
     getElementListByInitialListIndexes(indexes: any): any[];
-    consecutiveDifferent(list: any[]): boolean;
     reset(): void;
     getSet(): any[];
     isEmpty(): boolean;

package/lib/CustomPermutationGenerator.js

@@ -1,166 +1,125 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CustomPermutationGenerator = void 0;
-var PermutationGeneratorForSet_1 = require("./PermutationGeneratorForSet");
-var CustomPermutationGenerator = /** @class */ (function () {
-    // choicesByIndex: wisheds, unChoicesByIndex: unwisheds type is not but like SlotForPerson[], since it is a object instead of array
-    function CustomPermutationGenerator(elementList, choicesByIndex, // ChoicesByIndex is relative to sub-sch so we need elementsIndexRel, a index list of sub-sch
-    nonChoicesByIndex, // nonChoices is also relative
-    elementsOrderAbs, // Actual orders in final schdule
-    elementsIndexRel, // Actual relative orders in sub-schedule
-    passFunction, randomizechoices) {
-        if (choicesByIndex === void 0) { choicesByIndex = {}; }
-        if (nonChoicesByIndex === void 0) { nonChoicesByIndex = {}; }
-        if (elementsIndexRel === void 0) { elementsIndexRel = []; }
+const PermutationGeneratorForSet_1 = require("./PermutationGeneratorForSet");
+class CustomPermutationGenerator {
+    constructor(elementList, choicesByIndex = {}, nonChoicesByIndex = {}, elementsOrderAbsolute, passFunction) {
         this.elementList = elementList;
         this.choicesByIndex = choicesByIndex;
         this.nonChoicesByIndex = nonChoicesByIndex;
-        this.elementsOrderAbs = elementsOrderAbs;
-        this.elementsIndexRel = elementsIndexRel;
+        this.elementsOrderAbsolute = elementsOrderAbsolute;
         this.passFunction = passFunction;
-        this.randomizechoices = randomizechoices;
         this.nextIndexList = [];
-        this.choicesByIndexInSet = {}; // index of each choices in set
-        this.history = []; // Permutation history
-        this.historyHashes = []; // Permutation hashes, being used to distinguish new perm from olds
-        this.current = []; // keeps the current perm of set
+        this.finalChoicesByIndexInSet = {};
+        this.history = [];
+        this.historyHashes = [];
+        this.current = [];
         this.cursor = 0;
-        var indexList = Array(elementList.length).fill(0).map(function (el, ind) { return ind; });
-        this.set = elementList.reduce(function (init, el, i) { return elementList.indexOf(el) == i ? init.concat(el) : init; }, []);
-        this.setAsStr = this.set.map(function (x) { return String(x); });
-        this.init();
-        // debugger
-        // Optimization: Take same element indexes and when removeing one remove all
-        var indexesOfSameElements = {};
-        elementList.forEach(function (element, i) {
+        const indexList = Array(elementList.length)
+            .fill(0)
+            .map((_, ind) => ind);
+        this.set = Array.from(new Set(elementList));
+        const indexesOfSameElements = {};
+        elementList.forEach((element, i) => {
             indexesOfSameElements[i] = [];
-            // Zero means noone
-            // if (element == 0) {
-            //   // indexesOfSameElements[i] = [i]; // To make an illusion such that zero is different than zero, to make it possible to be consecutive
-            //   return;
-            // }
-            elementList.forEach(function (innerElement, j) {
-                if (element == innerElement) {
+            elementList.forEach((el, j) => {
+                if (element === el) {
                     indexesOfSameElements[i].push(j);
                 }
             });
         });
-        // Can be uncomment, since it will increase the permutation number but it should be remain for exact results
         this.extendIndexesOfSameElements(this.choicesByIndex, indexesOfSameElements);
-        // not make for choicesByIndex list so that options be little
         this.extendIndexesOfSameElements(this.nonChoicesByIndex, indexesOfSameElements);
-        // let choicesByIndexInSetFiltered = Object.keys(this.choicesByIndexInSet).filter(x => elementsIndexRel.indexOf(Number(x)) >= 0)
-        //   .map(x => this.choicesByIndexInSet[x]);
-        // Same like above
-        // for(let i = 0; i < this.elementsIndexRel.length; i++) {
-        //   choicesByIndexInSetFiltered[i] = this.choicesByIndexInSet[elementsIndexRel[i]]
-        // }
-        this.permutationGenOfSet = new PermutationGeneratorForSet_1.PermutationGeneratorForSet(elementList, indexList, this.choicesByIndexInSet, indexesOfSameElements, elementsOrderAbs, passFunction, randomizechoices);
-    }
-    // collect indexes of same elements into nonChoicesByIndex array, eg, slot1 should be placed by person 1 whose indexes are 3,4,5
-    CustomPermutationGenerator.prototype.extendIndexesOfSameElements = function (choicesByIndex, indexesOfSameElements) {
-        if (!choicesByIndex) {
-            return;
-        }
-        var choicesIndexKeys = Object.keys(choicesByIndex);
-        for (var i = 0; i < choicesIndexKeys.length; i++) {
-            var key = choicesIndexKeys[i];
-            if (choicesByIndex[key]) {
-                for (var j = 0; j < choicesByIndex[key].length; j++) {
-                    var ar = choicesByIndex[key].slice();
-                    // debugger
-                    if ((indexesOfSameElements[choicesByIndex[key][j]] || []).indexOf(choicesByIndex[key][j]) >= 0) {
-                        ar = ar.concat(indexesOfSameElements[choicesByIndex[key][j]]);
-                    }
-                }
-                choicesByIndex[key] = ar ? ar.filter(function (el, i) { return ar.indexOf(el) == i; }) : [];
-            }
-        }
-    };
-    // ? Need indexes to make a set, since element list may not be distinct
-    CustomPermutationGenerator.prototype.init = function () {
         if (this.nonChoicesByIndex) {
-            this.removeNonChoicesIndexes(); // Since set is changed to indexes, choices should be converted also to indexes
+            this.removeNonChoicesIndexes();
         }
         if (this.choicesByIndex) {
-            this.setChoicesIndexesInSet(); // Since set is changed to indexes, choices should be converted also to indexes
+            this.setChoicesIndexesInSet();
         }
-        this.completeMissingChoicesIndexes();
-    };
-    CustomPermutationGenerator.prototype.completeMissingChoicesIndexes = function () {
-        var allIndexes = Array(this.elementList.length).fill(0).map(function (x, i) { return i; });
-        for (var i = 0; i < this.elementList.length; i++) {
-            if (!this.choicesByIndexInSet[i]) {
-                this.choicesByIndexInSet[i] = allIndexes.slice();
-            }
-        }
-    };
-    // Index of choices in set
-    CustomPermutationGenerator.prototype.setChoicesIndexesInSet = function () {
-        var _this = this;
-        Object.keys(this.choicesByIndex).forEach(function (key) {
-            if (!_this.choicesByIndex[key])
-                return; //?? bu gives error
-            var indexesInList = [];
-            for (var j = 0; j < _this.choicesByIndex[key].length; j++) {
-                indexesInList = indexesInList.concat(_this.getAllIndexesOfElementInList(String(_this.choicesByIndex[key][j]), _this.elementList));
+        this.completeRestOfIndexes();
+        this.permutationGenOfSet = new PermutationGeneratorForSet_1.PermutationGeneratorForSet(elementList, indexList, this.finalChoicesByIndexInSet, indexesOfSameElements, this.elementsOrderAbsolute, passFunction);
+    }
+    removeNonChoicesIndexes() {
+        const allIndexes = Array(this.elementList.length)
+            .fill(0)
+            .map((x, i) => i);
+        Object.keys(this.nonChoicesByIndex).forEach((key) => {
+            let indexes = allIndexes.slice();
+            for (const el of this.nonChoicesByIndex[key]) {
+                const indexesToRemove = this.getAllIndexesOfElementInList(el, this.elementList);
+                indexes = indexes.filter((x) => indexesToRemove.indexOf(x) < 0);
             }
-            _this.choicesByIndexInSet[key] = indexesInList;
+            this.finalChoicesByIndexInSet[key] = indexes;
         });
-    };
-    CustomPermutationGenerator.prototype.removeNonChoicesIndexes = function () {
-        var _this = this;
-        var allIndexes = Array(this.elementList.length).fill(0).map(function (x, i) { return i; });
-        Object.keys(this.nonChoicesByIndex).forEach(function (key) {
-            var indexes = allIndexes.slice();
-            for (var j = 0; j < _this.nonChoicesByIndex[key].length; j++) {
-                var indexesToRemove = _this.getAllIndexesOfElementInList(_this.nonChoicesByIndex[key][j], _this.elementList);
-                indexes = indexes.filter(function (x) { return indexesToRemove.indexOf(x) < 0; });
+    }
+    setChoicesIndexesInSet() {
+        for (const key in this.choicesByIndex) {
+            if (!this.choicesByIndex[key]) {
+                continue;
             }
-            _this.choicesByIndexInSet[key] = indexes;
-        });
-    };
-    CustomPermutationGenerator.prototype.getAllIndexesOfElementInList = function (el, list) {
-        var indexes = [];
-        for (var i = 0; i < list.length; i++) {
-            if (String(el) == String(list[i])) {
+            let indexesInList = [];
+            for (const el of this.choicesByIndex[key]) {
+                indexesInList = indexesInList.concat(this.getAllIndexesOfElementInList(el, this.elementList));
+            }
+            this.finalChoicesByIndexInSet[key] = indexesInList;
+        }
+    }
+    getAllIndexesOfElementInList(el, list) {
+        const indexes = [];
+        for (let i = 0; i < list.length; i++) {
+            if (String(el) === String(list[i])) {
                 indexes.push(i);
             }
         }
         return indexes;
-    };
-    CustomPermutationGenerator.prototype.prev = function () {
-        if (this.cursor > 1) { // cursor-1 is current, cursor-2 is prev
-            return this.history[--this.cursor - 1];
+    }
+    completeRestOfIndexes() {
+        const allIndexes = Array(this.elementList.length)
+            .fill(0)
+            .map((x, i) => i);
+        for (let i = 0; i < this.elementList.length; i++) {
+            if (!this.finalChoicesByIndexInSet[i]) {
+                this.finalChoicesByIndexInSet[i] = allIndexes.slice();
+            }
         }
-    };
-    CustomPermutationGenerator.prototype.next = function () {
-        var nextDistinct;
-        while (true) {
-            nextDistinct = this.nextDistinct();
-            if (nextDistinct && !nextDistinct.done) {
-                if (nextDistinct.value) {
-                    return nextDistinct.value;
-                }
-                else {
-                    return [];
+    }
+    extendIndexesOfSameElements(choicesByIndex, indexesOfSameElements) {
+        if (!choicesByIndex) {
+            return;
+        }
+        for (const key in choicesByIndex) {
+            if (choicesByIndex[key]) {
+                let clone;
+                for (const anotherKey of choicesByIndex[key]) {
+                    clone = choicesByIndex[key].slice();
+                    if ((indexesOfSameElements[anotherKey] || []).indexOf(anotherKey) >= 0) {
+                        clone = clone.concat(indexesOfSameElements[anotherKey]);
+                    }
                 }
-            }
-            else if (nextDistinct && nextDistinct.done) {
-                return null; // PermResultTypeEnum.ENDOFPERMUTATION;
+                choicesByIndex[key] = clone ? clone.filter((el, idx) => clone.indexOf(el) === idx) : [];
             }
         }
-    };
-    CustomPermutationGenerator.prototype.nextDistinct = function () {
+    }
+    prev() {
+        if (this.cursor > 1) {
+            // cursor-1 is current, cursor-2 is prev
+            return this.history[--this.cursor - 1];
+        }
+    }
+    next() {
+        let nextDistinctPerm = this.nextDistinct();
+        return !nextDistinctPerm.done ? nextDistinctPerm.value : null;
+    }
+    nextDistinct() {
         if (this.cursor < this.history.length) {
             return { value: this.history[this.cursor++], done: false };
         }
-        var nextPerm = this.permutationGenOfSet.next();
+        const nextPerm = this.permutationGenOfSet.next();
         this.nextIndexList = nextPerm.value;
-        var elList;
+        let elList;
         if (this.nextIndexList && this.nextIndexList.length > 0) {
             elList = this.getElementListByInitialListIndexes(nextPerm.value);
-            var hash = this.getHash(elList);
+            const hash = this.getHash(elList);
             if (this.historyHashes.indexOf(hash) < 0 && (!this.passFunction || this.passFunction(elList))) {
                 this.current = elList;
                 this.history.push(elList);
@@ -168,70 +127,60 @@ var CustomPermutationGenerator = /** @class */ (function () {
                 this.cursor++;
             }
             else {
-                return false;
+                return this.nextDistinct();
             }
         }
         return { done: nextPerm.done, value: elList };
-    };
-    CustomPermutationGenerator.prototype.saveCurrentToHistory = function () {
+    }
+    saveCurrentToHistory() {
         this.history.push(this.current);
-        var hash = this.getHash(this.current);
+        const hash = this.getHash(this.current);
         this.historyHashes.push(hash);
         this.cursor++;
-    };
-    CustomPermutationGenerator.prototype.getHash = function (elList) {
-        var hash = '';
-        for (var i = 0; i < elList.length; i++) {
-            for (var j = 0; j < i + 1; j++) {
+    }
+    getHash(elList) {
+        let hash = '';
+        for (let i = 0; i < elList.length; i++) {
+            for (let j = 0; j < i + 1; j++) {
                 hash += String(elList[i]);
             }
         }
         return hash;
-    };
-    CustomPermutationGenerator.prototype.getElementListByInitialListIndexes = function (indexes) {
-        var _this = this;
+    }
+    getElementListByInitialListIndexes(indexes) {
         if (!indexes || !indexes.length) {
             return [];
         }
-        var elList = [];
-        indexes.forEach(function (index) {
+        const elList = [];
+        indexes.forEach((index) => {
             // if(this.elementList[index]) // Can be added, but costly
             {
-                elList.push(_this.elementList[index]);
+                elList.push(this.elementList[index]);
             }
         });
         return elList;
-    };
-    CustomPermutationGenerator.prototype.consecutiveDifferent = function (list) {
-        for (var i = 1; i < list.length; i++) {
-            if (list[i] == list[i - 1]) {
-                return false;
-            }
-        }
-        return true;
-    };
-    CustomPermutationGenerator.prototype.reset = function () {
+    }
+    reset() {
         this.cursor = 0;
-    };
-    CustomPermutationGenerator.prototype.getSet = function () {
+    }
+    getSet() {
         return this.set || [];
-    };
-    CustomPermutationGenerator.prototype.isEmpty = function () {
+    }
+    isEmpty() {
         return !this.set || this.set.length === 0;
-    };
-    CustomPermutationGenerator.prototype.getCurrent = function () {
+    }
+    getCurrent() {
         if (this.cursor < this.history.length && this.cursor >= 0) {
             return this.history[this.cursor];
         }
         else {
             return null;
         }
-    };
-    CustomPermutationGenerator.prototype.last = function () {
+    }
+    last() {
         this.cursor = this.history.length - 1;
         return this.history[this.cursor];
-    };
-    return CustomPermutationGenerator;
-}());
+    }
+}
 exports.CustomPermutationGenerator = CustomPermutationGenerator;
 //# sourceMappingURL=CustomPermutationGenerator.js.map