Move the length argument to the options-object

Author: sindresorhus

index.d.ts

@@ -1,63 +1,70 @@
 import {MergeExclusive} from 'type-fest';
 
+interface BaseOptions {
+	/**
+	Length of the returned string.
+	*/
+	length: number;
+}
+
+interface TypeOption {
+	/**
+	Use only characters from a predefined set of allowed characters.
+
+	Cannot be set at the same time as the `characters` option.
+
+	@default 'hex'
+
+	@example
+	```
+	cryptoRandomString({length: 10});
+	//=> '87fc70e2b9'
+
+	cryptoRandomString({length: 10, type:'base64'});
+	//=> 'mhsX7xmIv/'
+
+	cryptoRandomString({length: 10, type:'url-safe'});
+	//=> 'VEjfNW3Yej'
+	```
+	*/
+	type?: 'hex' | 'base64' | 'url-safe';
+}
+
+interface CharactersOption {
+	/**
+	Use only characters from a custom set of allowed characters.
+
+	Cannot be set at the same time as the `type` option.
+
+	Minimum length: `1`
+	Maximum length: `65536`
+
+	@example
+	```
+	cryptoRandomString({length: 10, characters:'0123456789'});
+	//=> '8796225811'
+	```
+	*/
+	characters?: string;
+}
+
 declare namespace cryptoRandomString {
-	interface TypeOptions {
-		/**
-		Use only characters from a predefined set of allowed characters.
-
-		Cannot be set at the same time as the `characters` option.
-
-		@default 'hex'
-
-		@example
-		```
-		cryptoRandomString(10, {type:'hex'});
-		//=> '87fc70e2b9'
-
-		cryptoRandomString(10, {type:'base64'});
-		//=> 'mhsX7xmIv/'
-
-		cryptoRandomString(10, {type:'url-safe'});
-		//=> 'VEjfNW3Yej'
-		```
-		*/
-		type?: 'hex' | 'base64' | 'url-safe';
-	}
-
-	interface CharactersOptions {
-		/**
-		Use only characters from a custom set of allowed characters.
-
-		Cannot be set at the same time as the `type` option.
-		
-		Minimum length: `1`
-		Maximum length: `65536`
-
-		@example
-		```
-		cryptoRandomString(10, {characters:'0123456789'});
-		//=> '8796225811'
-		```
-		*/
-		characters: string;
-	}
-	type Options = MergeExclusive<TypeOptions, CharactersOptions>;
+	type Options = BaseOptions & MergeExclusive<TypeOption, CharactersOption>;
 }
 
 /**
 Generate a [cryptographically strong](https://en.wikipedia.org/wiki/Strong_cryptography) random string.
 
-@param length - Length of the returned string.
-@returns Returns a randomized string.
+@returns A randomized string.
 
 @example
 ```
 import cryptoRandomString = require('crypto-random-string');
 
-cryptoRandomString(10);
+cryptoRandomString({length: 10});
 //=> '2cf05d94db'
 ```
 */
-declare function cryptoRandomString(length: number, options?: cryptoRandomString.Options): string;
+declare function cryptoRandomString(options?: cryptoRandomString.Options): string;
 
 export = cryptoRandomString;

index.js

@@ -1,11 +1,11 @@
 'use strict';
 const crypto = require('crypto');
 
-const urlSafeChars = 'abcdefjhijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-._~'.split('');
+const urlSafeCharacters = 'abcdefjhijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-._~'.split('');
 
-const generateForCustomCharacters = (length, chars) => {
+const generateForCustomCharacters = (length, characters) => {
 	// Generating entropy is faster than complex math operations, so we use the simplest way
-	const characterCount = chars.length;
+	const characterCount = characters.length;
 	const maxValidSelector = (Math.floor(0x10000 / characterCount) * characterCount) - 1; // Using values above this will ruin distribution when using modular division
 	const entropyLength = 2 * Math.ceil(1.1 * length); // Generating a bit more than required so chances we need more than one pass will be really low
 	let string = '';
@@ -22,24 +22,26 @@ const generateForCustomCharacters = (length, chars) => {
 				continue;
 			}
 
-			string += chars[entropyValue % characterCount];
+			string += characters[entropyValue % characterCount];
 			stringLength++;
 		}
 	}
 
 	return string;
 };
 
-const allowedTypes = [undefined, 'hex', 'base64', 'url-safe'];
+const allowedTypes = [
+	undefined,
+	'hex',
+	'base64',
+	'url-safe'
+];
 
-module.exports = (length, opts) => {
+module.exports = ({length, type, characters}) => {
 	if (!Number.isFinite(length)) {
 		throw new TypeError('Expected a finite number');
 	}
 
-	let type = opts === undefined ? undefined : opts.type;
-	const characters = opts === undefined ? undefined : opts.characters;
-
 	if (type !== undefined && characters !== undefined) {
 		throw new TypeError('Expected either type or characters');
 	}
@@ -65,7 +67,7 @@ module.exports = (length, opts) => {
 	}
 
 	if (type === 'url-safe') {
-		return generateForCustomCharacters(length, urlSafeChars);
+		return generateForCustomCharacters(length, urlSafeCharacters);
 	}
 
 	if (characters.length === 0) {

index.test-d.ts

@@ -1,6 +1,9 @@
-import {expectType} from 'tsd';
+import {expectType, expectError} from 'tsd';
 import cryptoRandomString = require('.');
 
-expectType<string>(cryptoRandomString(10));
-expectType<string>(cryptoRandomString(10, {type: 'url-safe'}));
-expectType<string>(cryptoRandomString(10, {characters: '1234'}));
+expectType<string>(cryptoRandomString({length: 10}));
+expectType<string>(cryptoRandomString({length: 10, type: 'url-safe'}));
+expectType<string>(cryptoRandomString({length: 10, characters: '1234'}));
+
+expectError(cryptoRandomString({type: 'url-safe'}));
+expectError(cryptoRandomString({length: 10, type: 'url-safe', characters: '1234'}));

readme.md

@@ -1,6 +1,6 @@
 # crypto-random-string [![Build Status](https://travis-ci.org/sindresorhus/crypto-random-string.svg?branch=master)](https://travis-ci.org/sindresorhus/crypto-random-string)
 
-> Generate a [cryptographically strong](https://en.m.wikipedia.org/wiki/Strong_cryptography) random string
+> Generate a [cryptographically strong](https://en.wikipedia.org/wiki/Strong_cryptography) random string
 
 Can be useful for creating an identifier, slug, salt, fixture, etc.
 
@@ -17,44 +17,42 @@ $ npm install crypto-random-string
 ```js
 const cryptoRandomString = require('crypto-random-string');
 
-cryptoRandomString(10);
+cryptoRandomString({length: 10});
 //=> '2cf05d94db'
 
-cryptoRandomString(10, {type: 'hex'});
-//=> 'c00f094c79'
-
-cryptoRandomString(10, {type: 'base64'});
+cryptoRandomString({length: 10, type: 'base64'});
 //=> 'YMiMbaQl6I'
 
-cryptoRandomString(10, {type: 'url-safe'});
+cryptoRandomString({length: 10, type: 'url-safe'});
 //=> 'YN-tqc8pOw'
 
-cryptoRandomString(10, {characters: '1234567890'});
+cryptoRandomString({length: 10, characters: '1234567890'});
 //=> '1791935639'
 ```
 
 
 ## API
 
-### cryptoRandomString(length, [options])
+### cryptoRandomString(options)
 
 Returns a randomized string. [Hex](https://en.wikipedia.org/wiki/Hexadecimal) by default.
 
-#### length
+#### options
 
-Type: `number`
+Type: `object`
 
-Length of the returned string.
+##### length
 
-#### options
+*Required*<br>
+Type: `number`
 
-Type: `object`
+Length of the returned string.
 
 ##### type
 
 Type: `string`<br>
-Default: `hex`<br>
-Values: `hex` `base64` `url-safe`
+Default: `'hex'`<br>
+Values: `'hex'` `'base64'` `'url-safe'`
 
 Use only characters from a predefined set of allowed characters.
 

test.js

@@ -2,54 +2,54 @@ import test from 'ava';
 import cryptoRandomString from '.';
 
 test('main', t => {
-	t.is(cryptoRandomString(0).length, 0);
-	t.is(cryptoRandomString(10).length, 10);
-	t.is(cryptoRandomString(100).length, 100);
-	t.regex(cryptoRandomString(100), /^[a-f\d]*$/); // Sanity check, probabilistic
+	t.is(cryptoRandomString({length: 0}).length, 0);
+	t.is(cryptoRandomString({length: 10}).length, 10);
+	t.is(cryptoRandomString({length: 100}).length, 100);
+	t.regex(cryptoRandomString({length: 100}), /^[a-f\d]*$/); // Sanity check, probabilistic
 });
 
 test('hex', t => {
-	t.is(cryptoRandomString(0, {type: 'hex'}).length, 0);
-	t.is(cryptoRandomString(10, {type: 'hex'}).length, 10);
-	t.is(cryptoRandomString(100, {type: 'hex'}).length, 100);
-	t.regex(cryptoRandomString(100, {type: 'hex'}), /^[a-f\d]*$/); // Sanity check, probabilistic
+	t.is(cryptoRandomString({length: 0, type: 'hex'}).length, 0);
+	t.is(cryptoRandomString({length: 10, type: 'hex'}).length, 10);
+	t.is(cryptoRandomString({length: 100, type: 'hex'}).length, 100);
+	t.regex(cryptoRandomString({length: 100, type: 'hex'}), /^[a-f\d]*$/); // Sanity check, probabilistic
 });
 
 test('base64', t => {
-	t.is(cryptoRandomString(0, {type: 'base64'}).length, 0);
-	t.is(cryptoRandomString(10, {type: 'base64'}).length, 10);
-	t.is(cryptoRandomString(100, {type: 'base64'}).length, 100);
-	t.regex(cryptoRandomString(100, {type: 'base64'}), /^[a-zA-Z\d/+]*$/); // Sanity check, probabilistic
+	t.is(cryptoRandomString({length: 0, type: 'base64'}).length, 0);
+	t.is(cryptoRandomString({length: 10, type: 'base64'}).length, 10);
+	t.is(cryptoRandomString({length: 100, type: 'base64'}).length, 100);
+	t.regex(cryptoRandomString({length: 100, type: 'base64'}), /^[a-zA-Z\d/+]*$/); // Sanity check, probabilistic
 });
 
 test('url-safe', t => {
-	t.is(cryptoRandomString(0, {type: 'url-safe'}).length, 0);
-	t.is(cryptoRandomString(10, {type: 'url-safe'}).length, 10);
-	t.is(cryptoRandomString(100, {type: 'url-safe'}).length, 100);
-	t.regex(cryptoRandomString(100, {type: 'url-safe'}), /^[a-zA-Z\d._~-]*$/); // Sanity check, probabilistic
+	t.is(cryptoRandomString({length: 0, type: 'url-safe'}).length, 0);
+	t.is(cryptoRandomString({length: 10, type: 'url-safe'}).length, 10);
+	t.is(cryptoRandomString({length: 100, type: 'url-safe'}).length, 100);
+	t.regex(cryptoRandomString({length: 100, type: 'url-safe'}), /^[a-zA-Z\d._~-]*$/); // Sanity check, probabilistic
 });
 
 test('characters', t => {
-	t.is(cryptoRandomString(0, {characters: '1234'}).length, 0);
-	t.is(cryptoRandomString(10, {characters: '1234'}).length, 10);
-	t.is(cryptoRandomString(100, {characters: '1234'}).length, 100);
-	t.regex(cryptoRandomString(100, {characters: '1234'}), /^[1-4]*$/); // Sanity check, probabilistic
+	t.is(cryptoRandomString({length: 0, characters: '1234'}).length, 0);
+	t.is(cryptoRandomString({length: 10, characters: '1234'}).length, 10);
+	t.is(cryptoRandomString({length: 100, characters: '1234'}).length, 100);
+	t.regex(cryptoRandomString({length: 100, characters: '1234'}), /^[1-4]*$/); // Sanity check, probabilistic
 });
 
 test('argument errors', t => {
 	t.throws(() => {
-		cryptoRandomString(Infinity);
+		cryptoRandomString({length: Infinity});
 	});
 
 	t.throws(() => {
-		cryptoRandomString(0, {type: 'hex', characters: '1234'});
+		cryptoRandomString({length: 0, type: 'hex', characters: '1234'});
 	});
 
 	t.throws(() => {
-		cryptoRandomString(0, {characters: 42});
+		cryptoRandomString({length: 0, characters: 42});
 	});
 
 	t.throws(() => {
-		cryptoRandomString(0, {type: 'unknown'});
+		cryptoRandomString({length: 0, type: 'unknown'});
 	});
 });