js-generate-password 0.1.2 → 0.1.4

package/README.md

@@ -3,7 +3,7 @@
 
 # js-generate-password
 
-js-generate-password is usable for every javascript based project like react, vue, node, etc. it used to generate passwords that may contain alphabets, number and symbols. The options parameter enables the user to enable or disable the characters that are used to generate random password.
+js-generate-password is usable for every javascript and typescript based project like react, vue, node, etc. it used to generate passwords that may contain alphabets, number and symbols. The options parameter enables the user to enable or disable the characters that are used to generate random password.
 
 The characters that may be choosen from are
 
@@ -25,7 +25,7 @@ or
 For the password to be generated, **parameters** are able to pass as an optional **options** object.
 
 ```javascript
-import GeneratePassword from "js-generate-password";
+import { GeneratePassword } from "js-generate-password";
 const password = GeneratePassword({
   length: 14,
   symbols: true,
@@ -74,7 +74,7 @@ Any of these can be passed into the options object for each function.
 - **No Options passed.**
 
 ```javscript
-const GeneratePassword = require("js-generate-password");
+const {GeneratePassword} = require("js-generate-password");
 const password = GeneratePassword();
 console.log(password);
 ```
@@ -88,14 +88,11 @@ xDU6izb3PV;
 - **Length parameter passed.**
 
 ```javascript
-options={
-      length : 25;
-      }
-password = GeneratePassword(options);
+const password = GeneratePassword({ length: 25 });
 console.log(password);
 ```
 
-The password generated is
+The password generated is like this
 
 ```javascript
 U4c3KpQP5UrbZgTcrqMgFeI3R;

package/lib/check-options-error.js

@@ -1,40 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkError = void 0;
 const checkError = (options) => {
-  const {
-    length,
-    lowercase,
-    uppercase,
-    numbers,
-    symbols,
-    minLengthLowercase,
-    minLengthUppercase,
-    minLengthNumbers,
-    minLengthSymbols,
-  } = options;
-
-  //Checking if the sum of minimum characters of Lowercase, uppercase, numbers and special case is greater than the total password length.
-  if (
-    minLengthLowercase +
-      minLengthUppercase +
-      minLengthNumbers +
-      minLengthSymbols >
-    length
-  ) {
-    throw new Error(
-      "Sum of Minimum Characters in the passwords greater than the length of the Password to be generated."
-    );
-  }
-
-  //Checking if lowercase, uppercase , numbers and special characters have all been set to false.
-  if (
-    lowercase == false &&
-    uppercase == false &&
-    numbers == false &&
-    symbols == false
-  ) {
-    throw new Error(
-      "Alphabets, Numbers and Symbols are all set to False. No valid Characters to generate the Password."
-    );
-  }
+    const { length, lowercase, uppercase, numbers, symbols, minLengthLowercase, minLengthUppercase, minLengthNumbers, minLengthSymbols, } = options;
+    //Checking if the sum of minimum characters of Lowercase, uppercase, numbers and special case is greater than the total password length.
+    if (minLengthLowercase +
+        minLengthUppercase +
+        minLengthNumbers +
+        minLengthSymbols >
+        length) {
+        throw new Error("Sum of Minimum Characters in the passwords greater than the length of the Password to be generated.");
+    }
+    //Checking if lowercase, uppercase , numbers and special characters have all been set to false.
+    if (lowercase == false &&
+        uppercase == false &&
+        numbers == false &&
+        symbols == false) {
+        throw new Error("Alphabets, Numbers and Symbols are all set to False. No valid Characters to generate the Password.");
+    }
 };
-
-module.exports = checkError;
+exports.checkError = checkError;
+// module.exports = checkError;

package/lib/check-options-error.ts

@@ -0,0 +1,42 @@
+import { GenerateOptions } from "./types";
+
+export const checkError = (options: GenerateOptions) => {
+  const {
+    length,
+    lowercase,
+    uppercase,
+    numbers,
+    symbols,
+    minLengthLowercase,
+    minLengthUppercase,
+    minLengthNumbers,
+    minLengthSymbols,
+  } = options;
+
+  //Checking if the sum of minimum characters of Lowercase, uppercase, numbers and special case is greater than the total password length.
+  if (
+    minLengthLowercase! +
+      minLengthUppercase! +
+      minLengthNumbers! +
+      minLengthSymbols! >
+    length!
+  ) {
+    throw new Error(
+      "Sum of Minimum Characters in the passwords greater than the length of the Password to be generated."
+    );
+  }
+
+  //Checking if lowercase, uppercase , numbers and special characters have all been set to false.
+  if (
+    lowercase == false &&
+    uppercase == false &&
+    numbers == false &&
+    symbols == false
+  ) {
+    throw new Error(
+      "Alphabets, Numbers and Symbols are all set to False. No valid Characters to generate the Password."
+    );
+  }
+};
+
+// module.exports = checkError;

package/lib/generate-random-number.js

@@ -1,5 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateRandomNumbers = void 0;
 const generateRandomNumbers = (upperLimit) => {
-  return (randomNumber = Math.floor(Math.random() * upperLimit));
+    return Math.floor(Math.random() * upperLimit);
 };
-
-module.exports = generateRandomNumbers;
+exports.generateRandomNumbers = generateRandomNumbers;
+// module.exports = generateRandomNumbers;

package/lib/generate-random-number.ts

@@ -0,0 +1,5 @@
+export const generateRandomNumbers = (upperLimit: number) => {
+  return Math.floor(Math.random() * upperLimit);
+};
+
+// module.exports = generateRandomNumbers;

package/lib/password-generator.js

@@ -1,90 +1,64 @@
-const randomNumber = require("./generate-random-number");
-const shuffleString = require("./shuffle-string");
-
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generatePassword = void 0;
+// const generategenerateRandomNumberss = require("./generate-random-number");
+// const shuffleString = require("./shuffle-string");
+const generate_random_number_1 = require("./generate-random-number");
+const shuffle_string_1 = require("./shuffle-string");
 const generatePassword = (options) => {
-  let pswd = "";
-  let minChar = "";
-  let {
-    length,
-    lowercase,
-    uppercase,
-    numbers,
-    symbols,
-    minLengthLowercase,
-    minLengthUppercase,
-    minLengthNumbers,
-    minLengthSymbols,
-    exclude,
-  } = options;
-
-  let lowercaseChar = "abcdefghijklmnopqrstuvwxyz";
-  lowercaseChar = removeExceptions(lowercaseChar, exclude);
-
-  let uppercaseChar = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
-  uppercaseChar = removeExceptions(uppercaseChar, exclude);
-
-  let numberChar = "0123456789";
-  numberChar = removeExceptions(numberChar, exclude);
-
-  let specialChar = "!#$%&'()*+,-./:;<=>?@[]^_{|}~";
-  specialChar = removeExceptions(specialChar, exclude);
-
-  //  Generating a minChar string that holds minimum number of characters on the User Option Selection.
-  // The minChar variable will store the minimum number of characters for each type - lowercase, uppercase, numbers, and symbols.
-  //  Then, the minChar variable is shuffled to make the password random.
-
-  upperLimit = lowercaseChar.length;
-  for (i = 0; i < minLengthLowercase; i++) {
-    minChar += lowercaseChar.charAt(randomNumber(upperLimit));
-  }
-
-  upperLimit = uppercaseChar.length;
-  for (i = 0; i < minLengthUppercase; i++) {
-    minChar += uppercaseChar.charAt(randomNumber(upperLimit));
-  }
-
-  upperLimit = numberChar.length;
-  for (i = 0; i < minLengthNumbers; i++) {
-    minChar += numberChar.charAt(randomNumber(upperLimit));
-  }
-
-  upperLimit = specialChar.length;
-  for (i = 0; i < minLengthSymbols; i++) {
-    minChar += specialChar.charAt(randomNumber(upperLimit));
-  }
-
-  //Shuffling the minChar to generate a password that holds minimum criteria.
-  pswd = pswd + shuffleString(minChar);
-
-  characterString = "";
-
-  characterString = lowercase
-    ? characterString + lowercaseChar
-    : characterString;
-
-  characterString = uppercase
-    ? characterString + uppercaseChar
-    : characterString;
-
-  characterString = numbers ? characterString + numberChar : characterString;
-
-  characterString = symbols ? characterString + specialChar : characterString;
-
-  remainingChar = length - pswd.length;
-
-  upperLimit = characterString.length;
-
-  for (i = 0; i < remainingChar; i++) {
-    pswd += characterString.charAt(randomNumber(upperLimit));
-  }
-  return pswd;
+    let pswd = "";
+    let minChar = "";
+    let { length, lowercase, uppercase, numbers, symbols, minLengthLowercase, minLengthUppercase, minLengthNumbers, minLengthSymbols, exclude, } = options;
+    let lowercaseChar = "abcdefghijklmnopqrstuvwxyz";
+    lowercaseChar = removeExceptions(lowercaseChar, exclude);
+    let uppercaseChar = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+    uppercaseChar = removeExceptions(uppercaseChar, exclude);
+    let numberChar = "0123456789";
+    numberChar = removeExceptions(numberChar, exclude);
+    let specialChar = "!#$%&'()*+,-./:;<=>?@[]^_{|}~";
+    specialChar = removeExceptions(specialChar, exclude);
+    //  Generating a minChar string that holds minimum number of characters on the User Option Selection.
+    // The minChar variable will store the minimum number of characters for each type - lowercase, uppercase, numbers, and symbols.
+    //  Then, the minChar variable is shuffled to make the password random.
+    let upperLimit = lowercaseChar.length;
+    for (let i = 0; i < minLengthLowercase; i++) {
+        minChar += lowercaseChar.charAt((0, generate_random_number_1.generateRandomNumbers)(upperLimit));
+    }
+    upperLimit = uppercaseChar.length;
+    for (let i = 0; i < minLengthUppercase; i++) {
+        minChar += uppercaseChar.charAt((0, generate_random_number_1.generateRandomNumbers)(upperLimit));
+    }
+    upperLimit = numberChar.length;
+    for (let i = 0; i < minLengthNumbers; i++) {
+        minChar += numberChar.charAt((0, generate_random_number_1.generateRandomNumbers)(upperLimit));
+    }
+    upperLimit = specialChar.length;
+    for (let i = 0; i < minLengthSymbols; i++) {
+        minChar += specialChar.charAt((0, generate_random_number_1.generateRandomNumbers)(upperLimit));
+    }
+    //Shuffling the minChar to generate a password that holds minimum criteria.
+    pswd = pswd + (0, shuffle_string_1.shuffleString)(minChar);
+    let characterString = "";
+    characterString = lowercase
+        ? characterString + lowercaseChar
+        : characterString;
+    characterString = uppercase
+        ? characterString + uppercaseChar
+        : characterString;
+    characterString = numbers ? characterString + numberChar : characterString;
+    characterString = symbols ? characterString + specialChar : characterString;
+    let remainingChar = length - pswd.length;
+    upperLimit = characterString.length;
+    for (let i = 0; i < remainingChar; i++) {
+        pswd += characterString.charAt((0, generate_random_number_1.generateRandomNumbers)(upperLimit));
+    }
+    return pswd;
 };
-
+exports.generatePassword = generatePassword;
 const removeExceptions = (str, EXCEPTIONS) => {
-  EXCEPTIONS?.split("").forEach((char) => {
-    str = str.replace(char, "");
-  });
-  return str;
+    EXCEPTIONS === null || EXCEPTIONS === void 0 ? void 0 : EXCEPTIONS.split("").forEach((char) => {
+        str = str.replace(char, "");
+    });
+    return str;
 };
-
-module.exports = generatePassword;
+// module.exports = generatePassword;

package/lib/password-generator.ts

@@ -0,0 +1,92 @@
+// const generategenerateRandomNumberss = require("./generate-random-number");
+// const shuffleString = require("./shuffle-string");
+import { generateRandomNumbers } from "./generate-random-number";
+import { shuffleString } from "./shuffle-string";
+import { GenerateOptions } from "./types";
+export const generatePswd = (options: GenerateOptions) => {
+  let pswd = "";
+  let minChar = "";
+  let {
+    length,
+    lowercase,
+    uppercase,
+    numbers,
+    symbols,
+    minLengthLowercase,
+    minLengthUppercase,
+    minLengthNumbers,
+    minLengthSymbols,
+    exclude,
+  } = options;
+
+  let lowercaseChar = "abcdefghijklmnopqrstuvwxyz";
+  lowercaseChar = removeExceptions(lowercaseChar, exclude!);
+
+  let uppercaseChar = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+  uppercaseChar = removeExceptions(uppercaseChar, exclude!);
+
+  let numberChar = "0123456789";
+  numberChar = removeExceptions(numberChar, exclude!);
+
+  let specialChar = "!#$%&'()*+,-./:;<=>?@[]^_{|}~";
+  specialChar = removeExceptions(specialChar, exclude!);
+
+  //  Generating a minChar string that holds minimum number of characters on the User Option Selection.
+  // The minChar variable will store the minimum number of characters for each type - lowercase, uppercase, numbers, and symbols.
+  //  Then, the minChar variable is shuffled to make the password random.
+
+  let upperLimit = lowercaseChar.length;
+  for (let i = 0; i < minLengthLowercase!; i++) {
+    minChar += lowercaseChar.charAt(generateRandomNumbers(upperLimit));
+  }
+
+  upperLimit = uppercaseChar.length;
+  for (let i = 0; i < minLengthUppercase!; i++) {
+    minChar += uppercaseChar.charAt(generateRandomNumbers(upperLimit));
+  }
+
+  upperLimit = numberChar.length;
+  for (let i = 0; i < minLengthNumbers!; i++) {
+    minChar += numberChar.charAt(generateRandomNumbers(upperLimit));
+  }
+
+  upperLimit = specialChar.length;
+  for (let i = 0; i < minLengthSymbols!; i++) {
+    minChar += specialChar.charAt(generateRandomNumbers(upperLimit));
+  }
+
+  //Shuffling the minChar to generate a password that holds minimum criteria.
+  pswd = pswd + shuffleString(minChar);
+
+  let characterString = "";
+
+  characterString = lowercase
+    ? characterString + lowercaseChar
+    : characterString;
+
+  characterString = uppercase
+    ? characterString + uppercaseChar
+    : characterString;
+
+  characterString = numbers ? characterString + numberChar : characterString;
+
+  characterString = symbols ? characterString + specialChar : characterString;
+
+  let remainingChar = length! - pswd.length;
+
+  upperLimit = characterString.length;
+
+  for (let i = 0; i < remainingChar; i++) {
+    pswd += characterString.charAt(generateRandomNumbers(upperLimit));
+  }
+  return pswd;
+};
+
+const removeExceptions = (str: string, EXCEPTIONS: string) => {
+  EXCEPTIONS?.split("").forEach((char) => {
+    str = str.replace(char, "");
+  });
+  return str;
+};
+
+// module.exports = generatePassword;

package/lib/process-options.js

@@ -1,72 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processOption = void 0;
 const processOption = (options) => {
-  if (typeof options == "undefined") {
-    options = {
-      length: 10,
-      lowercase: true,
-      uppercase: true,
-      numbers: true,
-      symbols: false,
-      exclude: "",
-      minLengthLowercase: 1,
-      minLengthUppercase: 1,
-      minLengthNumbers: 1,
-      minLengthSymbols: 0,
-    };
-  } else {
-    options.length = typeof options.length == "undefined" ? 10 : options.length;
-
-    options.lowercase =
-      typeof options.lowercase == "undefined" ? true : options.lowercase;
-
-    options.uppercase =
-      typeof options.uppercase == "undefined" ? true : options.uppercase;
-
-    options.numbers =
-      typeof options.numbers == "undefined" ? true : options.numbers;
-
-    options.symbols =
-      typeof options.symbols == "undefined" ? false : options.symbols;
-
-    if (options.lowercase) {
-      options.minLengthLowercase =
-        typeof options.minLengthLowercase == "undefined"
-          ? 1
-          : options.minLengthLowercase;
-    } else {
-      options.minLengthLowercase = 0;
+    {
+        options.length = typeof options.length == "undefined" ? 10 : options.length;
+        options.lowercase =
+            typeof options.lowercase == "undefined" ? true : options.lowercase;
+        options.uppercase =
+            typeof options.uppercase == "undefined" ? true : options.uppercase;
+        options.numbers =
+            typeof options.numbers == "undefined" ? true : options.numbers;
+        options.symbols =
+            typeof options.symbols == "undefined" ? false : options.symbols;
+        if (options.lowercase) {
+            options.minLengthLowercase =
+                typeof options.minLengthLowercase == "undefined"
+                    ? 1
+                    : options.minLengthLowercase;
+        }
+        else {
+            options.minLengthLowercase = 0;
+        }
+        if (options.uppercase) {
+            options.minLengthUppercase =
+                typeof options.minLengthUppercase == "undefined"
+                    ? 1
+                    : options.minLengthUppercase;
+        }
+        else {
+            options.minLengthUppercase = 0;
+        }
+        if (options.numbers) {
+            options.minLengthNumbers =
+                typeof options.minLengthNumbers == "undefined"
+                    ? 1
+                    : options.minLengthNumbers;
+        }
+        else {
+            options.minLengthNumbers = 0;
+        }
+        if (options.symbols) {
+            options.minLengthSymbols =
+                typeof options.minLengthSymbols == "undefined"
+                    ? 1
+                    : options.minLengthSymbols;
+        }
+        else {
+            options.minLengthSymbols = 0;
+        }
+        options.exclude =
+            typeof options.exclude == "undefined" ? "" : options.exclude;
     }
-
-    if (options.uppercase) {
-      options.minLengthUppercase =
-        typeof options.minLengthUppercase == "undefined"
-          ? 1
-          : options.minLengthUppercase;
-    } else {
-      options.minLengthUppercase = 0;
-    }
-
-    if (options.numbers) {
-      options.minLengthNumbers =
-        typeof options.minLengthNumbers == "undefined"
-          ? 1
-          : options.minLengthNumbers;
-    } else {
-      options.minLengthNumbers = 0;
-    }
-
-    if (options.symbols) {
-      options.minLengthSymbols =
-        typeof options.minLengthSymbols == "undefined"
-          ? 1
-          : options.minLengthSymbols;
-    } else {
-      options.minLengthSymbols = 0;
-    }
-
-    options.exclude =
-      typeof options.exclude == "undefined" ? "" : options.exclude;
-  }
-  return options;
+    return options;
 };
-
-module.exports = processOption;
+exports.processOption = processOption;
+// module.exports = processOption;

package/lib/process-options.ts

@@ -0,0 +1,61 @@
+import { GenerateOptions } from "./types";
+
+export const processOption = (options: GenerateOptions) => {
+  {
+    options.length = typeof options.length == "undefined" ? 10 : options.length;
+
+    options.lowercase =
+      typeof options.lowercase == "undefined" ? true : options.lowercase;
+
+    options.uppercase =
+      typeof options.uppercase == "undefined" ? true : options.uppercase;
+
+    options.numbers =
+      typeof options.numbers == "undefined" ? true : options.numbers;
+
+    options.symbols =
+      typeof options.symbols == "undefined" ? false : options.symbols;
+
+    if (options.lowercase) {
+      options.minLengthLowercase =
+        typeof options.minLengthLowercase == "undefined"
+          ? 1
+          : options.minLengthLowercase;
+    } else {
+      options.minLengthLowercase = 0;
+    }
+
+    if (options.uppercase) {
+      options.minLengthUppercase =
+        typeof options.minLengthUppercase == "undefined"
+          ? 1
+          : options.minLengthUppercase;
+    } else {
+      options.minLengthUppercase = 0;
+    }
+
+    if (options.numbers) {
+      options.minLengthNumbers =
+        typeof options.minLengthNumbers == "undefined"
+          ? 1
+          : options.minLengthNumbers;
+    } else {
+      options.minLengthNumbers = 0;
+    }
+
+    if (options.symbols) {
+      options.minLengthSymbols =
+        typeof options.minLengthSymbols == "undefined"
+          ? 1
+          : options.minLengthSymbols;
+    } else {
+      options.minLengthSymbols = 0;
+    }
+
+    options.exclude =
+      typeof options.exclude == "undefined" ? "" : options.exclude;
+  }
+  return options;
+};
+
+// module.exports = processOption;

package/lib/shuffle-string.js

@@ -1,14 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shuffleString = void 0;
 const shuffleString = (str) => {
-  let arr = str.split("");
-  n = arr.length;
-
-  for (let i = n - 1; i > 0; i--) {
-    let j = Math.floor(Math.random() * (i + 1));
-    let tmp = arr[i];
-    arr[i] = arr[j];
-    arr[j] = tmp;
-  }
-  return arr.join("");
+    let arr = str.split("");
+    let n = arr.length;
+    for (let i = n - 1; i > 0; i--) {
+        let j = Math.floor(Math.random() * (i + 1));
+        let tmp = arr[i];
+        arr[i] = arr[j];
+        arr[j] = tmp;
+    }
+    return arr.join("");
 };
-
-module.exports = shuffleString;
+exports.shuffleString = shuffleString;
+// module.exports = shuffleString;

package/lib/shuffle-string.ts

@@ -0,0 +1,14 @@
+export const shuffleString = (str: string) => {
+  let arr = str.split("");
+  let n = arr.length;
+
+  for (let i = n - 1; i > 0; i--) {
+    let j = Math.floor(Math.random() * (i + 1));
+    let tmp = arr[i];
+    arr[i] = arr[j];
+    arr[j] = tmp;
+  }
+  return arr.join("");
+};
+
+// module.exports = shuffleString;

package/lib/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/types.ts

@@ -0,0 +1,52 @@
+export interface GenerateOptions {
+  /**
+   * lenght of the password
+   * @default 10
+   */
+  length?: number;
+  /**
+   * Should the password include lowercase characters
+   * @default true
+   */
+  lowercase?: boolean;
+  /**
+   * Should the password include uppercase characters
+   * @default true
+   */
+  uppercase?: boolean;
+  /**
+   * Should the password include numbers
+   * @default true
+   */
+  numbers?: boolean;
+  /**
+   * Should the password include symbol characters
+   * @default false
+   */
+  symbols?: boolean;
+  /**
+   * List of characters to be excluded from the password
+   * @default ""
+   */
+  exclude?: string;
+  /**
+   * min lentgh of lowercase character
+   * @default 1
+   */
+  minLengthLowercase?: number;
+  /**
+   * min lentgh of uppercase character
+   * @default 1
+   */
+  minLengthUppercase?: number;
+  /**
+   * min length of numbers
+   * @default 1
+   */
+  minLengthNumbers?: number;
+  /**
+   * min length of symbols
+   * @default 0
+   */
+  minLengthSymbols?: number;
+}

package/package.json

@@ -1,12 +1,10 @@
 {
   "name": "js-generate-password",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "private": false,
   "description": "Password Generator for using in javascirpt/typscript based projects.",
-  "main": "index.js",
-  "bin": "index.js",
-  "exports": "./index.js",
-  "types": "index.d.ts",
+  "main": "./src/index.js",
+  "bin": "./src/index.js",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"
   },

package/{index.d.ts → src/index.d.ts}

@@ -1,4 +1,4 @@
-interface GenerateOptions {
+export interface GenerateOptions {
   /**
    * lenght of the password
    * @default 10

package/src/index.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeneratePassword = void 0;
+const password_generator_1 = require("../lib/password-generator");
+const check_options_error_1 = require("../lib/check-options-error");
+const process_options_1 = require("../lib/process-options");
+// const errorCheck = require("../../lib/check-options-error");
+// const processOptions = require("../../lib/process-options");
+function GeneratePassword(options) {
+    let pswd;
+    if (options) {
+        options = (0, process_options_1.processOption)(options);
+        (0, check_options_error_1.checkError)(options);
+        pswd = (0, password_generator_1.generatePassword)(options);
+        return pswd;
+    }
+    else {
+        let opt = {
+            length: 10,
+            lowercase: true,
+            uppercase: true,
+            numbers: true,
+            symbols: false,
+            exclude: "",
+            minLengthLowercase: 1,
+            minLengthUppercase: 1,
+            minLengthNumbers: 1,
+            minLengthSymbols: 0,
+        };
+        options = (0, process_options_1.processOption)(opt);
+        (0, check_options_error_1.checkError)(options);
+        pswd = (0, password_generator_1.generatePassword)(options);
+        return pswd;
+    }
+}
+exports.GeneratePassword = GeneratePassword;
+exports.default = { GeneratePassword };

package/src/index.ts

@@ -0,0 +1,39 @@
+import { generatePswd } from "../lib/password-generator";
+import { checkError } from "../lib/check-options-error";
+import { processOption } from "../lib/process-options";
+import { GenerateOptions } from "../lib/types";
+
+function GeneratePassword(options?: GenerateOptions) {
+  let pswd;
+  if (options) {
+    options = processOption(options);
+
+    checkError(options);
+
+    pswd = generatePswd(options);
+    return pswd;
+  } else {
+    let opt = {
+      length: 10,
+      lowercase: true,
+      uppercase: true,
+      numbers: true,
+      symbols: false,
+      exclude: "",
+      minLengthLowercase: 1,
+      minLengthUppercase: 1,
+      minLengthNumbers: 1,
+      minLengthSymbols: 0,
+    };
+    options = processOption(opt);
+
+    checkError(options);
+
+    pswd = generatePswd(options);
+    return pswd;
+  }
+}
+
+// console.log(GeneratePassword({ minLengthLowercase: 4 }));
+export { GeneratePassword };
+export default { GeneratePassword };

package/index.js

@@ -1,16 +0,0 @@
-const passwords = require("./lib/password-generator.js");
-const errorCheck = require("./lib/check-options-error");
-const processOptions = require("./lib/process-options");
-
-function GeneratePassword(options) {
-  options = processOptions(options);
-
-  errorCheck(options);
-
-  const pswd = passwords(options);
-
-  return pswd;
-}
-
-exports.default = GeneratePassword;
-module.exports = GeneratePassword;