Module: utils/options

This module provides functions to validate and resolve user input options.

This module also provide the default options used by the application, they are defined in the defaults namespace. Please note, all properties within the namespace are read-only properties.

Since:
  • 2.0.0
Author:
License:
  • MIT
Source:

Requires

Namespaces

defaults

Methods

(package, inner) resolve(inOpts, expectedOpts) → {Record.<string, any>}

Resolves and validates input options against expected types and default values.

This function ensures that only recognized options with the correct types are retained. If an option is missing or has an incorrect type, it is replaced with a default value (if specified).

How It Works

  • Filters Out Unknown Options: Only options defined in expectedOpts are included.
  • Validates Option Types: Each option's type is checked against the expected type.
  • Supports Multiple Expected Types:
    • If an option accepts multiple types (e.g., 'string' or 'number'), the function iterates through them and assigns the first valid type.
  • Handles Special Cases:
    • 'array' is explicitly checked using Array.isArray().
    • 'function' ensures that the value is callable but not an ES6 class.
    • If an expected type is a class, it checks if the value is an instance of that class.
  • Fallback to Default Values: If an option is missing or invalid, the default value is used.
Parameters:
Name Type Description
inOpts Record.<string, any>

The input options to be resolved.
expectedOpts Record.<string, Array.<(string|function()|Array.<(string|function()|any)>|any)>>

An object defining expected types and default values. With the key being the option name and the value being an array defining the expected type(s) and default value.
Since:
  • 2.0.0
Source:
Returns:

An object containing only the valid and resolved options.

Type
Record.<string, any>
Examples

Basic usage with primitive types 

const options = resolveOptions(
  { cacheSize: '10', verbose: true },
  { cacheSize: ['number', 5], verbose: ['boolean', false] }
);
console.log(options);  // { cacheSize: 5, verbose: true }

Handling multiple expected types 

const options = resolveOptions(
  { cacheSize: '10', mode: 'fast' },
  { cacheSize: [['number', 'string'], 5], mode: ['string', 'default'] }
);
console.log(options);  // { cacheSize: '10', mode: 'fast' }

Handling class instances 

class CacheHandler {}
const options = resolveOptions(
  { handler: new CacheHandler() },
  { handler: [CacheHandler, null] }
);
console.log(options);  // { handler: CacheHandler {} }

Handling invalid values 

const options = resolveOptions(
  { cacheSize: 'not a number' },
  { cacheSize: ['number', 10] }
);
console.log(options); // { cacheSize: 10 } // Falls back to default