@stdlib/utils-async-group-by 0.0.8 → 0.2.0

package/docs/types/index.d.ts

@@ -16,129 +16,224 @@
 * limitations under the License.
 */
 
-// TypeScript Version: 2.0
+// TypeScript Version: 4.1
 
 /// <reference types="@stdlib/types"/>
 
-import { Collection } from '@stdlib/types/object';
+import { Collection } from '@stdlib/types/array';
 
 /**
 * Interface defining function options.
 */
-interface Options {
+interface BaseOptions<T, V> {
+	/**
+	* Execution context.
+	*/
+	thisArg?: ThisParameterType<Indicator<T, V>>;
+
 	/**
 	* The maximum number of pending invocations at any one time.
 	*/
 	limit?: number;
 
 	/**
-	* Boolean indicating whether to wait for a previous invocation to complete before invoking a provided function for the next element in a collection (default: false).
+	* Boolean indicating whether to sequentially invoke the `indicator` function for each `collection` element. If `true`, the function sets `options.limit=1`.
 	*/
 	series?: boolean;
+}
 
+/**
+* Interface defining function options.
+*/
+interface ValuesOptions<T, V> extends BaseOptions<T, V> {
 	/**
-	* Execution context.
+	* Indicates that the function should return collection values when grouping.
+	*/
+	returns: 'values';
+}
+
+/**
+* Interface defining function options.
+*/
+interface IndicesOptions<T, V> extends BaseOptions<T, V> {
+	/**
+	* Indicates that the function should return collection indices when grouping.
+	*/
+	returns: 'indices';
+}
+
+/**
+* Interface defining function options.
+*/
+interface IndicesAndValuesOptions<T, V> extends BaseOptions<T, V> {
+	/**
+	* Indicates to return both indices and values when grouping collection elements.
+	*/
+	returns: '*';
+}
+
+/**
+* Interface describing group results when returning values.
+*/
+interface ValuesResults<T> {
+	/**
+	* Results for an individual group.
 	*/
-	thisArg?: any;
+	[ key: string ]: Array<T>;
+}
+
+/**
+* Interface describing group results when returning indices.
+*/
+interface IndicesResults<T> {
+	/**
+	* Results for an individual group.
+	*/
+	[ key: string ]: Array<number>;
+}
 
+/**
+* Interface describing group results when returning indices and values.
+*/
+interface IndicesAndValuesResults<T> {
 	/**
-	* If `values`, values are returned; if `indices`, indices are returned; if `*`, both indices and values are returned (default: 'values').
+	* Results for an individual group.
 	*/
-	returns?: 'values' | 'indices' | '*';
+	[ key: string ]: Array<[ number, T ]>;
 }
 
 /**
 * Callback invoked either upon processing all collection elements or upon encountering an error.
 */
-type DoneNullary = () => void;
+type Nullary = () => void;
 
 /**
 * Callback invoked either upon processing all collection elements or upon encountering an error.
 *
 * @param error - encountered error or null
 */
-type DoneUnary = ( error: Error | null ) => void;
+type Unary = ( error: Error | null ) => void;
 
 /**
 * Callback invoked either upon processing all collection elements or upon encountering an error.
 *
 * @param error - encountered error or null
-* @param result - group-by result
+* @param result - group results
 */
-type DoneBinary = ( error: Error | null, result: any ) => void;
+type ValuesBinary<T> = ( error: Error | null, result: ValuesResults<T> ) => void;
 
 /**
 * Callback invoked either upon processing all collection elements or upon encountering an error.
 *
 * @param error - encountered error or null
-* @param result - group-by result
+* @param result - group results
 */
-type DoneCallback = DoneNullary | DoneUnary | DoneBinary;
+type IndicesBinary<T> = ( error: Error | null, result: IndicesResults<T> ) => void;
 
 /**
-* Callback function.
+* Callback invoked either upon processing all collection elements or upon encountering an error.
+*
+* @param error - encountered error or null
+* @param result - group results
 */
-type Nullary = () => void;
+type IndicesAndValuesBinary<T> = ( error: Error | null, result: IndicesAndValuesResults<T> ) => void;
+
+/**
+* Callback invoked either upon processing all collection elements or upon encountering an error.
+*
+* @param error - encountered error or null
+* @param result - group results
+*/
+type ValuesCallback<T> = Nullary | Unary | ValuesBinary<T>;
 
 /**
-* Callback function.
+* Callback invoked either upon processing all collection elements or upon encountering an error.
 *
 * @param error - encountered error or null
+* @param result - group results
 */
-type Unary = ( error: Error | null ) => void;
+type IndicesCallback<T> = Nullary | Unary | IndicesBinary<T>;
+
+/**
+* Callback invoked either upon processing all collection elements or upon encountering an error.
+*
+* @param error - encountered error or null
+* @param result - group results
+*/
+type IndicesAndValuesCallback<T> = Nullary | Unary | IndicesAndValuesBinary<T>;
+
+/**
+* Callback function to invoke once the indicator function has finished processing a collection value.
+*/
+type NullaryNext = () => void;
+
+/**
+* Callback function to invoke once the indicator function has finished processing a collection value.
+*
+* @param error - encountered error or null
+*/
+type UnaryNext = ( error: Error | null ) => void;
 
 /**
-* Callback function.
+* Callback function to invoke once the indicator function has finished processing a collection value.
 *
 * @param error - encountered error or null
 * @param group - value group
 */
-type Binary = ( error: Error | null, group: string ) => void;
+type BinaryNext = ( error: Error | null, group: string ) => void;
 
 /**
-* Callback function.
+* Callback function to invoke once the indicator function has finished processing a collection value.
 *
 * @param error - encountered error or null
 * @param group - value group
 */
-type Callback = Nullary | Unary | Binary;
+type Next = NullaryNext | UnaryNext | BinaryNext;
 
 /**
-* Checks whether an element in a collection passes a test.
+* Returns the group to which a collection element belongs.
 *
 * @param value - collection value
 * @param next - a callback to be invoked after processing a collection `value`
 */
-type BinaryIndicator = ( value: any, next: Callback ) => void;
+type BinaryIndicator<T, V> = ( this: V, value: T, next: Next ) => void;
 
 /**
-* Checks whether an element in a collection passes a test.
+* Returns the group to which a collection element belongs.
 *
 * @param value - collection value
 * @param index - collection index
 * @param next - a callback to be invoked after processing a collection `value`
 */
-type TernaryIndicator = ( value: any, index: number, next: Callback ) => void;
+type TernaryIndicator<T, V> = ( this: V, value: T, index: number, next: Next ) => void;
 
 /**
-* Checks whether an element in a collection passes a test.
+* Returns the group to which a collection element belongs.
 *
 * @param value - collection value
 * @param index - collection index
 * @param collection - input collection
 * @param next - a callback to be invoked after processing a collection `value`
 */
-type QuaternaryIndicator = ( value: any, index: number, collection: Collection, next: Callback ) => void; // tslint-disable-line max-line-length
+type QuaternaryIndicator<T, V> = ( this: V, value: T, index: number, collection: Collection<T>, next: Next ) => void;
 
 /**
-* Checks whether an element in a collection passes a test.
+* Returns the group to which a collection element belongs.
 *
 * @param value - collection value
 * @param index - collection index
 * @param collection - input collection
 * @param next - a callback to be invoked after processing a collection `value`
 */
-type Indicator = Unary | BinaryIndicator | TernaryIndicator | QuaternaryIndicator; // tslint-disable-line max-line-length
+type Indicator<T, V> = BinaryIndicator<T, V> | TernaryIndicator<T, V> | QuaternaryIndicator<T, V>;
+
+/**
+* Invokes an indicator function for each element in a collection.
+*
+* @param collection - input collection
+* @param done - function to invoke upon completion
+*/
+type ValuesFactoryFunction<T> = ( collection: Collection<T>, done: ValuesCallback<T> ) => void;
 
 /**
 * Invokes an indicator function for each element in a collection.
@@ -146,7 +241,15 @@ type Indicator = Unary | BinaryIndicator | TernaryIndicator | QuaternaryIndicato
 * @param collection - input collection
 * @param done - function to invoke upon completion
 */
-type FactoryFunction = ( collection: Collection, done: DoneCallback ) => void;
+type IndicesFactoryFunction<T> = ( collection: Collection<T>, done: IndicesCallback<T> ) => void;
+
+/**
+* Invokes an indicator function for each element in a collection.
+*
+* @param collection - input collection
+* @param done - function to invoke upon completion
+*/
+type IndicesAndValuesFactoryFunction<T> = ( collection: Collection<T>, done: IndicesAndValuesCallback<T> ) => void;
 
 /**
 * Interface for `groupByAsync`.
@@ -159,6 +262,55 @@ interface GroupByAsync {
 	*
 	* -   This function does **not** guarantee that execution is asynchronous. To do so, wrap the `done` callback in a function which either executes at the end of the current stack (e.g., `nextTick`) or during a subsequent turn of the event loop (e.g., `setImmediate`, `setTimeout`).
 	*
+	* @param collection - input collection
+	* @param options - function options
+	* @param options.thisArg - execution context
+	* @param options.limit - maximum number of pending invocations at any one time
+	* @param options.series - boolean indicating whether to wait for a previous invocation to complete before invoking a provided function for the next element in a collection (default: false)
+	* @param options.returns - if `values`, values are returned; if `indices`, indices are returned; if `*`, both indices and values are returned (default: 'values')
+	* @param indicator - indicator function specifying which group an element in the input collection belongs to
+	* @param done - function to invoke upon completion
+	* @throws must provide valid options
+	*
+	* @example
+	* var readFile = require( '@stdlib/fs-read-file' );
+	*
+	* function done( error, result ) {
+	*     if ( error ) {
+	*         throw error;
+	*     }
+	*     console.log( result );
+	* }
+	*
+	* function indicator( file, next ) {
+	*     var opts = {
+	*         'encoding': 'utf8'
+	*     };
+	*     readFile( file, opts, onFile );
+	*
+	*     function onFile( error ) {
+	*         if ( error ) {
+	*             return next( null, 'nonreadable' );
+	*         }
+	*         next( null, 'readable' );
+	*     }
+	* }
+	*
+	* var files = [
+	*     './beep.js',
+	*     './boop.js'
+	* ];
+	*
+	* groupByAsync( files, {}, indicator, done );
+	*/
+	<T = unknown, V = unknown>( collection: Collection<T>, options: IndicesOptions<T, V>, indicator: Indicator<T, V>, done: IndicesCallback<T> ): void;
+
+	/**
+	* Groups values according to an indicator function.
+	*
+	* ## Notes
+	*
+	* -   This function does **not** guarantee that execution is asynchronous. To do so, wrap the `done` callback in a function which either executes at the end of the current stack (e.g., `nextTick`) or during a subsequent turn of the event loop (e.g., `setImmediate`, `setTimeout`).
 	*
 	* @param collection - input collection
 	* @param options - function options
@@ -171,7 +323,7 @@ interface GroupByAsync {
 	* @throws must provide valid options
 	*
 	* @example
-	* var readFile = require( `@stdlib/fs/read-file` );
+	* var readFile = require( '@stdlib/fs-read-file' );
 	*
 	* function done( error, result ) {
 	*     if ( error ) {
@@ -201,7 +353,7 @@ interface GroupByAsync {
 	*
 	* groupByAsync( files, {}, indicator, done );
 	*/
-	( collection: Collection, options: Options, indicator: Indicator, done: DoneCallback ): void; // tslint-disable-line max-line-length
+	<T = unknown, V = unknown>( collection: Collection<T>, options: IndicesAndValuesOptions<T, V>, indicator: Indicator<T, V>, done: IndicesAndValuesCallback<T> ): void;
 
 	/**
 	* Groups values according to an indicator function.
@@ -210,13 +362,62 @@ interface GroupByAsync {
 	*
 	* -   This function does **not** guarantee that execution is asynchronous. To do so, wrap the `done` callback in a function which either executes at the end of the current stack (e.g., `nextTick`) or during a subsequent turn of the event loop (e.g., `setImmediate`, `setTimeout`).
 	*
+	* @param collection - input collection
+	* @param options - function options
+	* @param options.thisArg - execution context
+	* @param options.limit - maximum number of pending invocations at any one time
+	* @param options.series - boolean indicating whether to wait for a previous invocation to complete before invoking a provided function for the next element in a collection (default: false)
+	* @param options.returns - if `values`, values are returned; if `indices`, indices are returned; if `*`, both indices and values are returned (default: 'values')
+	* @param indicator - indicator function specifying which group an element in the input collection belongs to
+	* @param done - function to invoke upon completion
+	* @throws must provide valid options
+	*
+	* @example
+	* var readFile = require( '@stdlib/fs-read-file' );
+	*
+	* function done( error, result ) {
+	*     if ( error ) {
+	*         throw error;
+	*     }
+	*     console.log( result );
+	* }
+	*
+	* function indicator( file, next ) {
+	*     var opts = {
+	*         'encoding': 'utf8'
+	*     };
+	*     readFile( file, opts, onFile );
+	*
+	*     function onFile( error ) {
+	*         if ( error ) {
+	*             return next( null, 'nonreadable' );
+	*         }
+	*         next( null, 'readable' );
+	*     }
+	* }
+	*
+	* var files = [
+	*     './beep.js',
+	*     './boop.js'
+	* ];
+	*
+	* groupByAsync( files, {}, indicator, done );
+	*/
+	<T = unknown, V = unknown>( collection: Collection<T>, options: ValuesOptions<T, V> | BaseOptions<T, V>, indicator: Indicator<T, V>, done: ValuesCallback<T> ): void;
+
+	/**
+	* Groups values according to an indicator function.
+	*
+	* ## Notes
+	*
+	* -   This function does **not** guarantee that execution is asynchronous. To do so, wrap the `done` callback in a function which either executes at the end of the current stack (e.g., `nextTick`) or during a subsequent turn of the event loop (e.g., `setImmediate`, `setTimeout`).
 	*
 	* @param collection - input collection
 	* @param indicator - indicator function specifying which group an element in the input collection belongs to
 	* @param done - function to invoke upon completion
 	*
 	* @example
-	* var readFile = require( `@stdlib/fs/read-file` );
+	* var readFile = require( '@stdlib/fs-read-file' );
 	*
 	* function done( error, result ) {
 	*     if ( error ) {
@@ -246,7 +447,7 @@ interface GroupByAsync {
 	*
 	* groupByAsync( files, indicator, done );
 	*/
-	( collection: Collection, indicator: Indicator, done: DoneCallback ): void;
+	<T = unknown, V = unknown>( collection: Collection<T>, indicator: Indicator<T, V>, done: ValuesCallback<T> ): void;
 
 	/**
 	* Returns a function for grouping values according to an indicator function.
@@ -255,6 +456,64 @@ interface GroupByAsync {
 	*
 	* -   This function does **not** guarantee that execution is asynchronous. To do so, wrap the `done` callback in a function which either executes at the end of the current stack (e.g., `nextTick`) or during a subsequent turn of the event loop (e.g., `setImmediate`, `setTimeout`).
 	*
+	* @param options - function options
+	* @param options.thisArg - execution context
+	* @param options.limit - maximum number of pending invocations at any one time
+	* @param options.series - boolean indicating whether to wait for a previous invocation to complete before invoking a provided function for the next element in a collection (default: false)
+	* @param options.returns - if `values`, values are returned; if `indices`, indices are returned; if `*`, both indices and values are returned (default: 'values')
+	* @param indicator - indicator function specifying which group an element in the input collection belongs to
+	* @throws must provide valid options
+	* @returns function which invokes the indicator function once for each element in a collection
+	*
+	* @example
+	* var readFile = require( '@stdlib/fs-read-file' );
+	*
+	* function indicator( file, next ) {
+	*     var opts = {
+	*         'encoding': 'utf8'
+	*     };
+	*     readFile( file, opts, onFile );
+	*
+	*     function onFile( error ) {
+	*         if ( error ) {
+	*             return next( null, 'nonreadable' );
+	*         }
+	*         next( null, 'readable' );
+	*     }
+	* }
+	*
+	* var opts = {
+	*     'series': true
+	* };
+	*
+	* // Create a `groupByAsync` function which invokes the indicator function for each collection element sequentially:
+	* var groupByAsync = factory( opts, indicator );
+	*
+	* // Create a collection over which to iterate:
+	* var files = [
+	*     './beep.js',
+	*     './boop.js'
+	* ];
+	*
+	* // Define a callback which handles results:
+	* function done( error, result ) {
+	*     if ( error ) {
+	*         throw error;
+	*     }
+	*     console.log( result );
+	* }
+	*
+	* // Try to read each element in `files`:
+	* groupByAsync( files, done );
+	*/
+	factory<T = unknown, V = unknown>( options: IndicesOptions<T, V>, indicator: Indicator<T, V> ): IndicesFactoryFunction<T>;
+
+	/**
+	* Returns a function for grouping values according to an indicator function.
+	*
+	* ## Notes
+	*
+	* -   This function does **not** guarantee that execution is asynchronous. To do so, wrap the `done` callback in a function which either executes at the end of the current stack (e.g., `nextTick`) or during a subsequent turn of the event loop (e.g., `setImmediate`, `setTimeout`).
 	*
 	* @param options - function options
 	* @param options.thisArg - execution context
@@ -266,7 +525,7 @@ interface GroupByAsync {
 	* @returns function which invokes the indicator function once for each element in a collection
 	*
 	* @example
-	* var readFile = require( `@stdlib/fs/read-file` );
+	* var readFile = require( '@stdlib/fs-read-file' );
 	*
 	* function indicator( file, next ) {
 	*     var opts = {
@@ -306,7 +565,7 @@ interface GroupByAsync {
 	* // Try to read each element in `files`:
 	* groupByAsync( files, done );
 	*/
-	factory( options: Options, indicator: Indicator ): FactoryFunction;
+	factory<T = unknown, V = unknown>( options: IndicesAndValuesOptions<T, V>, indicator: Indicator<T, V> ): IndicesAndValuesFactoryFunction<T>;
 
 	/**
 	* Returns a function for grouping values according to an indicator function.
@@ -315,12 +574,70 @@ interface GroupByAsync {
 	*
 	* -   This function does **not** guarantee that execution is asynchronous. To do so, wrap the `done` callback in a function which either executes at the end of the current stack (e.g., `nextTick`) or during a subsequent turn of the event loop (e.g., `setImmediate`, `setTimeout`).
 	*
+	* @param options - function options
+	* @param options.thisArg - execution context
+	* @param options.limit - maximum number of pending invocations at any one time
+	* @param options.series - boolean indicating whether to wait for a previous invocation to complete before invoking a provided function for the next element in a collection (default: false)
+	* @param options.returns - if `values`, values are returned; if `indices`, indices are returned; if `*`, both indices and values are returned (default: 'values')
+	* @param indicator - indicator function specifying which group an element in the input collection belongs to
+	* @throws must provide valid options
+	* @returns function which invokes the indicator function once for each element in a collection
+	*
+	* @example
+	* var readFile = require( '@stdlib/fs-read-file' );
+	*
+	* function indicator( file, next ) {
+	*     var opts = {
+	*         'encoding': 'utf8'
+	*     };
+	*     readFile( file, opts, onFile );
+	*
+	*     function onFile( error ) {
+	*         if ( error ) {
+	*             return next( null, 'nonreadable' );
+	*         }
+	*         next( null, 'readable' );
+	*     }
+	* }
+	*
+	* var opts = {
+	*     'series': true
+	* };
+	*
+	* // Create a `groupByAsync` function which invokes the indicator function for each collection element sequentially:
+	* var groupByAsync = factory( opts, indicator );
+	*
+	* // Create a collection over which to iterate:
+	* var files = [
+	*     './beep.js',
+	*     './boop.js'
+	* ];
+	*
+	* // Define a callback which handles results:
+	* function done( error, result ) {
+	*     if ( error ) {
+	*         throw error;
+	*     }
+	*     console.log( result );
+	* }
+	*
+	* // Try to read each element in `files`:
+	* groupByAsync( files, done );
+	*/
+	factory<T = unknown, V = unknown>( options: ValuesOptions<T, V> | BaseOptions<T, V>, indicator: Indicator<T, V> ): ValuesFactoryFunction<T>;
+
+	/**
+	* Returns a function for grouping values according to an indicator function.
+	*
+	* ## Notes
+	*
+	* -   This function does **not** guarantee that execution is asynchronous. To do so, wrap the `done` callback in a function which either executes at the end of the current stack (e.g., `nextTick`) or during a subsequent turn of the event loop (e.g., `setImmediate`, `setTimeout`).
 	*
 	* @param indicator - indicator function specifying which group an element in the input collection belongs to
 	* @returns function which invokes the indicator function once for each element in a collection
 	*
 	* @example
-	* var readFile = require( `@stdlib/fs/read-file` );
+	* var readFile = require( '@stdlib/fs-read-file' );
 	*
 	* function indicator( file, next ) {
 	*     var opts = {
@@ -356,7 +673,7 @@ interface GroupByAsync {
 	* // Try to read each element in `files`:
 	* groupByAsync( files, done );
 	*/
-	factory( indicator: Indicator ): FactoryFunction;
+	factory<T = unknown, V = unknown>( indicator: Indicator<T, V> ): ValuesFactoryFunction<T>;
 }
 
 /**
@@ -366,7 +683,6 @@ interface GroupByAsync {
 *
 * -   This function does **not** guarantee that execution is asynchronous. To do so, wrap the `done` callback in a function which either executes at the end of the current stack (e.g., `nextTick`) or during a subsequent turn of the event loop (e.g., `setImmediate`, `setTimeout`).
 *
-*
 * @param collection - input collection
 * @param options - function options
 * @param options.thisArg - execution context
@@ -378,7 +694,7 @@ interface GroupByAsync {
 * @throws must provide valid options
 *
 * @example
-* var readFile = require( `@stdlib/fs/read-file` );
+* var readFile = require( '@stdlib/fs-read-file' );
 *
 * function done( error, result ) {
 *     if ( error ) {

package/lib/factory.js

@@ -22,6 +22,7 @@
 
 var isFunction = require( '@stdlib/assert-is-function' );
 var isCollection = require( '@stdlib/assert-is-collection' );
+var format = require( '@stdlib/string-format' );
 var PINF = require( '@stdlib/constants-float64-pinf' );
 var validate = require( './validate.js' );
 var limit = require( './limit.js' );
@@ -36,7 +37,6 @@ var limit = require( './limit.js' );
 *
 * -   This function does **not** guarantee that execution is asynchronous. To do so, wrap the `done` callback in a function which either executes at the end of the current stack (e.g., `nextTick`) or during a subsequent turn of the event loop (e.g., `setImmediate`, `setTimeout`).
 *
-*
 * @param {Options} [options] - function options
 * @param {*} [options.thisArg] - execution context
 * @param {PositiveInteger} [options.limit] - maximum number of pending invocations at any one time
@@ -105,7 +105,7 @@ function factory( options, indicator ) {
 		f = options;
 	}
 	if ( !isFunction( f ) ) {
-		throw new TypeError( 'invalid argument. Last argument must be a function. Value: `'+f+'`.' );
+		throw new TypeError( format( 'invalid argument. Last argument must be a function. Value: `%s`.', f ) );
 	}
 	if ( opts.series ) {
 		opts.limit = 1;
@@ -126,10 +126,10 @@ function factory( options, indicator ) {
 	*/
 	function groupByAsync( collection, done ) {
 		if ( !isCollection( collection ) ) {
-			throw new TypeError( 'invalid argument. First argument must be a collection. Value: `'+collection+'.`' );
+			throw new TypeError( format( 'invalid argument. First argument must be a collection. Value: `%s`.', collection ) );
 		}
 		if ( !isFunction( done ) ) {
-			throw new TypeError( 'invalid argument. Last argument must be a function. Value: `'+done+'`.' );
+			throw new TypeError( format( 'invalid argument. Last argument must be a function. Value: `%s`.', done ) );
 		}
 		return limit( collection, opts, f, clbk );
 

package/lib/index.js

@@ -59,15 +59,15 @@
 // MODULES //
 
 var setReadOnly = require( '@stdlib/utils-define-nonenumerable-read-only-property' );
-var groupByAsync = require( './group_by.js' );
+var main = require( './main.js' );
 var factory = require( './factory.js' );
 
 
 // MAIN //
 
-setReadOnly( groupByAsync, 'factory', factory );
+setReadOnly( main, 'factory', factory );
 
 
 // EXPORTS //
 
-module.exports = groupByAsync;
+module.exports = main;

package/lib/limit.js

@@ -39,7 +39,6 @@ var debug = logger( 'group-by-async:limit' );
 * -   We need to cache the collection value to prevent the edge case where, during the invocation of the indicator function, the element at index `i` is swapped for some other value. For some, that might be a feature; here, we take the stance that one should be less clever.
 * -   Checking for an "own" property is necessary to guard against the edge case where an indicator function returns a group identifier which matches a method or property on the `Object` prototype.
 *
-*
 * @private
 * @param {Collection} collection - input collection
 * @param {Options} opts - function options

package/lib/{group_by.js → main.js}

@@ -32,7 +32,6 @@ var factory = require( './factory.js' );
 *
 * -   This function does **not** guarantee that execution is asynchronous. To do so, wrap the `done` callback in a function which either executes at the end of the current stack (e.g., `nextTick`) or during a subsequent turn of the event loop (e.g., `setImmediate`, `setTimeout`).
 *
-*
 * @param {Collection} collection - input collection
 * @param {Options} [options] - function options
 * @param {*} [options.thisArg] - execution context