use ts4.0, partial realize

Author: ganmin

.eslintrc.js

@@ -0,0 +1,40 @@
+module.exports = {
+  parser: '@typescript-eslint/parser',
+  parserOptions: {
+    ecmaVersion: 2020,
+    sourceType: 'module',
+  },
+  env: {
+    jest: true,
+    browser: true,
+  },
+  extends: [
+    'plugin:@typescript-eslint/recommended',
+    'prettier/@typescript-eslint',
+    'plugin:prettier/recommended',
+  ],
+  rules: {
+    '@typescript-eslint/no-unused-vars': [
+      'error',
+      { argsIgnorePattern: '^_', varsIgnorePattern: '^_' },
+    ],
+    'no-console': 'warn',
+  },
+  overrides: [
+    {
+      files: [
+        'jest.config.js',
+        'webpack.config.js',
+        '.prettierrc.js',
+        '.eslintrc.js',
+      ],
+      env: {
+        node: true,
+      },
+      extends: ['plugin:prettier/recommended'],
+      rules: {
+        '@typescript-eslint/no-var-requires': 'off',
+      },
+    },
+  ],
+};

.gitignore

@@ -1,9 +1,10 @@
 # node modules
-node_modules
+node_modules/
 # vscode
 .vscode/*
-# build 
-/src/local
+
+# build files
+/local
 .DS_Store*
-yarn.lock
 package-lock.json
+/coverage

.npmignore

@@ -1,14 +1,27 @@
 # dir
 /src/
+/local/
 /__tests__/
 /dist/
 /node_modules/
+/coverage
+
 # files
-tslint.json
-yarn.lock
+browser.ts
+
+# system temp file
 .DS_Store
+
+# vscode config
 .vscode
-.travis.yml
+
+# package
+yarn.lock
 package-lock.json
+
+# config files
+.travis.yml
 webpack.config.js
-jest.config.json
+jest.config.js
+.prettierrc.js
+.eslintrc.js

.prettierrc.js

@@ -0,0 +1,6 @@
+module.exports = {
+  semi: true,
+  trailingComma: "all",
+  singleQuote: true,
+  tabWidth: 2
+};

.travis.yml

@@ -1,9 +1,10 @@
 language: node_js
-node_js: 
-  - '7'
-  - '8'
-  - '9'
-sudo: false
+install:
+  - yarn
+os:
+  - "linux"
+node_js:
+  - "12"
 script:
   - "npm test"
 after_script:

coverage/.gitkeep

@@ -1,16 +1,21 @@
 const { defaults: tsjPreset } = require('ts-jest/presets');
 module.exports = {
   testEnvironment: 'node',
-  transform: Object.assign({},tsjPreset.transform),
+  transform: Object.assign({}, tsjPreset.transform),
   verbose: true,
-  testRegex: "(/__tests__/.*|(\\.|/)(test|spec))\\.(jsx?|tsx?)$",
-  testPathIgnorePatterns: ['<rootDir>/lib/','<rootDir>/dist/','<rootDir>/node_modules/','<rootDir>/src/'],
-  coverageDirectory: '<rootDir>/',
-  moduleFileExtensions: [
-    "ts",
-    "js",
+  testRegex: '(/__tests__/.*|(\\.|/)(test|spec))\\.(jsx?|tsx?)$',
+  testPathIgnorePatterns: [
+    '<rootDir>/lib/',
+    '<rootDir>/dist/',
+    '<rootDir>/node_modules/',
+    '<rootDir>/local/',
   ],
-  moduleNameMapper:{
-    '^@/(.*)': '<rootDir>/src/$1'
-  }
-};
+  coverageDirectory: '<rootDir>/coverage',
+  collectCoverage: true,
+  collectCoverageFrom: ['src/**/*.{ts,js}', '!<rootDir>/node_modules/'],
+  moduleFileExtensions: ['ts', 'js'],
+  moduleNameMapper: {
+    '^@/(.*)': '<rootDir>/src/$1',
+  },
+  rootDir: '.',
+};

jest.config.js

@@ -1,11 +1,18 @@
 import { Mocker } from '../such';
-import { NormalObject, ParamsPathItem } from '../types';
+import { TObject, ParamsPathItem } from '../types';
 export declare const encodeRegexpChars: (chars: string) => string;
 export declare const typeOf: (target: any) => string;
 export declare const isFn: (target: any) => boolean;
-export declare const map: (target: string | any[] | NormalObject, fn: (item: any, index: string | number) => void) => NormalObject;
+export declare const map: (
+  target: string | any[] | TObject,
+  fn: (item: any, index: string | number) => void,
+) => TObject;
 export declare const makeRandom: (min: number, max: number) => number;
-export declare const makeStrRangeList: (first?: string, last?: string, ...args: string[]) => string[];
+export declare const makeStrRangeList: (
+  first?: string,
+  last?: string,
+  ...args: string[]
+) => string[];
 export declare const isOptional: () => boolean;
 export declare const capitalize: (target: string) => string;
 export declare const decodeTrans: (target: string) => string;
@@ -15,7 +22,13 @@ export declare const range: (start: number, end: number, step?: number) => any;
 export declare const deepCopy: (target: any, ...args: any[]) => any;
 export declare const isNoEmptyObject: (target: any) => boolean;
 export declare const isPromise: (target: any) => boolean;
-export declare const shiftObject: (obj: NormalObject, keys: string[]) => NormalObject;
+export declare const shiftObject: (obj: TObject, keys: string[]) => TObject;
 export declare const withPromise: (res: any[]) => any[];
-export declare const isRelativePath: (first: (string | number)[], second: (string | number)[]) => boolean;
-export declare const getRefMocker: (item: ParamsPathItem, mocker: Mocker) => Mocker;
+export declare const isRelativePath: (
+  first: (string | number)[],
+  second: (string | number)[],
+) => boolean;
+export declare const getRefMocker: (
+  item: ParamsPathItem,
+  mocker: Mocker,
+) => Mocker;

lib/helpers/utils.d.ts

@@ -1,32 +1,32 @@
-import { MockitConfig, NormalObject, SuchOptions } from '../types';
+import { MockitConfig, TObject, SuchOptions } from '../types';
 export declare type Result<T> = T | never;
 export declare type ModifierFn<T> = (res: T) => T | string | never;
-export declare type RuleFn = (cur: NormalObject) => void | NormalObject;
+export declare type RuleFn = (cur: TObject) => void | TObject;
 export default abstract class Mockit<T> {
-    protected readonly constructorName: string;
-    protected configOptions: MockitConfig;
-    protected params: NormalObject;
-    protected origParams: NormalObject;
-    protected generateFn: undefined | ((options: SuchOptions) => Result<T>);
-    protected isValidOk: boolean;
-    protected hasValid: boolean;
-    protected invalidKeys: string[];
-    constructor(constructorName: string);
-    abstract init(): void;
-    addModifier(name: string, fn: ModifierFn<T>, pos?: string): void;
-    addRule(name: string, fn: RuleFn, pos?: string): void;
-    setParams(params: NormalObject, value: undefined): NormalObject | never;
-    setParams(key: string, value: NormalObject): NormalObject | never;
-    frozen(): this;
-    reGenerate(fn?: (options: SuchOptions) => Result<T>): void;
-    make(options: SuchOptions): Result<T>;
-    abstract generate(options: SuchOptions): Result<T>;
-    abstract test(target: T): boolean;
-    private add;
-    private validParams;
-    private validate;
-    private resetValidInfo;
-    private runModifiers;
-    private runFuncs;
-    private runAll;
+  protected readonly constructorName: string;
+  protected configOptions: MockitConfig;
+  protected params: TObject;
+  protected origParams: TObject;
+  protected generateFn: undefined | ((options: SuchOptions) => Result<T>);
+  protected isValidOk: boolean;
+  protected hasValid: boolean;
+  protected invalidKeys: string[];
+  constructor(constructorName: string);
+  abstract init(): void;
+  addModifier(name: string, fn: ModifierFn<T>, pos?: string): void;
+  addRule(name: string, fn: RuleFn, pos?: string): void;
+  setParams(params: TObject, value: undefined): TObject | never;
+  setParams(key: string, value: TObject): TObject | never;
+  frozen(): this;
+  reGenerate(fn?: (options: SuchOptions) => Result<T>): void;
+  make(options: SuchOptions): Result<T>;
+  abstract generate(options: SuchOptions): Result<T>;
+  abstract test(target: T): boolean;
+  private add;
+  private validParams;
+  private validate;
+  private resetValidInfo;
+  private runModifiers;
+  private runFuncs;
+  private runAll;
 }

lib/mockit/namespace.d.ts

@@ -1,9 +1,19 @@
-import { NormalObject } from 'reregexp';
+import { TObject } from 'reregexp';
 import { ParamsPathItem } from '../types';
-export declare const loadDict: (filePath: string | string[], useCache?: boolean) => Promise<string[] | string[][]>;
+export declare const loadDict: (
+  filePath: string | string[],
+  useCache?: boolean,
+) => Promise<string[] | string[][]>;
 export declare const getAllFiles: (directory: string) => Promise<string[]>;
-export declare const loadJson: (filePath: string | string[]) => Promise<string[] | string[][]>;
-export declare const loadAllData: (allFiles: string[]) => Promise<[string[] | string[][], string[] | string[][]]>;
+export declare const loadJson: (
+  filePath: string | string[],
+) => Promise<string[] | string[][]>;
+export declare const loadAllData: (
+  allFiles: string[],
+) => Promise<[string[] | string[][], string[] | string[][]]>;
 export declare const loadTemplate: (file: string) => Promise<{}>;
 export declare const getRealPath: (item: ParamsPathItem) => string;
-export declare const getCascaderValue: (data: NormalObject, values: any[]) => any;
+export declare const getCascaderValue: (
+  data: TObject<unknown>,
+  values: any[],
+) => any;

lib/node/utils.d.ts

@@ -1,46 +1,51 @@
-import { NormalObject, ParserConfig } from '../types';
+import { TObject, ParserConfig } from '../types';
 export interface Tags {
-    start: string;
-    end: string;
+  start: string;
+  end: string;
 }
 export interface ParserConstructor extends ParserConfig {
-    readonly splitor?: string;
-    new (): ParserInterface;
+  readonly splitor?: string;
+  new (): ParserInterface;
 }
 export declare abstract class ParserInterface {
-    protected params: string[];
-    protected patterns: any[][];
-    protected tags: Tags;
-    protected code: string;
-    protected setting: NormalObject;
-    protected defaults: NormalObject;
-    constructor();
-    init(): this;
-    info(): {
-        tags: Tags;
-        params: string[];
-        code: string;
-        patterns: any[][];
-    };
-    parseCode(code: string, tags: Tags): void;
-    abstract parse(): object | never;
-    protected halt(err: string): never;
+  protected params: string[];
+  protected patterns: any[][];
+  protected tags: Tags;
+  protected code: string;
+  protected setting: TObject;
+  protected defaults: TObject;
+  constructor();
+  init(): this;
+  info(): {
+    tags: Tags;
+    params: string[];
+    code: string;
+    patterns: any[][];
+  };
+  parseCode(code: string, tags: Tags): void;
+  abstract parse(): object | never;
+  protected halt(err: string): never;
 }
 export interface ParserList {
-    [index: string]: ParserConstructor;
+  [index: string]: ParserConstructor;
 }
 export interface ParserInstances {
-    [index: string]: ParserInterface;
+  [index: string]: ParserInterface;
 }
 export declare class Dispatcher {
-    protected parsers: ParserList;
-    protected tagPairs: string[];
-    protected pairHash: NormalObject;
-    protected readonly splitor: string;
-    protected instances: ParserInstances;
-    addParser(name: string, config: ParserConfig, parse: () => void, setting?: NormalObject): never | void;
-    parse(code: string): NormalObject | never;
-    protected getInstance(name: string): ParserInterface;
-    protected parseUntilFind(context: string): NormalObject;
-    protected halt(err: string): never;
+  protected parsers: ParserList;
+  protected tagPairs: string[];
+  protected pairHash: TObject;
+  protected readonly splitor: string;
+  protected instances: ParserInstances;
+  addParser(
+    name: string,
+    config: ParserConfig,
+    parse: () => void,
+    setting?: TObject,
+  ): never | void;
+  parse(code: string): TObject | never;
+  protected getInstance(name: string): ParserInterface;
+  protected parseUntilFind(context: string): TObject;
+  protected halt(err: string): never;
 }

lib/parser/namespace.d.ts

@@ -1,13 +1,13 @@
-import { NormalObject } from './types';
+import { TObject } from './types';
 export interface Store {
-    (name: string, value: any, alwaysVar: boolean): void;
-    vars: NormalObject;
-    fns: NormalObject;
-    mockits: NormalObject;
-    alias: NormalObject;
-    aliasTypes: string[];
-    fileCache: NormalObject;
-    config: NormalObject;
+  (name: string, value: any, alwaysVar: boolean): void;
+  vars: TObject;
+  fns: TObject;
+  mockits: TObject;
+  alias: TObject;
+  aliasTypes: string[];
+  fileCache: TObject;
+  config: TObject;
 }
 declare const store: Store;
 export default store;