@elara-services/packages 5.3.1 → 6.0.1

package/dist/src/lib/languages.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Languages = void 0;
+const utils_1 = require("@elara-services/utils");
+const langs = {
+    en: "English",
+    fr: "French",
+    es: "Spanish",
+    pt: "Portuguese",
+    tr: "Turkish",
+    ru: "Russian",
+    ar: "Arabic",
+    af: "Afrikaans",
+    sq: "Albanian",
+    am: "Amharic",
+    hy: "Armenian",
+    az: "Azerbaijani",
+    eu: "Basque",
+    be: "Belarusian",
+    bn: "Bengali",
+    bs: "Bosnian",
+    bg: "Bulgarian",
+    ca: "Catalan",
+    ceb: "Cebuano",
+    ny: "Chichewa",
+    zh: "Chinese (Simplified)",
+    "zh-tw": "Chinese (Traditional)",
+    co: "Corsican",
+    hr: "Croatian",
+    cs: "Czech",
+    da: "Danish",
+    nl: "Dutch",
+    eo: "Esperanto",
+    et: "Estonian",
+    tl: "Filipino",
+    fi: "Finnish",
+    fy: "Frisian",
+    gl: "Galician",
+    ka: "Georgian",
+    de: "German",
+    el: "Greek",
+    gu: "Gujarati",
+    ht: "Haitian Creole",
+    ha: "Hausa",
+    haw: "Hawaiian",
+    he: "Hebrew",
+    iw: "Hebrew",
+    hi: "Hindi",
+    hmn: "Hmong",
+    hu: "Hungarian",
+    is: "Icelandic",
+    ig: "Igbo",
+    id: "Indonesian",
+    ga: "Irish",
+    it: "Italian",
+    ja: "Japanese",
+    jw: "Javanese",
+    kn: "Kannada",
+    kk: "Kazakh",
+    km: "Khmer",
+    ko: "Korean",
+    ku: "Kurdish (Kurmanji)",
+    ky: "Kyrgyz",
+    lo: "Lao",
+    la: "Latin",
+    lv: "Latvian",
+    lt: "Lithuanian",
+    lb: "Luxembourgish",
+    mk: "Macedonian",
+    mg: "Malagasy",
+    ms: "Malay",
+    ml: "Malayalam",
+    mt: "Maltese",
+    mi: "Maori",
+    mr: "Marathi",
+    mn: "Mongolian",
+    my: "Myanmar (Burmese)",
+    ne: "Nepali",
+    no: "Norwegian",
+    ps: "Pashto",
+    fa: "Persian",
+    pl: "Polish",
+    pa: "Punjabi",
+    ro: "Romanian",
+    sm: "Samoan",
+    gd: "Scots Gaelic",
+    sr: "Serbian",
+    st: "Sesotho",
+    sn: "Shona",
+    sd: "Sindhi",
+    si: "Sinhala",
+    sk: "Slovak",
+    sl: "Slovenian",
+    so: "Somali",
+    su: "Sundanese",
+    sw: "Swahili",
+    sv: "Swedish",
+    tg: "Tajik",
+    ta: "Tamil",
+    te: "Telugu",
+    th: "Thai",
+    uk: "Ukrainian",
+    ur: "Urdu",
+    uz: "Uzbek",
+    vi: "Vietnamese",
+    cy: "Welsh",
+    xh: "Xhosa",
+    yi: "Yiddish",
+    yo: "Yoruba",
+    zu: "Zulu",
+};
+exports.Languages = {
+    langs,
+    find(name) {
+        for (const key of (0, utils_1.getKeys)(langs)) {
+            if (key === name) {
+                return key;
+            }
+            if (langs[key] === name) {
+                return key;
+            }
+        }
+        return null;
+    },
+};

package/dist/src/lib/minesweeper.d.ts

@@ -0,0 +1,20 @@
+export declare class Minesweeper {
+    rows: number;
+    columns: number;
+    mines: number;
+    matrix: string[][];
+    types: {
+        mine: string;
+        numbers: string[];
+    };
+    constructor(opts: {
+        rows?: number;
+        columns?: number;
+        mines?: number;
+        emote?: string;
+    });
+    generateEmptyMatrix(): void;
+    plantMines(): void;
+    getNumberOfMines(x: number, y: number): string;
+    start(): string[][] | null;
+}

package/dist/src/lib/minesweeper.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Minesweeper = void 0;
+class Minesweeper {
+    constructor(opts) {
+        var _a, _b, _c, _d;
+        this.rows = (_a = opts === null || opts === void 0 ? void 0 : opts.rows) !== null && _a !== void 0 ? _a : 5;
+        this.columns = (_b = opts === null || opts === void 0 ? void 0 : opts.columns) !== null && _b !== void 0 ? _b : 5;
+        this.mines = (_c = opts === null || opts === void 0 ? void 0 : opts.mines) !== null && _c !== void 0 ? _c : 5;
+        this.matrix = [];
+        this.types = {
+            mine: (_d = opts === null || opts === void 0 ? void 0 : opts.emote) !== null && _d !== void 0 ? _d : "bomb",
+            numbers: [
+                "zero",
+                "one",
+                "two",
+                "three",
+                "four",
+                "five",
+                "six",
+                "seven",
+                "eight",
+            ],
+        };
+    }
+    generateEmptyMatrix() {
+        for (let i = 0; i < this.rows; i++) {
+            const arr = new Array(this.columns).fill(this.types.numbers[0]);
+            this.matrix.push(arr);
+        }
+    }
+    plantMines() {
+        for (let i = 0; i < this.mines; i++) {
+            const x = Math.floor(Math.random() * this.rows);
+            const y = Math.floor(Math.random() * this.columns);
+            if (this.matrix[x][y] === this.types.mine) {
+                i--;
+            }
+            else {
+                this.matrix[x][y] = this.types.mine;
+            }
+        }
+    }
+    getNumberOfMines(x, y) {
+        if (this.matrix[x][y] === this.types.mine) {
+            return this.types.mine;
+        }
+        let counter = 0;
+        const hasLeft = y > 0;
+        const hasRight = y < this.columns - 1;
+        const hasTop = x > 0;
+        const hasBottom = x < this.rows - 1;
+        counter += +(hasTop &&
+            hasLeft &&
+            this.matrix[x - 1][y - 1] === this.types.mine);
+        counter += +(hasTop && this.matrix[x - 1][y] === this.types.mine);
+        counter += +(hasTop &&
+            hasRight &&
+            this.matrix[x - 1][y + 1] === this.types.mine);
+        counter += +(hasLeft && this.matrix[x][y - 1] === this.types.mine);
+        counter += +(hasRight && this.matrix[x][y + 1] === this.types.mine);
+        counter += +(hasBottom &&
+            hasLeft &&
+            this.matrix[x + 1][y - 1] === this.types.mine);
+        counter += +(hasBottom && this.matrix[x + 1][y] === this.types.mine);
+        counter += +(hasBottom &&
+            hasRight &&
+            this.matrix[x + 1][y + 1] === this.types.mine);
+        return this.types.numbers[counter];
+    }
+    start() {
+        if (this.rows * this.columns <= this.mines * 2) {
+            return null;
+        }
+        this.generateEmptyMatrix();
+        this.plantMines();
+        this.matrix = this.matrix.map((row, x) => row.map((col, y) => this.getNumberOfMines(x, y)));
+        return this.matrix;
+    }
+}
+exports.Minesweeper = Minesweeper;

package/dist/src/lib/misc.d.ts

@@ -0,0 +1 @@
+export declare function fetch<B extends object, T>(url: string, key?: string, body?: B | undefined, postRequest?: boolean, returnRaw?: boolean): Promise<T | null>;

package/dist/src/lib/misc.js

@@ -0,0 +1,73 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetch = void 0;
+function fetch(url, key = "", body = undefined, postRequest = false, returnRaw = false) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const client = yield Promise.resolve().then(() => __importStar(require("@elara-services/fetch"))).catch(() => { });
+            if (!client) {
+                throw new Error(`NPM package (@elara-services/fetch) now found`);
+            }
+            const headers = {
+                "User-Agent": `Services v${Math.floor(Math.random() * 999999)}`,
+                authorization: "",
+            };
+            if (key !== "" && key) {
+                headers["authorization"] = key;
+            }
+            else {
+                // @ts-expect-error
+                delete headers["authorization"];
+            }
+            const res = yield client
+                .fetch(url, postRequest ? "POST" : "GET")
+                .header(headers)
+                .body(body, "json")
+                .send()
+                .catch(() => ({ statusCode: 500, body: "", json: () => "" }));
+            if (res.statusCode !== 200) {
+                return null;
+            }
+            if (returnRaw) {
+                return res.body;
+            }
+            return res.json();
+        }
+        catch (_a) {
+            return null;
+        }
+    });
+}
+exports.fetch = fetch;

package/dist/src/lib/random.d.ts

@@ -0,0 +1,16 @@
+export declare function randomWeight<T>(objects: (T & {
+    weight: number;
+})[]): (T & {
+    weight: number;
+}) | undefined;
+export interface RandomWord {
+    exactly?: boolean;
+    maxLength?: number;
+    min?: number;
+    max?: number;
+    wordsPerString?: number;
+    formatter(word: string | undefined, relativeIndex?: number): void;
+    separator: string;
+    join: string;
+}
+export declare function randomWords(options: RandomWord): string | string[];