chore: rewrite package on 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.ts

@@ -1,23 +1,37 @@
-const _ = require('lodash');
-const {buildLazyObject, forceParsing} = require('./lazy');
-const {MissingOptionError, UnknownKeysError} = require('./errors');
-const initLocator = require('./locator');
+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
  */
-function 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(config, locator.parent) : config;
+        const currNode = locator.parent ? _.get(parsed, locator.parent) : config;
 
-        let value;
+        let value: unknown;
         if (locator.cliOption !== undefined) {
             value = parseCli(locator.cliOption);
         } else if (locator.envVar !== undefined) {
@@ -31,7 +45,8 @@ function option({
         } else {
             throw new MissingOptionError(locator.name);
         }
-        validate(value, config, currNode);
+
+        validateFunc(value, config, currNode);
 
         return mapFunc(value, config, currNode);
     };
@@ -41,13 +56,15 @@ function option({
  * Object with fixed properties.
  * Any unknown property will be reported as error.
  */
-function section(properties) {
-    const expectedKeys = _.keys(properties);
+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
+            expectedKeys as Array<string>
         );
+
         if (unknownKeys.length > 0) {
             throw new UnknownKeysError(
                 unknownKeys.map((key) => `${locator.name}.${key}`)
@@ -56,7 +73,8 @@ function section(properties) {
 
         const lazyResult = buildLazyObject(expectedKeys, (key) => {
             const parser = properties[key];
-            return () => parser(locator.nested(key), config);
+
+            return () => parser(locator.nested(key) as Locator<DeepPartial<T[keyof T]>>, config);
         });
 
         _.set(config, locator.name, lazyResult);
@@ -69,32 +87,33 @@ function section(properties) {
  * Object with user-specified keys and values,
  * parsed by valueParser.
  */
-function map(valueParser, defaultValue) {
+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 {};
+                return {} as LazyObject<T>;
             }
             locator = locator.resetOption(defaultValue);
         }
 
-        const optionsToParse = Object.keys(locator.option);
-        const lazyResult = buildLazyObject(optionsToParse, (key) => {
-            return () => valueParser(locator.nested(key), config);
+        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;
     };
 }
 
-function root(rootParser, {envPrefix, cliPrefix}) {
+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, parsed);
-        return forceParsing(parsed.root);
+        const parsed = rootParser(rootLocator, {} as RootParsedConfig<T>);
+
+        return forceParsing(parsed);
     };
 }
-
-module.exports = {option, section, map, root};

lib/errors.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/index.ts

@@ -1,7 +1,2 @@
-const {root, section, map, option} = require('./core');
-const {MissingOptionError, UnknownKeysError} = require('./errors');
-
-module.exports = {
-    root, section, map, option,
-    MissingOptionError, UnknownKeysError
-};
+export { root, section, map, option } from './core';
+export { MissingOptionError, UnknownKeysError } from './errors';

lib/lazy.ts

@@ -1,38 +1,52 @@
-const _ = require('lodash');
+import _ from 'lodash';
 
-const isLazy = Symbol('isLazy');
+import type { LazyObject } from './types/lazy';
 
-function buildLazyObject(keys, getKeyGetter) {
+export const isLazy = Symbol('isLazy');
+
+export function buildLazyObject<T>(keys: Array<keyof T>, getKeyGetter: (key: keyof T) => () => (T[keyof T] | LazyObject<T[keyof T]>)): LazyObject<T> {
     const target = {
         [isLazy]: true
-    };
+    } as LazyObject<T>;
+
     for (const key of keys) {
         defineLazy(target, key, getKeyGetter(key));
     }
+
     return target;
 }
 
-function forceParsing(lazyObject) {
+export function forceParsing<T>(lazyObject: LazyObject<T>): T {
     return _.cloneDeep(lazyObject);
 }
 
-function defineLazy(object, key, getter) {
+function defineLazy<T>(object: LazyObject<T>, key: keyof T, getter: () => T[keyof T] | LazyObject<T[keyof T]>): void {
     let defined = false;
-    let value;
+    let value: T[keyof T];
 
     Object.defineProperty(object, key, {
-        get() {
+        get(): T[keyof T] {
             if (!defined) {
                 defined = true;
-                value = getter();
-                if (_.isObject(value) && value[isLazy]) {
-                    value = forceParsing(value);
+                const val = getter();
+
+                if (isLazyObject(val)) {
+                    value = forceParsing(val);
+                } else {
+                    value = val;
                 }
             }
+
             return value;
         },
         enumerable: true
     });
 }
 
-module.exports = {forceParsing, buildLazyObject};
+function isLazyObject<T>(value: T): value is LazyObject<T> {
+    return _.isObject(value) && hasOwnProperty(value, isLazy) && value[isLazy] === true;
+}
+
+function hasOwnProperty<T extends {}>(obj: T, prop: PropertyKey): obj is T & Record<typeof prop, unknown> {
+    return obj.hasOwnProperty(prop);
+}

lib/locator.ts

@@ -1,6 +1,8 @@
-const _ = require('lodash');
+import _ from 'lodash';
 
-function parseArgv(argv, cliPrefix) {
+import type { LocatorArg, Locator, Node, Prefixes } from './types/locator';
+
+function parseArgv(argv: Array<string>, cliPrefix: string): Array<string> {
     return argv.reduce(function(argv, arg) {
         if (!arg.startsWith(cliPrefix) || !_.includes(arg, '=')) {
             return argv.concat(arg);
@@ -11,20 +13,20 @@ function parseArgv(argv, cliPrefix) {
         const value = parts.slice(1).join('=');
 
         return argv.concat(option, value);
-    }, []);
+    }, [] as Array<string>);
 }
 
-module.exports = function({options, env, argv, envPrefix = '', cliPrefix = '--'}) {
+export default function<T>({options, env, argv, envPrefix = '', cliPrefix = '--'}: LocatorArg<T>): Locator<T> {
     const parsedArgv = parseArgv(argv, cliPrefix);
 
-    function getNested(option, {namePrefix, envPrefix, cliPrefix}) {
+    function getNested<T extends {}>(option: T | undefined, {namePrefix, envPrefix, cliPrefix}: Prefixes): (key: keyof T) => Locator<T[keyof T]> {
         return (subKey) => {
-            const envName = envPrefix + _.snakeCase(subKey);
-            const cliFlag = cliPrefix + _.kebabCase(subKey);
+            const envName = envPrefix + _.snakeCase(subKey.toString());
+            const cliFlag = cliPrefix + _.kebabCase(subKey.toString());
 
             const argIndex = parsedArgv.lastIndexOf(cliFlag);
             const subOption = _.get(option, subKey);
-            const newName = namePrefix ? `${namePrefix}.${subKey}` : subKey;
+            const newName = namePrefix ? `${namePrefix}.${subKey}` : subKey.toString();
 
             return mkLocator(
                 {
@@ -43,14 +45,11 @@ module.exports = function({options, env, argv, envPrefix = '', cliPrefix = '--'}
         };
     }
 
-    function mkLocator(base, prefixes) {
+    function mkLocator<T>(base: Node<T>, prefixes: Prefixes): Locator<T> {
         return _.extend(base, {
             nested: getNested(base.option, prefixes),
-            resetOption: function(newOptions) {
-                return _.extend({}, base, {
-                    option: newOptions,
-                    nested: getNested(newOptions, prefixes)
-                });
+            resetOption: function<T>(newOptions: T): Locator<T> {
+                return mkLocator({ ...base, option: newOptions }, prefixes);
             }
         });
     }
@@ -64,7 +63,7 @@ module.exports = function({options, env, argv, envPrefix = '', cliPrefix = '--'}
             cliOption: undefined
         },
         {
-            namePrefix: '',
+            namePrefix: 'root',
             envPrefix,
             cliPrefix
         }

lib/types/common.ts

@@ -0,0 +1,10 @@
+import type { LazyObject } from './lazy';
+import type { MapParser } from './map';
+import type { OptionParser } from './option';
+import type { SectionParser } from './section';
+
+export type ParsedConfig<T> = {[K in keyof T]: LazyObject<T[K]>};
+
+export type RootParsedConfig<T> = ParsedConfig<{root: LazyObject<T>}>;
+
+export type Parser<T, R = any> = OptionParser<T, R> | SectionParser<T, R> | MapParser<T, R>;