ts-client-lib 0.0.7

package/games/TSLotto.js

@@ -0,0 +1,205 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TSLotto = void 0;
+var TSNumber_1 = require("../utils/TSNumber");
+var TSLotto = /** @class */ (function () {
+    function TSLotto(options) {
+        if (options === void 0) { options = { max: 36, pick: 3, extra: 2, tickets: 5 }; }
+        var _this = this;
+        this.numbers = [];
+        this.selections = [];
+        this.bonus = [];
+        this.options = options;
+        this.numbers = Array.from({ length: options.max }, function (v, i) { return i + 1; });
+        this.selections = Array.from({ length: options.tickets }, function () { return _this.emptyLine(options.pick); });
+        if (options.extra) {
+            this.bonus = Array.from({ length: options.tickets }, function () { return _this.emptyLine(options.extra); });
+        }
+        if (this.options.randomize) {
+            this.selections.forEach(function (l, i) {
+                _this.fillLine(l);
+                if (options.extra) {
+                    _this.fillLine(_this.bonus[i], l);
+                }
+            });
+        }
+    }
+    Object.defineProperty(TSLotto.prototype, "render", {
+        get: function () {
+            var _this = this;
+            var sortNumber = function (a, b) { return a - b; }, formatLines = function () {
+                var lines = [];
+                _this.selections.forEach(function (l, i) {
+                    if (_this.options.sort) {
+                        lines[i] = _this.selections[i] = _this.selections[i].sort(sortNumber);
+                        if (_this.options.extra) {
+                            _this.bonus[i] = _this.bonus[i].sort(sortNumber);
+                            lines[i] = lines[i].concat(_this.bonus[i]);
+                        }
+                    }
+                    else {
+                        lines[i] = _this.selections[i];
+                        if (_this.options.extra) {
+                            lines[i] = lines[i].concat(_this.bonus[i]);
+                        }
+                    }
+                });
+                return { selections: _this.selections, bonus: _this.bonus, lines: lines };
+            };
+            return __assign(__assign({ options: this.options }, formatLines()), { numbers: this.numbers });
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(TSLotto.prototype, "lotto", {
+        set: function (data) {
+            this.options = data.options;
+            this.selections = data.selections;
+            this.bonus = data.bonus;
+            this.numbers = data.numbers;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    TSLotto.prototype.fillLine = function (line, existingLine) {
+        if (existingLine === void 0) { existingLine = []; }
+        var index = line.findIndex(Number.isNaN);
+        while (index > -1) {
+            var random = TSNumber_1.TSNumber.random(1, this.options.max);
+            if (line.indexOf(random) === -1 && existingLine.indexOf(random) === -1) {
+                line[index] = random;
+            }
+            index = line.findIndex(Number.isNaN);
+        }
+    };
+    TSLotto.prototype.randomLine = function (index) {
+        this.clearLine(index);
+        this.fillLine(this.selections[index], this.bonus[index]);
+        if (this.options.extra) {
+            this.fillLine(this.bonus[index], this.selections[index]);
+        }
+    };
+    TSLotto.prototype.addLine = function (line) {
+        var _this = this;
+        if (line) {
+            var lineLength = this.options.pick + this.options.extra;
+            this.selections.unshift([]);
+            this.selections[0] = line.slice(0, this.options.pick);
+            if (this.options.extra) {
+                this.bonus.unshift([]);
+                this.bonus[0] = line.slice(this.options.pick, lineLength);
+            }
+            if (this.selections[0].length + (this.bonus[0] ? this.bonus[0].length : 0) !== lineLength) {
+                this.deleteLine(0);
+                return -2;
+            }
+            else if (this.validateLine(0)) {
+                this.deleteLine(0);
+                return -1;
+            }
+            return 0;
+        }
+        else {
+            this.selections.push(this.emptyLine(this.options.pick));
+            this.bonus.push(this.emptyLine(this.options.extra));
+            var lastIndex_1 = this.selections.length - 1;
+            if (this.options.randomize) {
+                this.selections.forEach(function () {
+                    _this.fillLine(_this.selections[lastIndex_1]);
+                    if (_this.options.extra) {
+                        _this.fillLine(_this.bonus[lastIndex_1], _this.selections[lastIndex_1]);
+                    }
+                });
+            }
+            return lastIndex_1;
+        }
+    };
+    TSLotto.prototype.shufleLines = function () {
+        var _this = this;
+        this.selections.forEach(function (s, i) { return _this.randomLine(i); });
+    };
+    TSLotto.prototype.adjustLines = function (tickets) {
+        this.options.tickets = tickets;
+        var count = this.selections.length;
+        for (var j = 0; j < Math.abs(tickets - count); j++) {
+            if (tickets - count > 0) {
+                this.addLine();
+            }
+            else {
+                this.deleteLine(this.render.lines.length - 1);
+            }
+        }
+    };
+    TSLotto.prototype.clearLine = function (index) {
+        this.selections[index] = this.emptyLine(this.options.pick);
+        this.bonus[index] = this.emptyLine(this.options.extra);
+    };
+    TSLotto.prototype.deleteLine = function (index) {
+        this.bonus.splice(index, 1);
+        this.selections.splice(index, 1);
+    };
+    TSLotto.prototype.emptyLine = function (length) {
+        return Array.from({ length: length }, function () { return NaN; });
+    };
+    TSLotto.prototype.validateLine = function (index) {
+        var _this = this;
+        var l = this.selections[index].concat(this.bonus[index] || []);
+        return l.some(function (v, i) { return l.indexOf(v) !== i || (v > _this.options.max || v < 1); });
+    };
+    TSLotto.prototype.clear = function () {
+        var _this = this;
+        this.selections.forEach(function (v, i) { return _this.clearLine(i); });
+    };
+    TSLotto.prototype.toggle = function (line, index) {
+        var sli = this.selections[line].indexOf(this.numbers[index]), bli = this.bonus[line] && this.bonus[line].length ? this.bonus[line].indexOf(this.numbers[index]) : -1, isFull = sli === -1 && bli === -1 && this.isComplete(line);
+        if (isFull) {
+            return;
+        }
+        else if (sli > -1) {
+            this.selections[line][sli] = NaN;
+            return;
+        }
+        else if (bli > -1) {
+            this.bonus[line][bli] = NaN;
+            return;
+        }
+        var s = this.selections[line].findIndex(Number.isNaN), b = this.bonus[line] && this.bonus[line].length ? this.bonus[line].findIndex(Number.isNaN) : -1;
+        if (s > -1 && bli === -1 && sli === -1) {
+            this.selections[line][s] = this.numbers[index];
+        }
+        else if (b > -1 && sli === -1) {
+            this.bonus[line][b] = this.numbers[index];
+        }
+    };
+    TSLotto.prototype.isComplete = function (index) {
+        var _this = this;
+        var isLineComplete = function (i) {
+            var hasNaN = _this.selections[i].findIndex(Number.isNaN) === -1;
+            if (_this.options.extra) {
+                hasNaN = hasNaN && _this.bonus[i].findIndex(Number.isNaN) === -1;
+            }
+            return hasNaN;
+        };
+        if (typeof index !== 'undefined') {
+            return isLineComplete(index);
+        }
+        else {
+            var isFull_1 = true;
+            this.selections.forEach(function (l, i) { return isFull_1 = isFull_1 && isLineComplete(i); });
+            return isFull_1;
+        }
+    };
+    return TSLotto;
+}());
+exports.TSLotto = TSLotto;

package/games/TSPool.d.ts

@@ -0,0 +1,28 @@
+export interface ITSPool {
+    matches: Array<any>;
+    reserve?: Array<any>;
+    stake: number;
+    size?: number;
+}
+export interface ITSPoolResult {
+    selected: Record<string, Array<string>>;
+    lines: number;
+    stake: number;
+    amount: number;
+    completed: boolean;
+}
+export declare class TSPool {
+    private params;
+    options: ITSPool;
+    result: ITSPoolResult;
+    private items;
+    private selected;
+    constructor(params: ITSPool);
+    toggleLine(k: string): ITSPoolResult;
+    favoriteLines(kItem?: string, property?: string): ITSPoolResult;
+    randomLines(kItem?: string): ITSPoolResult;
+    clearLines(): ITSPoolResult;
+    key(key: string): string;
+    private toggle;
+    private get calculate();
+}

package/games/TSPool.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TSPool = void 0;
+var TSNumber_1 = require("../utils/TSNumber");
+var TSObject_1 = require("../utils/TSObject");
+var TSString_1 = require("../utils/TSString");
+var TSPool = /** @class */ (function () {
+    function TSPool(params) {
+        this.params = params;
+        this.items = [];
+        this.selected = {};
+        if (!this.params.reserve) {
+            this.params.reserve = [];
+        }
+        this.options = this.params;
+        this.items = this.options.matches.concat(this.options.reserve);
+        this.options.size = this.items.length;
+        void this.calculate;
+    }
+    TSPool.prototype.toggleLine = function (k) {
+        this.toggle(k);
+        return this.calculate;
+    };
+    TSPool.prototype.favoriteLines = function (kItem, property) {
+        if (kItem === void 0) { kItem = 'oc'; }
+        if (property === void 0) { property = 'o'; }
+        this.clearLines();
+        for (var _i = 0, _a = this.items; _i < _a.length; _i++) {
+            var i = _a[_i];
+            var min = i[kItem].reduce(function (m, c, ci, pool) { return c[property] < pool[m][property] ? ci : m; }, 0);
+            this.toggle(i[kItem][min].sk);
+        }
+        return this.calculate;
+    };
+    TSPool.prototype.randomLines = function (kItem) {
+        if (kItem === void 0) { kItem = 'oc'; }
+        this.clearLines();
+        for (var _i = 0, _a = this.items; _i < _a.length; _i++) {
+            var i = _a[_i];
+            var k = TSNumber_1.TSNumber.random(0, i[kItem].length - 1);
+            this.toggle(i[kItem][k].sk);
+        }
+        return this.calculate;
+    };
+    TSPool.prototype.clearLines = function () {
+        this.selected = {};
+        return this.calculate;
+    };
+    TSPool.prototype.key = function (key) {
+        return TSString_1.TSString.splitBy(key, '_', 'first')[0];
+    };
+    TSPool.prototype.toggle = function (k) {
+        var key = this.key(k);
+        if (!this.selected[key]) {
+            this.selected[key] = [k];
+        }
+        else {
+            var iIndex = this.selected[key].findIndex(function (v) { return v === k; });
+            if (iIndex !== -1) {
+                this.selected[key].splice(iIndex, 1);
+            }
+            else {
+                this.selected[key].push(k);
+            }
+        }
+    };
+    Object.defineProperty(TSPool.prototype, "calculate", {
+        get: function () {
+            var lines = TSObject_1.TSObject.value(this.selected) ? 1 : 0, size = 0;
+            TSObject_1.TSObject.forOwn(this.selected, function (v) {
+                if (v.length) {
+                    lines *= v.length;
+                    size++;
+                }
+            });
+            this.result = {
+                stake: this.options.stake, amount: this.options.stake * lines,
+                lines: lines,
+                selected: this.selected, completed: size === this.options.size
+            };
+            return this.result;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return TSPool;
+}());
+exports.TSPool = TSPool;

package/package.json

@@ -0,0 +1,93 @@
+{
+  "name": "ts-client-lib",
+  "version": "0.0.7",
+  "scripts": {
+    "prepublishOnly": "npm run build",
+    "postpublish": "npm run clean:artifacts",
+    "build": "tsc --declaration -p .",
+    "watch": "tsc -w --declaration -p .",
+    "clean:artifacts": "node -e \"const fs=require('fs'),path=require('path');const root=process.cwd();for(const rel of ['auth','devices','entities','finance','games','utils']){const dir=path.join(root,rel);let n;try{n=fs.readdirSync(dir)}catch{continue}for(const name of n){if(!name.endsWith('.d.ts')&&path.extname(name)!=='.js')continue;const fp=path.join(dir,name);try{if(fs.statSync(fp).isFile())fs.unlinkSync(fp)}catch{}}}\"",
+    "clean:deps": "node -e \"for(const p of ['coverage','node_modules','package-lock.json'])try{require('fs').rmSync(p,{recursive:true,force:true})}catch{}\"",
+    "clean": "npm run clean:artifacts && npm run clean:deps",
+    "lint": "eslint . --fix --ignore-pattern \"**/*.d.ts\"",
+    "test": "npm run build && vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/onalbi/ts-client-lib"
+  },
+  "author": {
+    "name": "Albion Liçi",
+    "email": "lici.albion@gmail.com"
+  },
+  "keywords": [
+    "typescript",
+    "cordova",
+    "cache",
+    "heuristic"
+  ],
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/onalbi/ts-client-lib/issues"
+  },
+  "files": [
+    "auth/**/*.{js,d.ts}",
+    "devices/**/*.{js,d.ts}",
+    "entities/**/*.{js,d.ts}",
+    "finance/**/*.{js,d.ts}",
+    "games/**/*.{js,d.ts}",
+    "utils/**/*.{js,d.ts}"
+  ],
+  "peerDependencies": {
+    "reflect-metadata": "^0.2.2"
+  },
+  "devDependencies": {
+    "ts-common-lib": "latest"
+  },
+  "dependencies": {
+    "reflect-metadata": "^0.2.2"
+  },
+  "engines": {
+    "node": ">=20.12.1"
+  },
+  "vitest": {
+    "globals": true,
+    "environment": "node",
+    "include": [
+      "test/**/*.spec.ts"
+    ],
+    "exclude": [
+      "**/*.spec.js",
+      "**/node_modules/**"
+    ],
+    "resolve": {
+      "extensions": [
+        ".ts",
+        ".tsx",
+        ".mts",
+        ".cts",
+        ".js",
+        ".mjs",
+        ".jsx",
+        ".json"
+      ]
+    },
+    "coverage": {
+      "provider": "v8",
+      "include": [
+        "auth/**/*.ts",
+        "devices/**/*.ts",
+        "entities/**/*.ts",
+        "finance/**/*.ts",
+        "games/**/*.ts",
+        "utils/**/*.ts"
+      ],
+      "reporter": [
+        "text",
+        "lcov"
+      ]
+    }
+  }
+}

package/utils/TSArray.d.ts

@@ -0,0 +1,9 @@
+export declare class TSArray {
+    static indexOfPartial(items: Array<string> | undefined, needle: string): number;
+    static shuffle(array: any[]): any[];
+    static fn(compare: (value: any) => any, order?: 'asc' | 'desc'): (a: any, b: any) => 1 | -1 | 0;
+    static sort(reverse?: boolean, path?: string): (a: any, b: any) => 1 | -1 | 0;
+    static toPair(array: Array<any>): Record<string, unknown>;
+    private static compare;
+    private static g;
+}

package/utils/TSArray.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TSArray = void 0;
+var TSArray = /** @class */ (function () {
+    function TSArray() {
+    }
+    TSArray.indexOfPartial = function (items, needle) {
+        if (items === void 0) { items = []; }
+        for (var i in items) {
+            if (Object.hasOwn(items, i) && needle.indexOf(items[i]) !== -1) {
+                return parseInt(i, 10);
+            }
+        }
+        return -1;
+    };
+    TSArray.shuffle = function (array) {
+        var _a;
+        for (var i = array.length - 1; i > 0; i--) {
+            var j = Math.floor(Math.random() * (i + 1));
+            _a = [array[j], array[i]], array[i] = _a[0], array[j] = _a[1];
+        }
+        return array;
+    };
+    TSArray.fn = function (compare, order) {
+        if (order === void 0) { order = 'desc'; }
+        if (order === 'asc') {
+            return function (a, b) {
+                var va = compare(a), vb = compare(b);
+                if (vb > va)
+                    return -1;
+                if (va > vb)
+                    return 1;
+                return 0;
+            };
+        }
+        return function (a, b) {
+            var va = compare(a), vb = compare(b);
+            if (va > vb)
+                return -1;
+            if (vb > va)
+                return 1;
+            return 0;
+        };
+    };
+    TSArray.sort = function (reverse, path) {
+        var p = path !== null && path !== void 0 ? path : '';
+        return function (a, b) { return reverse ? TSArray.compare(a, b, p) : TSArray.compare(b, a, p); };
+    };
+    TSArray.toPair = function (array) {
+        var r = {};
+        for (var i = 0; i < array.length; i += 2) {
+            r[array[i]] = array[i + 1];
+        }
+        return r;
+    };
+    TSArray.compare = function (a, b, p) {
+        if (p) {
+            var gb = TSArray.g(b, p), ga = TSArray.g(a, p);
+            if (gb < ga)
+                return -1;
+            if (gb > ga)
+                return 1;
+            return 0;
+        }
+        if (b < a)
+            return -1;
+        if (b > a)
+            return 1;
+        return 0;
+    };
+    TSArray.g = function (object, path) {
+        var a = path.split('.');
+        while (a.length) {
+            var key = a.shift();
+            if (key === undefined) {
+                break;
+            }
+            object = object[key];
+            if (!object) {
+                break;
+            }
+        }
+        return object;
+    };
+    return TSArray;
+}());
+exports.TSArray = TSArray;

package/utils/TSBoolean.d.ts

@@ -0,0 +1,4 @@
+export declare class TSBoolean {
+    static parse(v: any): any;
+    static isEmpty(v: any): boolean;
+}

package/utils/TSBoolean.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TSBoolean = void 0;
+var TSBoolean = /** @class */ (function () {
+    function TSBoolean() {
+    }
+    TSBoolean.parse = function (v) {
+        if (typeof v === 'boolean') {
+            return v;
+        }
+        else if (/^\s*(true|1|on|yes|y)\s*$/i.test(v)) {
+            return true;
+        }
+        else if (/^\s*(false|0|off|no|n)\s*$/i.test(v)) {
+            return false;
+        }
+        return v;
+    };
+    TSBoolean.isEmpty = function (v) {
+        return v == null || /^\s*(null|undefined)\s*$/i.test(v);
+    };
+    return TSBoolean;
+}());
+exports.TSBoolean = TSBoolean;