js-generate-password 0.1.5 → 0.1.7

package/dist/index.js

@@ -32,5 +32,4 @@ function GeneratePassword(options) {
     }
 }
 exports.GeneratePassword = GeneratePassword;
-console.log(GeneratePassword({ minLengthLowercase: 4 }));
 exports.default = { GeneratePassword };

package/package.json

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

package/src/index.d.ts

@@ -55,4 +55,4 @@ declare namespace GeneratePassword {}
 
 declare function GeneratePassword(options?: GenerateOptions): string;
 
-export default GeneratePassword;
+export { GeneratePassword };

package/src/index.ts

@@ -34,6 +34,6 @@ function GeneratePassword(options?: GenerateOptions) {
   }
 }
 
-console.log(GeneratePassword({ minLengthLowercase: 4 }));
+// console.log(GeneratePassword({ minLengthLowercase: 4 }));
 export { GeneratePassword };
 export default { GeneratePassword };

package/src/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/src/lib/generate-random-number.ts

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

package/src/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/src/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/src/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/src/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;
+}