custom-permutation 1.0.6 → 1.1.0

package/README.md

@@ -1,60 +1,108 @@
+# 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
 
-```typescript
+## 1.1. `require`
+```ts
+const CustomPermutation = require('custom-permutation')
+```
+## 1.2. ,`import`
+
+```ts
+import CustomPermutation from "custom-permutation";
+```
+
+## 2. Constructor
+```ts
 CustomPermutation(elList:[els...], choices:{ index: [els...]] }, nonChoices:{ index: [els...]] })
 ```
 
-_example:_\
-`CustomPermutation(['a', 'b', 'c'], {1: ['a', 'b']}, {0: ['a']})`
+## 3. Usage explanation
+
+_example:_
 
-Permutate 3 elements which are 'a', 'b' and 'c' with below rules
+```ts
+CustomPermutation(["a", "b", "c"], {1: ["a", "b"]}, {0: ["a"]})
+```
+
+Permutate 3 elements which are "a", "b" and "c" with below rules
 
-__1. choices rule:__ `{ 1: ['a', 'b'] }`
+__- choices rule:__
+```json
+{ "1": ["a", "b"] }
+```
 
-    At index=1 there can be just 'a' or 'b'
+    At index=1 there can only be the element "a" or "b"
 
-__2. nonChoices rule:__ `{ 0: ['a'] }`
+__- nonChoices rule:__
+```json
+{ "0": ["a"] }
+```
 
-    At index=0 there can NOT be 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]_
+_Note: given index are considered as 0 based: [index=0, index=1, etc.]_
 
-__Result set:__
+## 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.
-```javascript
-    let customPerm = new CustomPermutation(['a', 'b', 'c'], { 1: ['a', 'b'] }, { 0: ['a'] });
-    let gen = customPerm.generator();
-    while (true) {
-        let next = gen.next();
-        if (next.done) {
-            break;
-        }
-        console.log(next.value)
-    }
-
-```
-or
-```javascript
-    let customPerm = new CustomPermutation(['a', 'b', 'c'], { 1: ['a', 'b'] }, { 0: ['a'] });
-    while (true) {
-        let next = customPerm.next();
-        if (!next) {
-            break;
-        }
-        console.log(next)
-    }
-```
-
-__Console__\
-['b', 'a', 'c']\
-['c', 'a', 'b']\
-['c', 'b', 'a']
+
+## 5. Complete example
+
+### 1. Create permutation
+
+```ts
+let customPerm = new CustomPermutation(
+    ["a", "b", "c"],
+    { "1": ["a", "b"] },
+    { "0": ["a"] }
+);
+```
+
+### 2. Get next value
+
+#### 2.1. Use with next
+
+```ts
+let next = customPerm.next();
+
+while (next) {
+    console.log(next)
+    next = customPerm.next();
+}
+```
+
+#### 2.2. Or use with generator
+
+```ts
+let generator = customPerm.generator();
+let next = generator.next();
+
+while (!next.done) {
+    console.log(next.value)
+    next = generator.next();
+}
+```
+
+### 3. Output
+
+__Console__
+
+```sh
+["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;