chore: rewrite package to typescript

Author: oldskytree

.eslintignore

@@ -0,0 +1 @@
+build

.gitignore

@@ -1 +1,2 @@
 node_modules
+build

.travis.yml

@@ -3,4 +3,5 @@ node_js:
 - '6'
 - '8'
 script:
+- npm build
 - npm test

README.md

@@ -8,6 +8,7 @@ Config is described with a combination of a functions:
 var parser = root(section({
     system: section({
         parallelLimit: option({
+            defaultValue: 0,
             parseEnv: Number,
             parseCli: Number,
             validate: function() {...}

lib/core.js

@@ -0,0 +1,119 @@
+import _ from 'lodash';
+
+import { MissingOptionError, UnknownKeysError } from './errors';
+import { buildLazyObject, forceParsing } from './lazy';
+import initLocator from './locator';
+
+import type { LazyObject } from './types/lazy';
+import type { RootParsedConfig } from './types/common';
+import type { MapParser } from './types/map';
+import type { OptionParser, OptionParserConfig } from './types/option';
+import type { RootParser, RootPrefixes, ConfigParser } from './types/root';
+import type { SectionParser, SectionProperties } from './types/section';
+import type { DeepPartial } from './types/utils';
+import type { Locator } from './types/locator';
+
+type Parser<T, R = any> = OptionParser<T, R> | SectionParser<T, R> | MapParser<T, R>;
+
+/**
+ * Single option
+ */
+export function option<T, S = T, R = any>({
+    defaultValue,
+    parseCli = _.identity,
+    parseEnv = _.identity,
+    validate = _.noop,
+    map: mapFunc = _.identity
+}: OptionParserConfig<T, S, R>): OptionParser<S, R> {
+    const validateFunc: typeof validate = validate;
+
+    return (locator, parsed) => {
+        const config = parsed.root;
+        const currNode = locator.parent ? _.get(parsed, locator.parent) : config;
+
+        let value: unknown;
+        if (locator.cliOption !== undefined) {
+            value = parseCli(locator.cliOption);
+        } else if (locator.envVar !== undefined) {
+            value = parseEnv(locator.envVar);
+        } else if (locator.option !== undefined) {
+            value = locator.option;
+        } else if (defaultValue !== undefined) {
+            value = _.isFunction(defaultValue)
+                ? defaultValue(config, currNode)
+                : defaultValue;
+        } else {
+            throw new MissingOptionError(locator.name);
+        }
+
+        validateFunc(value, config, currNode);
+
+        return mapFunc(value, config, currNode);
+    };
+}
+
+/**
+ * Object with fixed properties.
+ * Any unknown property will be reported as error.
+ */
+export function section<T, R = any>(properties: SectionProperties<T, R>): SectionParser<T, R> {
+    const expectedKeys = _.keys(properties) as Array<keyof T>;
+
+    return (locator, config) => {
+        const unknownKeys = _.difference(
+            _.keys(locator.option),
+            expectedKeys as Array<string>
+        );
+
+        if (unknownKeys.length > 0) {
+            throw new UnknownKeysError(
+                unknownKeys.map((key) => `${locator.name}.${key}`)
+            );
+        }
+
+        const lazyResult = buildLazyObject(expectedKeys, (key) => {
+            const parser = properties[key];
+
+            return () => parser(locator.nested(key) as Locator<DeepPartial<T[keyof T]>>, config);
+        });
+
+        _.set(config, locator.name, lazyResult);
+
+        return lazyResult;
+    };
+}
+
+/**
+ * Object with user-specified keys and values,
+ * parsed by valueParser.
+ */
+export function map<T extends Record<string, any>, V extends T[string] = T[string], R = any>(
+    valueParser: Parser<V, R>,
+    defaultValue: DeepPartial<Record<string, V>>
+): MapParser<Record<string, V>, R> {
+    return (locator, config) => {
+        if (locator.option === undefined) {
+            if (!defaultValue) {
+                return {} as LazyObject<T>;
+            }
+            locator = locator.resetOption(defaultValue);
+        }
+
+        const optionsToParse = Object.keys(locator.option as Record<string, V>);
+        const lazyResult = buildLazyObject<Record<string, V>>(optionsToParse, (key) => {
+            return () => valueParser(locator.nested(key) as Locator<DeepPartial<T[keyof T]>>, config);
+        });
+        _.set(config, locator.name, lazyResult);
+
+        return lazyResult;
+    };
+}
+
+export function root<T>(rootParser: RootParser<T>, {envPrefix, cliPrefix}: RootPrefixes): ConfigParser<T> {
+    return ({options, env, argv}) => {
+        const rootLocator = initLocator({options, env, argv, envPrefix, cliPrefix});
+        const parsed = rootParser(rootLocator, {} as RootParsedConfig<T>);
+
+        return forceParsing(parsed);
+    };
+}

lib/core.ts

@@ -1,5 +1,7 @@
-class MissingOptionError extends Error {
-    constructor(optionName) {
+export class MissingOptionError extends Error {
+    public optionName: string;
+
+    constructor(optionName: string) {
         const message = `${optionName} is required`;
         super(message);
         this.name = 'MissingOptionError';
@@ -10,8 +12,10 @@ class MissingOptionError extends Error {
     }
 }
 
-class UnknownKeysError extends Error {
-    constructor(keys) {
+export class UnknownKeysError extends Error {
+    public keys: Array<string>;
+
+    constructor(keys: Array<string>) {
         const message = `Unknown options: ${keys.join(', ')}`;
         super(message);
         this.name = 'UnknownKeysError';
@@ -21,5 +25,3 @@ class UnknownKeysError extends Error {
         Error.captureStackTrace(this, UnknownKeysError);
     }
 }
-
-module.exports = {MissingOptionError, UnknownKeysError};

lib/errors.js renamed to lib/errors.ts

@@ -0,0 +1,2 @@
+export { root, section, map, option } from './core';
+export { MissingOptionError, UnknownKeysError } from './errors';