randex 0.3.0 → 0.6.0

package/.vscode/settings.json

@@ -14,6 +14,7 @@
     "json"
   ],
   "cSpell.words": [
+    "Randex",
     "tebot"
   ],
 }

package/README.md

@@ -14,63 +14,110 @@ Installation:
 npm i randex
 ```
 
-- [`random` function](#random-function)
-- [randomFileName](#randomfilename)
-- [randomUsername](#randomfilename)
-- [randomEmail](#randomfilename)
-- [randomName](#randomfilename)
-- [randomFullName](#randomfilename)
+Functions:
 
+- [random](#random)
+- [randomFileName](#randomfilename)
+- [randomUsername](#randomusername)
+- [randomEmail](#randomemail)
+- [randomName](#randomname)
+- [randomFullName](#randomfullname)
 
-## `random` function
+## random
 
 Basic function for construct random thing.
 
 ```ts
-import { random } from 'randex';
-
+import { random } from "randex";
+
+// 3 english chars
+random({
+  set: "english",
+  length: 3,
+});
+// EFd
+
+// 3 lower english chars
+random({
+  set: ["english", "lower"],
+  length: 3,
+});
+// yhl
+
+// min 1 and max 3 english chars
+random({
+  set: "english",
+  length: [1, 3],
+});
+// eR
+
+// 3 number chars
+random({
+  set: "number",
+  length: 3,
+});
+// 643
+
+// 3 chars from custom range
+random({
+  range: "abc123",
+  length: 3,
+});
+// a21
+
+// 3 english or number chars
+random({
+  set: ["english", "number"],
+  length: 3,
+});
+
+// 4 chars: 2 english and 2 english or number
 random(
-    {
-        set: "alphabet",
-        length: 2,
-    },
-    {
-        set: ["alphabet", "number"],
-        length: 2,
-    }
+  {
+    set: "english",
+    length: 2,
+  },
+  {
+    set: ["english", "number"],
+    length: 2,
+  }
 );
-
-// gTo3
+// Kb3b
 ```
 
 Options:
-| Name                     |  Type| Description|
+| Name | Type| Description|
 | ------------------------ | ---- |------------ |
-|set| `hex`, `symbol`, `alphabet`, `alphabetLower`, `alphabetUpper`, `number`, `binary` | Set of predefined chars|
+|set|[RandexSet](#randexset) | Defined chars|
 |range|`string`| Range or custom chars |
-|length|`number`, `[number, number]` | Length or min and max length of chars are needed to be generated |
-
-
+|length|[RandexLength](#randexlength) | Length of chars |
 
 ## randomFileName
 
 Randoms file name.
 
 ```ts
-import { randomFileName } from 'randex';
+import { randomFileName } from "randex";
 
-randomFileName(
-    {
-        extension: 'txt'
-    },
-);
+randomFileName({
+  extension: "txt",
+});
 
-// FSCOuNN.txt
+// td1TX31eOB.txt
 ```
 
-Equals to: 
+Equals to:
+
 ```ts
-random([["alphabet", "number"], "_.", [5, 10]]) + random(["alphabet", "number"]) + "." + (extension ? extension : random(["alphabetLower", [2, 5]]));
+random([["english", "number"], "_.", [5, 10]]) +
+  random(["english", "number"]) +
+  "." +
+  (extension
+    ? extension
+    : random([
+        ["english", "l"],
+        [2, 5],
+      ]));
 ```
 
 ## randomUsername
@@ -78,82 +125,159 @@ random([["alphabet", "number"], "_.", [5, 10]]) + random(["alphabet", "number"])
 Randoms username.
 
 ```ts
-import { randomUsername } from 'randex';
-
+import { randomUsername } from "randex";
 
+// default (min - 6, max - 10 chars)
 randomUsername();
-
 // icvv81d1j
+
+// with length 5 chars
+randomUsername({ length: 5 });
+// okmle
+
+// with 2 min and 5 max chars
+randomName({ length: [2, 5] });
+// lkhs
+
 ```
 
-Equals to: 
+Equals to:
+
 ```ts
-random("alphabetLower", [
-    ["alphabetLower", "number"],
+random(
+  ["english", "l"],
+  [
+    [["english", "l"], "number"],
     [5, 10],
-  ]);
+  ]
+);
 ```
 
+Options:
+| Name | Type| Description|
+| ------------------------ | ---- |------------ |
+|length|[RandexLength](#randexlength) | Length of chars |
+
+
 ## randomEmail
 
 Randoms username.
 
 ```ts
-import { randomEmail } from 'randex';
+import { randomEmail } from "randex";
 
 
 randomEmail();
+// stv4ox27sevt@mqsyin.fil
 
-// dwrq4wu54nzj@dhvy.dtk
 ```
 
-Equals to: 
+Equals to:
+
 ```ts
-random("alphabetLower", [["alphabetLower", "number"], 10], "alphabetLower") +
-    "@" +
-    random("alphabetLower", ["alphabetLower", "-", [0, 5]], "alphabetLower") +
-    "." +
-    random(["alphabetLower", [2, 4]]);
+random(["english", "l"], [[["english", "l"], "number"], 10], ["english", "l"]) +
+  "@" +
+  random(["english", "l"], [["english", "l"], "-", [0, 5]], ["english", "l"]) +
+  "." +
+  random([
+    ["english", "l"],
+    [2, 4],
+  ]);
 ```
 
+
 ## randomName
 
 Randoms a name of the person, city, place, restaurant, ect.
 
 ```ts
-import { randomName } from 'randex';
-
+import { randomName } from "randex";
 
+// default (min - 2, max - 10 chars)
 randomName();
+// Ijb
+
+// name from french alphabet
+randomName({ alphabet: "french" });
+// Dbïœ
+
+// with length 5 chars
+randomName({ length: 5 });
+// Okmpj
 
-// Txotsaw
+// with 2 min and 5 max chars
+randomName({ length: [2, 5] });
+// Wslg
 ```
 
-Equals to: 
+Equals to:
+
 ```ts
-random("alphabetUpper", ["alphabetLower", [1, 10]]);
+random(
+  ["english", "u"],
+  [
+    ["english", "l"],
+    [1, 10],
+  ]
+);
 ```
 
 Options:
-| Name                     |  Type| Description|
+| Name | Type| Description|
 | ------------------------ | ---- |------------ |
-|length|`number`, `[number, number]` | Length or min and max length of chars are needed to be generated |
+|length|[RandexLength](#randexlength) | Length of chars |
+|alphabet|[RandexAlphabet](#randexalphabet) | Defined alphabet |
 
 ## randomFullName
 
 Randoms a full name of the person.
 
 ```ts
-import { randomFullName } from 'randex';
-
+import { randomFullName } from "randex";
 
 randomFullName();
-
 // Eqaa Bfmotnq
 ```
 
-Equals to: 
-```ts
-random("alphabetUpper", ["alphabetLower", [1, 10]]) + " " + random("alphabetUpper", ["alphabetLower", [1, 10]]);
-```
+Options:
+| Name | Type| Description|
+| ------------------------ | ---- |------------ |
+|firstLength|[RandexLength](#randexlength) | First name length of chars |
+|secondLength|[RandexLength](#randexlength) | Second name length of chars |
+|alphabet|[RandexAlphabet](#randexalphabet) | Defined alphabet |
+
+## Types
+
+## RandexLength
+
+Possible types:
+
+`number`: strict length
+
+`[number, number]`: an array of min and max length.
+
+## RandexSet
+
+Possible types:
+
+`string`: an alphabet - [RandexAlphabet](#randexalphabet) or a set of chars - [RandexKit](#randexkit)
+
+`[string, string]`: the first item is - [RandexAlphabet](#randexalphabet), the second item is - [RandexCase](#randexcase)
+
+## RandexAlphabet
+
+An alphabet of chars
+
+`string` values: `english`, `french`, `spanish`, `russian`.
+
+## RandexKit
+
+A kit of chars
+
+`string` values: `hex`, `symbol`, `number`, `binary`.
+
+## RandexCase
+
+A case of alphabet
 
+`string` values: `upper`, `u`,`lower`, `l`.

package/lib/basic/index.d.ts

@@ -1,2 +1,2 @@
-import { RandomPartOptions } from "../interfaces";
-export declare function random(...options: RandomPartOptions[]): string;
+import { RandexContentOptions } from "../interfaces";
+export declare function random(...options: RandexContentOptions[]): string;

package/lib/basic/index.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.random = void 0;
 var set_1 = require("./set");
+var type_1 = require("./type");
 function randomInt(max) {
     return Math.floor(Math.random() * max);
 }
@@ -18,56 +19,50 @@ function randomString(params) {
     }
     for (var i = 0; i < currentLength; i++) {
         var index = randomInt(range.length - 1);
-        result += range[index];
+        if (range.length >= index || range.length <= index) {
+            result += range[index];
+        }
     }
     return result;
 }
-function ifLengthType(value) {
-    return typeof value === "number" || Array.isArray(value);
-}
-function toFullOption(options) {
-    if (typeof options === "string") {
+function toContent(options) {
+    if (type_1.RandexTypeParser.isSet(options)) {
         return {
             set: options,
-            length: 1,
         };
     }
-    else if (Array.isArray(options)) {
+    else if (type_1.RandexTypeParser.isPartArray(options)) {
         if (options.length === 2) {
             var set = options[0], rangeOrLength = options[1];
-            var result = {
-                set: set,
-            };
-            if (ifLengthType(rangeOrLength)) {
-                result.length = rangeOrLength;
-            }
-            else {
-                result.range = rangeOrLength;
-            }
-            return result;
+            return type_1.RandexTypeParser.isLength(rangeOrLength)
+                ? {
+                    set: set,
+                    length: rangeOrLength,
+                }
+                : {
+                    set: set,
+                    range: rangeOrLength,
+                };
         }
-        if (options.length === 3 && ifLengthType(options[2])) {
+        else if (options.length === 3) {
+            var set = options[0], range = options[1], length_1 = options[2];
             return {
-                set: options[0],
-                range: options[1],
-                length: options[2],
+                set: set,
+                range: range,
+                length: length_1,
             };
         }
-        return {
-            set: options,
-            length: 1,
-        };
     }
     return options;
 }
-function toParam(options) {
+function toRangeOptions(options) {
     var fullRange = "";
     var set = options.set, range = options.range, _a = options.length, length = _a === void 0 ? 1 : _a;
     if (range) {
         fullRange += range;
     }
     if (set) {
-        fullRange += Array.isArray(set) ? set.map(function (x) { return set_1.RtSetUtil.toRange(x); }).join("") : set_1.RtSetUtil.toRange(set);
+        fullRange += set_1.RandexSetUtil.toRange(set);
     }
     return {
         range: fullRange,
@@ -82,8 +77,8 @@ function random() {
     var result = "";
     for (var _a = 0, options_1 = options; _a < options_1.length; _a++) {
         var option = options_1[_a];
-        var o = toFullOption(option);
-        var p = toParam(o);
+        var content = toContent(option);
+        var p = toRangeOptions(content);
         result += randomString(p);
     }
     return result;

package/lib/basic/set.d.ts

@@ -1,6 +1,8 @@
-import { RandomSet } from "../interfaces";
-export declare const alphabet: string;
-export declare class RtSetUtil {
+import { RandexSet, RandexLength } from "../interfaces";
+export declare class RandexSetUtil {
     private static toSingleRange;
-    static toRange(set: RandomSet): string;
+    private static toAlphabetCase;
+    private static toAlphabetRange;
+    static toRange(set: RandexSet): string;
+    static getLength(reservedChars: number, length: RandexLength | undefined, defaultLength: RandexLength): RandexLength;
 }

package/lib/basic/set.js

@@ -1,24 +1,30 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RtSetUtil = exports.alphabet = void 0;
-var alphabetUpper = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
-var alphabetLower = "abcdefghijklmnopqrstuvwxyz";
+exports.RandexSetUtil = void 0;
+var type_1 = require("./type");
 var hex = "0123456789ABCDEFabcdef";
 var symbol = '[-!$%^&*()_+|~=`{}[]:";<>?,./]' + "'";
-exports.alphabet = alphabetLower + alphabetUpper;
 var number = "0123456789";
 var binary = "01";
-var RtSetUtil = /** @class */ (function () {
-    function RtSetUtil() {
+var englishLower = "abcdefghijklmnopqrstuvwxyz";
+var englishUpper = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+var frenchLower = "abcdefghijklmnopqrstuvwxyzàâæçèéêëîïôœùûü";
+var frenchUpper = "ABCDEFGHIJKLMNOPQRSTUVWXYZÀÂÆÇÈÉÊËÎÏÔŒÙÛÜ";
+var spanishLower = "abcdefghijklmnopqrstuvwxyzñ";
+var spanishUpper = "ABCDEFGHIJKLMNOPQRSTUVWXYZÑ";
+var russianLower = "абвгдеёжзийклмнопрстуфхцчшщъыьэюя";
+var russianUpper = "АБВГДЕЁЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯ";
+var RandexSetUtil = /** @class */ (function () {
+    function RandexSetUtil() {
     }
-    RtSetUtil.toSingleRange = function (set) {
-        switch (set) {
-            case "alphabet":
-                return exports.alphabet;
-            case "alphabetUpper":
-                return alphabetUpper;
-            case "alphabetLower":
-                return alphabetLower;
+    RandexSetUtil.toSingleRange = function (itemSet) {
+        if (Array.isArray(itemSet)) {
+            return RandexSetUtil.toAlphabetRange(itemSet);
+        }
+        else if (type_1.RandexTypeParser.inAlphabet(itemSet)) {
+            return RandexSetUtil.toAlphabetRange([itemSet, "default"]);
+        }
+        switch (itemSet) {
             case "hex":
                 return hex;
             case "symbol":
@@ -31,9 +37,63 @@ var RtSetUtil = /** @class */ (function () {
                 return "";
         }
     };
-    RtSetUtil.toRange = function (set) {
-        return Array.isArray(set) ? set.map(function (x) { return RtSetUtil.toSingleRange(x); }).join("") : RtSetUtil.toSingleRange(set);
+    RandexSetUtil.toAlphabetCase = function (cas, lowerWord, upperWord) {
+        switch (cas) {
+            case "lower":
+            case "l":
+                return lowerWord;
+            case "upper":
+            case "u":
+                return upperWord;
+            default:
+                return lowerWord + upperWord;
+        }
+    };
+    RandexSetUtil.toAlphabetRange = function (set) {
+        var alphabet = set[0], aCase = set[1];
+        switch (alphabet) {
+            case "english":
+                return RandexSetUtil.toAlphabetCase(aCase, englishLower, englishUpper);
+            case "french":
+                return RandexSetUtil.toAlphabetCase(aCase, frenchLower, frenchUpper);
+            case "spanish":
+                return RandexSetUtil.toAlphabetCase(aCase, spanishLower, spanishUpper);
+            // case "german":
+            //   return RtSetUtil.toAlphabetCase(aCase, englishLower, englishUpper);
+            case "russian":
+                return RandexSetUtil.toAlphabetCase(aCase, russianLower, russianUpper);
+        }
+    };
+    RandexSetUtil.toRange = function (set) {
+        var result = "";
+        if (type_1.RandexTypeParser.isSetSingle(set)) {
+            result += RandexSetUtil.toSingleRange(set);
+        }
+        else if (type_1.RandexTypeParser.isSet(set)) {
+            result += set.map(RandexSetUtil.toSingleRange).join("");
+        }
+        return result;
+    };
+    RandexSetUtil.getLength = function (reservedChars, length, defaultLength) {
+        var result = defaultLength;
+        if (typeof length === "number" && length > reservedChars) {
+            result = length - reservedChars;
+        }
+        else if (Array.isArray(length)) {
+            var min = length[0], max = length[1];
+            var dMin = min - reservedChars;
+            var dMax = max - reservedChars;
+            if (dMin >= 0 && dMax >= 0) {
+                if (dMin < dMax) {
+                    return [dMin, dMax];
+                }
+                else if (dMin === dMax) {
+                    return dMin;
+                }
+            }
+        }
+        return result;
     };
-    return RtSetUtil;
+    return RandexSetUtil;
 }());
-exports.RtSetUtil = RtSetUtil;
+exports.RandexSetUtil = RandexSetUtil;

package/lib/basic/type.d.ts

@@ -0,0 +1,12 @@
+import { RandexCase, RandexAlphabet, RandexItemSet, RandexContentArrayOptions, RandexSet, RandexSingleSet, RandexLength } from "../interfaces";
+export declare class RandexTypeParser {
+    private static inRange;
+    private static inLiteral;
+    static inCase(value: string): value is RandexCase;
+    static inAlphabet(value: string): value is RandexAlphabet;
+    static inSet(value: string): value is RandexSingleSet;
+    static isLength(value: any): value is RandexLength;
+    static isSetSingle(value: any): value is RandexItemSet;
+    static isSet(value: any): value is RandexSet;
+    static isPartArray(value: any): value is RandexContentArrayOptions;
+}

package/lib/basic/type.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RandexTypeParser = void 0;
+var RandexTypeParser = /** @class */ (function () {
+    function RandexTypeParser() {
+    }
+    RandexTypeParser.inRange = function (value, range) {
+        var min = range[0], max = range[1];
+        return value >= min && value <= max;
+    };
+    RandexTypeParser.inLiteral = function (value) {
+        var expects = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            expects[_i - 1] = arguments[_i];
+        }
+        return !!expects.find(function (x) { return x === value; });
+    };
+    RandexTypeParser.inCase = function (value) {
+        return RandexTypeParser.inLiteral(value, "default", "lower", "upper", "l", "u");
+    };
+    RandexTypeParser.inAlphabet = function (value) {
+        return RandexTypeParser.inLiteral(value, "english", "french", "spanish", // "german",
+        "russian");
+    };
+    RandexTypeParser.inSet = function (value) {
+        return RandexTypeParser.inAlphabet(value) || RandexTypeParser.inLiteral(value, "hex", "symbol", "number", "binary");
+    };
+    // RandomLength
+    RandexTypeParser.isLength = function (value) {
+        if (typeof value === "number") {
+            return true;
+        }
+        else if (Array.isArray(value) && value.length === 2) {
+            return typeof value[0] === "number" && typeof value[1] === "number";
+        }
+        return false;
+    };
+    // RandomItemSet
+    RandexTypeParser.isSetSingle = function (value) {
+        if (typeof value === "string") {
+            return RandexTypeParser.inSet(value);
+        }
+        else if (Array.isArray(value) && value.length === 2) {
+            var _a = value, alphabet = _a[0], aCase = _a[1];
+            if (typeof alphabet === "string" && typeof aCase === "string") {
+                if (RandexTypeParser.inAlphabet(alphabet) && RandexTypeParser.inCase(aCase)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    };
+    RandexTypeParser.isSet = function (value) {
+        if (RandexTypeParser.isSetSingle(value)) {
+            return true;
+        }
+        else if (Array.isArray(value)) {
+            var sets = value.filter(function (x) { return RandexTypeParser.isSetSingle(x); });
+            return sets.length === value.length;
+        }
+        return false;
+    };
+    RandexTypeParser.isPartArray = function (value) {
+        if (Array.isArray(value) && RandexTypeParser.inRange(value.length, [2, 3])) {
+            if (value.length === 2) {
+                var set = value[0], rangeOrLength = value[1];
+                return RandexTypeParser.isSet(set) && (RandexTypeParser.isLength(rangeOrLength) || typeof rangeOrLength === "string");
+            }
+            else if (value.length === 3) {
+                var set = value[0], range = value[1], length_1 = value[2];
+                return RandexTypeParser.isSet(set) && typeof range === "string" && RandexTypeParser.isLength(length_1);
+            }
+        }
+        return false;
+    };
+    return RandexTypeParser;
+}());
+exports.RandexTypeParser = RandexTypeParser;

package/lib/custom/email.js

@@ -3,10 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.randomEmail = void 0;
 var basic_1 = require("../basic");
 function randomEmail() {
-    return ((0, basic_1.random)("alphabetLower", [["alphabetLower", "number"], 10], "alphabetLower") +
+    return ((0, basic_1.random)(["english", "l"], [[["english", "l"], "number"], 10], ["english", "l"]) +
         "@" +
-        (0, basic_1.random)("alphabetLower", ["alphabetLower", "-", [0, 5]], "alphabetLower") +
+        (0, basic_1.random)(["english", "l"], [["english", "l"], "-", [0, 5]], ["english", "l"]) +
         "." +
-        (0, basic_1.random)(["alphabetLower", [2, 4]]));
+        (0, basic_1.random)([
+            ["english", "l"],
+            [2, 4],
+        ]));
 }
 exports.randomEmail = randomEmail;

package/lib/custom/filename.js

@@ -4,6 +4,14 @@ exports.randomFileName = void 0;
 var basic_1 = require("../basic");
 function randomFileName(options) {
     var extension = (options || {}).extension;
-    return (0, basic_1.random)([["alphabet", "number"], "_.", [5, 10]]) + (0, basic_1.random)(["alphabet", "number"]) + "." + (extension ? extension : (0, basic_1.random)(["alphabetLower", [2, 5]]));
+    return ((0, basic_1.random)([["english", "number"], "_.", [5, 10]]) +
+        (0, basic_1.random)(["english", "number"]) +
+        "." +
+        (extension
+            ? extension
+            : (0, basic_1.random)([
+                ["english", "l"],
+                [2, 5],
+            ])));
 }
 exports.randomFileName = randomFileName;

package/lib/custom/name.d.ts

@@ -1,6 +1,12 @@
-import { RandomLength } from "../interfaces";
-export interface RandomNameOptions {
-    length: RandomLength;
+import { RandexAlphabet, RandexLength } from "../interfaces";
+export interface RandexNameOptions {
+    length?: RandexLength;
+    alphabet?: RandexAlphabet;
 }
-export declare function randomName(options?: RandomNameOptions): string;
-export declare function randomFullName(): string;
+export interface RandexFullNameOptions {
+    firstLength?: RandexLength;
+    secondLength?: RandexLength;
+    alphabet?: RandexAlphabet;
+}
+export declare function randomName(options?: RandexNameOptions): string;
+export declare function randomFullName(options?: RandexFullNameOptions): string;

package/lib/custom/name.js

@@ -2,33 +2,15 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.randomFullName = exports.randomName = void 0;
 var basic_1 = require("../basic");
-function getLength(reservedChars, length, defaultLength) {
-    var result = defaultLength;
-    if (typeof length === "number" && length > reservedChars) {
-        result = length - reservedChars;
-    }
-    else if (Array.isArray(length)) {
-        var min = length[0], max = length[1];
-        var dMin = min - reservedChars;
-        var dMax = max - reservedChars;
-        if (dMin >= 0 && dMax >= 0) {
-            if (dMin < dMax) {
-                return [dMin, dMax];
-            }
-            else if (dMin === dMax) {
-                return dMin;
-            }
-        }
-    }
-    return result;
-}
+var set_1 = require("../basic/set");
 function randomName(options) {
-    var length = (options || {}).length;
-    var currentLength = getLength(1, length, [1, 9]);
-    return (0, basic_1.random)("alphabetUpper", ["alphabetLower", currentLength]);
+    var _a = options || {}, length = _a.length, _b = _a.alphabet, alphabet = _b === void 0 ? "english" : _b;
+    var currentLength = set_1.RandexSetUtil.getLength(1, length, [1, 9]);
+    return (0, basic_1.random)([alphabet, "u"], [[alphabet, "l"], currentLength]);
 }
 exports.randomName = randomName;
-function randomFullName() {
-    return randomName() + " " + randomName();
+function randomFullName(options) {
+    var _a = options || {}, firstLength = _a.firstLength, secondLength = _a.secondLength, alphabet = _a.alphabet;
+    return randomName({ length: firstLength, alphabet: alphabet }) + " " + randomName({ length: secondLength, alphabet: alphabet });
 }
 exports.randomFullName = randomFullName;

package/lib/custom/username.d.ts

@@ -1 +1,5 @@
-export declare function randomUsername(): string;
+import { RandexLength } from "../interfaces";
+export interface RandexUsernameOptions {
+    length?: RandexLength;
+}
+export declare function randomUsername(options?: RandexUsernameOptions): string;

package/lib/custom/username.js

@@ -2,10 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.randomUsername = void 0;
 var basic_1 = require("../basic");
-function randomUsername() {
-    return (0, basic_1.random)("alphabetLower", [
-        ["alphabetLower", "number"],
-        [5, 10],
-    ]);
+var set_1 = require("../basic/set");
+function randomUsername(options) {
+    var length = (options || {}).length;
+    var currentLength = set_1.RandexSetUtil.getLength(1, length, [6, 10]);
+    return (0, basic_1.random)(["english", "l"], [[["english", "l"], "number"], currentLength]);
 }
 exports.randomUsername = randomUsername;

package/lib/interfaces/index.d.ts

@@ -1,17 +1,21 @@
-export type RandomSingleSet = "hex" | "symbol" | "alphabet" | "alphabetLower" | "alphabetUpper" | "number" | "binary";
-export type RandomSet = RandomSingleSet | RandomSingleSet[];
-export type RandomLength = number | [number, number];
-interface RandomPartFullOptions {
-    set?: RandomSet;
+export type RandexCase = "default" | "lower" | "upper" | "l" | "u";
+export type RandexAlphabet = "english" | "french" | "spanish" | "russian";
+export type RandexSingleSet = RandexAlphabet | "hex" | "symbol" | "number" | "binary";
+export type RandexAlphabetCase = [RandexAlphabet, RandexCase];
+export type RandexItemSet = RandexSingleSet | RandexAlphabetCase;
+export type RandexSet = RandexItemSet | RandexItemSet[];
+export type RandexLength = number | [number, number];
+interface RandexItemBasicOptions {
+    set?: RandexSet;
     range?: string;
-    length?: RandomLength;
+    length?: RandexLength;
 }
-export interface RandomPartSetOptions extends Omit<RandomPartFullOptions, "set"> {
-    set: RandomSet;
+export interface RandexContentSetOptions extends Omit<RandexItemBasicOptions, "set"> {
+    set: RandexSet;
 }
-export interface RandomPartRangeOptions extends Omit<RandomPartFullOptions, "range"> {
+export interface RandexContentRangeOptions extends Omit<RandexItemBasicOptions, "range"> {
     range: string;
 }
-export type RandomPartArrayOptions = [RandomSet, string | RandomLength] | [RandomSet, string, RandomLength];
-export type RandomPartOptions = RandomPartSetOptions | RandomPartRangeOptions | RandomPartArrayOptions | RandomSet;
+export type RandexContentArrayOptions = [RandexSet, string | RandexLength] | [RandexSet, string, RandexLength];
+export type RandexContentOptions = RandexContentSetOptions | RandexContentRangeOptions | RandexContentArrayOptions | RandexSet;
 export {};

package/lib/test/filename.test.js

@@ -5,8 +5,8 @@ var test_util_1 = require("./test-util");
 describe("randomFileName", function () {
     it("simple", function () {
         for (var i = 0; i < 100; i++) {
-            var email = (0, filename_1.randomFileName)();
-            expect(test_util_1.TestUtil.isFileNameValid(email)).toBeTruthy();
+            var value = (0, filename_1.randomFileName)();
+            expect(test_util_1.TestUtil.isFileNameValid(value)).toBeTruthy();
         }
     });
 });

package/lib/test/markdown.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/test/markdown.test.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var basic_1 = require("../basic");
+var custom_1 = require("../custom");
+describe("markdown", function () {
+    it("random", function () {
+        var value = (0, basic_1.random)({
+            set: "english",
+            length: 3,
+        });
+        expect(value.length).toBe(3);
+        value = (0, basic_1.random)({
+            set: ["english", "lower"],
+            length: 3,
+        });
+        expect(value.length).toBe(3);
+        value = (0, basic_1.random)({
+            set: "english",
+            length: [1, 3],
+        });
+        expect(value.length).toBeLessThanOrEqual(3);
+        value = (0, basic_1.random)({
+            set: "number",
+            length: 3,
+        });
+        expect(value.length).toBe(3);
+        value = (0, basic_1.random)({
+            range: "abc123",
+            length: 3,
+        });
+        expect(value.length).toBe(3);
+        value = (0, basic_1.random)({
+            set: ["english", "number"],
+            length: 3,
+        });
+        expect(value.length).toBe(3);
+        value = (0, basic_1.random)({
+            set: "english",
+            length: 2,
+        }, {
+            set: ["english", "number"],
+            length: 2,
+        });
+        expect(value.length).toBe(4);
+    });
+    it("randomFileName", function () {
+        var value = (0, custom_1.randomFileName)({
+            extension: "txt",
+        });
+        expect(value).toBeTruthy();
+    });
+    it("randomUsername", function () {
+        var value = (0, custom_1.randomUsername)();
+        expect(value).toBeTruthy();
+    });
+    it("randomEmail", function () {
+        var value = (0, custom_1.randomEmail)();
+        expect(value).toBeTruthy();
+    });
+    it("randomName", function () {
+        var value = (0, custom_1.randomName)();
+        expect(value).toBeTruthy();
+        value = (0, custom_1.randomName)({ alphabet: "french" });
+        expect(value).toBeTruthy();
+        value = (0, custom_1.randomName)({ length: 5 });
+        expect(value).toBeTruthy();
+        value = (0, custom_1.randomName)({ length: [2, 5] });
+        expect(value).toBeTruthy();
+    });
+    it("randomFullName", function () {
+        var value = (0, custom_1.randomFullName)();
+        expect(value).toBeTruthy();
+    });
+});

package/lib/test/params.test.js

@@ -4,21 +4,21 @@ var basic_1 = require("../basic");
 var test_util_1 = require("./test-util");
 describe("random params", function () {
     it("array 1", function () {
-        var set = "alphabetLower";
+        var set = "english";
         var result1 = (0, basic_1.random)({ set: set });
         var result2 = (0, basic_1.random)(set);
         test_util_1.TestUtil.testInSet(result1, set);
         test_util_1.TestUtil.testInSet(result2, set);
     });
     it("single: array", function () {
-        var set = ["number", "alphabetLower"];
+        var set = ["number", "english"];
         var result1 = (0, basic_1.random)({ set: set });
         var result2 = (0, basic_1.random)(set);
         test_util_1.TestUtil.testInSet(result1, set);
         test_util_1.TestUtil.testInSet(result2, set);
     });
     it("single: array, length", function () {
-        var set = ["number", "alphabetLower"];
+        var set = ["number", "english"];
         var length = 3;
         var result1 = (0, basic_1.random)({ set: set, length: length });
         var result2 = (0, basic_1.random)([set, length]);
@@ -26,7 +26,7 @@ describe("random params", function () {
         test_util_1.TestUtil.testInSet(result2, set, length);
     });
     it("single: array, length as array", function () {
-        var set = ["number", "alphabetLower"];
+        var set = ["number", "english"];
         var length = [1, 4];
         var result1 = (0, basic_1.random)({ set: set, length: length });
         var result2 = (0, basic_1.random)([set, length]);
@@ -42,7 +42,7 @@ describe("random params", function () {
         test_util_1.TestUtil.testInBoth(result2, set, range);
     });
     it("array 2 (length)", function () {
-        var set = "alphabet";
+        var set = "english";
         var length = 3;
         var result1 = (0, basic_1.random)({ set: set, length: length });
         var result2 = (0, basic_1.random)([set, length]);

package/lib/test/random.test.js

@@ -14,9 +14,9 @@ function inRange(range, length) {
 }
 describe("random", function () {
     it("set", function () {
-        inSet("alphabet", 3);
-        inSet("alphabetLower", 3);
-        inSet("alphabetUpper", 3);
+        inSet("english", 3);
+        inSet(["english", "l"], 3);
+        inSet(["english", "u"], 3);
         inSet("hex", 3);
         inSet("symbol", 3);
         inSet("number", 3);
@@ -27,9 +27,31 @@ describe("random", function () {
         inRange("1234abc!@#", 3);
     });
     it("length: alphabet", function () {
-        inSet("alphabet", 0);
-        inSet("alphabet", [0, 0]);
-        inSet("alphabet", [1, 3]);
-        inSet("alphabet", [0, 1]);
+        inSet("english", 0);
+        inSet("english", [0, 0]);
+        inSet("english", [1, 3]);
+        inSet("english", [0, 1]);
+    });
+    it("alphabet: upper", function () {
+        for (var i = 0; i < 100; i++) {
+            var value = (0, basic_1.random)(["english", "u"]);
+            expect(test_util_1.TestUtil.isUpperCharValid(value, 1)).toBeTruthy();
+            value = (0, basic_1.random)([
+                ["english", "u"],
+                [1, 3],
+            ]);
+            expect(test_util_1.TestUtil.isUpperCharValid(value, [1, 3])).toBeTruthy();
+        }
+    });
+    it("alphabet: lower", function () {
+        for (var i = 0; i < 100; i++) {
+            var value = (0, basic_1.random)(["english", "l"]);
+            expect(test_util_1.TestUtil.isLowerCharValid(value, 1)).toBeTruthy();
+            value = (0, basic_1.random)([
+                ["english", "lower"],
+                [1, 3],
+            ]);
+            expect(test_util_1.TestUtil.isLowerCharValid(value, [1, 3])).toBeTruthy();
+        }
     });
 });

package/lib/test/test-util.d.ts

@@ -1,15 +1,17 @@
-import { RandomLength, RandomSet } from "../interfaces";
+import { RandexLength, RandexSet } from "../interfaces";
 export declare class TestUtil {
-    static testIn(value: string, length: RandomLength | undefined, action: () => void): void;
-    static testInSet(value: string, set: RandomSet, length?: RandomLength): void;
-    static testInRange(value: string, range: string, length?: RandomLength): void;
-    static testInBoth(value: string, set: RandomSet, range: string, length?: RandomLength): void;
+    static testIn(value: string, length: RandexLength | undefined, action: () => void): void;
+    static testInSet(value: string, set: RandexSet, length?: RandexLength): void;
+    static testInRange(value: string, range: string, length?: RandexLength): void;
+    static testInBoth(value: string, set: RandexSet, range: string, length?: RandexLength): void;
     static inRange(value: string, range: string): boolean;
-    static inSet(value: string, set: RandomSet): boolean;
-    static inBoth(value: string, set: RandomSet, range: string): boolean;
+    static inSet(value: string, set: RandexSet): boolean;
+    static inBoth(value: string, set: RandexSet, range: string): boolean;
     static isEmailValid(email: string): RegExpMatchArray | null;
     static isUsernameValid(email: string): RegExpMatchArray | null;
     static isNameValid(email: string): RegExpMatchArray | null;
+    static isUpperCharValid(value: string, length?: RandexLength): RegExpMatchArray | null;
+    static isLowerCharValid(value: string, length?: RandexLength): RegExpMatchArray | null;
     static isFullNameValid(email: string): RegExpMatchArray | null;
     static isFileNameValid(email: string): RegExpMatchArray | null;
     static inNumberRange(value: number, range: [number, number]): boolean;

package/lib/test/test-util.js

@@ -46,11 +46,11 @@ var TestUtil = /** @class */ (function () {
         return value.length > 0;
     };
     TestUtil.inSet = function (value, set) {
-        var range = set_1.RtSetUtil.toRange(set);
+        var range = set_1.RandexSetUtil.toRange(set);
         return TestUtil.inRange(value, range);
     };
     TestUtil.inBoth = function (value, set, range) {
-        var fullRange = set_1.RtSetUtil.toRange(set) + range;
+        var fullRange = set_1.RandexSetUtil.toRange(set) + range;
         return TestUtil.inRange(value, fullRange);
     };
     TestUtil.isEmailValid = function (email) {
@@ -66,6 +66,16 @@ var TestUtil = /** @class */ (function () {
     TestUtil.isNameValid = function (email) {
         return String(email).match(/^[A-Z][a-z]{1,}$/);
     };
+    TestUtil.isUpperCharValid = function (value, length) {
+        if (length === void 0) { length = 1; }
+        var l = Array.isArray(length) ? "".concat(length[0], ",").concat(length[1]) : length;
+        return String(value).match(new RegExp("^[A-Z]{".concat(l, "}$")));
+    };
+    TestUtil.isLowerCharValid = function (value, length) {
+        if (length === void 0) { length = 1; }
+        var l = Array.isArray(length) ? "".concat(length[0], ",").concat(length[1]) : length;
+        return String(value).match(new RegExp("^[a-z]{".concat(l, "}$")));
+    };
     TestUtil.isFullNameValid = function (email) {
         return String(email).match(/^[A-Z][a-z]{1,}[ ][A-Z][a-z]{1,}$/);
     };

package/lib/test/type.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/test/type.test.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var type_1 = require("../basic/type");
+function isLength(value, expectedResult) {
+    if (expectedResult === void 0) { expectedResult = true; }
+    var result = type_1.RandexTypeParser.isLength(value);
+    expect(expectedResult).toBe(result);
+}
+function isSetSingle(value, expectedResult) {
+    if (expectedResult === void 0) { expectedResult = true; }
+    var result = type_1.RandexTypeParser.isSetSingle(value);
+    expect(expectedResult).toBe(result);
+}
+function isSet(value, expectedResult) {
+    if (expectedResult === void 0) { expectedResult = true; }
+    var result = type_1.RandexTypeParser.isSet(value);
+    expect(expectedResult).toBe(result);
+}
+describe("type", function () {
+    it("isLength", function () {
+        // true
+        isLength(1);
+        isLength([1, 2]);
+        // false
+        isLength([1, 2, 3], false);
+        isLength("hi", false);
+        isLength(null, false);
+    });
+    it("isSetSingle", function () {
+        // true
+        isSetSingle("english");
+        isSetSingle("hex");
+        isSetSingle(["english", "lower"]);
+        // false
+        isSetSingle("bric", false);
+        isSetSingle("hexeron", false);
+        isSetSingle(["bric", "lower"], false);
+        isSetSingle(1, false);
+        isSetSingle(null, false);
+        isSetSingle(["lower", "english"], false);
+    });
+    it("RandomSet", function () {
+        // true single
+        isSet("english");
+        isSet("hex");
+        isSet(["english", "lower"]);
+        // true array
+        isSet(["english", "hex", ["english", "u"]]);
+        // false single
+        isSet("bric", false);
+        isSet("hexeron", false);
+        isSet(["bric", "lower"], false);
+        isSet(1, false);
+        isSet(null, false);
+        // false array
+        isSet(["hex", 2], false);
+        isSet(["english", "hex", ["u", "english"]], false);
+    });
+});

package/lib/test/username.test.js

@@ -9,4 +9,12 @@ describe("randomEmail", function () {
             expect(test_util_1.TestUtil.isUsernameValid(value)).toBeTruthy();
         }
     });
+    it("options", function () {
+        var value1 = (0, username_1.randomUsername)({ length: 5 });
+        expect(value1.length).toBe(5);
+        var value2 = (0, username_1.randomUsername)({ length: [5, 5] });
+        expect(value2.length).toBe(5);
+        var value3 = (0, username_1.randomUsername)({ length: [1, 5] });
+        expect(test_util_1.TestUtil.inNumberRange(value3.length, [1, 5])).toBeTruthy();
+    });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "randex",
-  "version": "0.3.0",
+  "version": "0.6.0",
   "description": "",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -26,15 +26,12 @@
     "ts-jest": "^24.1.0",
     "typescript": "^4.2.4"
   },
-  "dependencies": {
-    "reflect-metadata": "^0.2.1"
-  },
   "keywords": [
     "random",
     "random filename",
     "random email",
     "random username",
-    "random full name",
+    "random name",
     "random string"
   ]
 }