Refactor types (hexojs#5178)

* refactor: add types for some explicit any fields

* refactor: add better extend types

* refactor: add type Hexo for ctx

* reafactor: better function type

* style: use import type for type only imports

* fix: wrong type for args and options

lib/box/index.ts

@@ -182,7 +182,7 @@ class Box extends EventEmitter {
     }).thenReturn(path);
   }
 
-  watch(callback) {
+  watch(callback?) {
     if (this.isWatching()) {
       return BlueBirdPromise.reject(new Error('Watcher has already started.')).asCallback(callback);
     }

lib/extend/console.ts

@@ -1,17 +1,40 @@
 import Promise from 'bluebird';
 import abbrev from 'abbrev';
 
-/**
- * Console plugin option
- * @typedef {Object} Option
- * @property {String} usage - The usage of a console command
- * @property {{name: String, desc: String}[]} arguments - The description of each argument of a console command
- * @property {{name: String, desc: String}[]} options - The description of each option of a console command
- */
+type Option = Partial<{
+  usage: string;
+  desc: string;
+  init: boolean;
+  arguments: {
+      name: string;
+      desc: string;
+    }[];
+  options: {
+    name: string;
+    desc: string;
+  }[];
+}>
+
+interface Args {
+  _: string[];
+  [key: string]: string | boolean | string[];
+}
+type AnyFn = (args: Args) => any;
+interface StoreFunction extends AnyFn {
+  desc?: string;
+  options?: Option;
+}
+
+interface Store {
+  [key: string]: StoreFunction
+}
+interface Alias {
+  [key: string]: string
+}
 
 class Console {
-  public store: any;
-  public alias: any;
+  public store: Store;
+  public alias: Alias;
 
   constructor() {
     this.store = {};
@@ -21,9 +44,9 @@ class Console {
   /**
    * Get a console plugin function by name
    * @param {String} name - The name of the console plugin
-   * @returns {Function} - The console plugin function
+   * @returns {StoreFunction} - The console plugin function
    */
-  get(name) {
+  get(name: string): StoreFunction {
     name = name.toLowerCase();
     return this.store[this.alias[name]];
   }
@@ -37,9 +60,13 @@ class Console {
    * @param {String} name - The name of console plugin to be registered
    * @param {String} desc - More detailed information about a console command
    * @param {Option} options - The description of each option of a console command
-   * @param {Function} fn - The console plugin to be registered
+   * @param {AnyFn} fn - The console plugin to be registered
    */
-  register(name, desc, options, fn) {
+  register(name: string, fn: AnyFn): void
+  register(name: string, desc: string, fn: AnyFn): void
+  register(name: string, options: Option, fn: AnyFn): void
+  register(name: string, desc: string, options: Option, fn: AnyFn): void
+  register(name: string, desc: string | Option | AnyFn, options?: Option | AnyFn, fn?: AnyFn) {
     if (!name) throw new TypeError('name is required');
 
     if (!fn) {
@@ -74,10 +101,10 @@ class Console {
       fn = Promise.method(fn);
     }
 
-    const c = fn;
+    const c = fn as StoreFunction;
     this.store[name.toLowerCase()] = c;
-    c.options = options;
-    c.desc = desc;
+    c.options = options as Option;
+    c.desc = desc as string;
 
     this.alias = abbrev(Object.keys(this.store));
   }

lib/extend/deployer.ts

@@ -1,7 +1,17 @@
 import Promise from 'bluebird';
 
+interface StoreFunction {
+  (deployArg: {
+    type: string;
+    [key: string]: any
+  }) : any;
+}
+interface Store {
+  [key: string]: StoreFunction
+}
+
 class Deployer {
-  public store: any;
+  public store: Store;
 
   constructor() {
     this.store = {};
@@ -15,7 +25,7 @@ class Deployer {
     return this.store[name];
   }
 
-  register(name: string, fn) {
+  register(name: string, fn: StoreFunction) {
     if (!name) throw new TypeError('name is required');
     if (typeof fn !== 'function') throw new TypeError('fn must be a function');
 

lib/extend/filter.ts

@@ -8,11 +8,11 @@ const typeAlias = {
 
 interface FilterOptions {
   context?: any;
-  args?: any;
+  args?: any[];
 }
 
 interface StoreFunction {
-  (...args: any[]): any;
+  (data?: any, ...args: any[]): any;
   priority?: number;
 }
 
@@ -34,8 +34,11 @@ class Filter {
     return this.store[type] || [];
   }
 
-  register(fn: StoreFunction, priority: number);
-  register(type?: string | StoreFunction, fn?: StoreFunction | number, priority?: number) {
+  register(fn: StoreFunction): void
+  register(fn: StoreFunction, priority: number): void
+  register(type: string, fn: StoreFunction): void
+  register(type: string, fn: StoreFunction, priority: number): void
+  register(type: string | StoreFunction, fn?: StoreFunction | number, priority?: number) {
     if (!priority) {
       if (typeof type === 'function') {
         priority = fn as number;
@@ -72,7 +75,7 @@ class Filter {
     if (index !== -1) list.splice(index, 1);
   }
 
-  exec(type: string, data, options: FilterOptions = {}) {
+  exec(type: string, data: any[], options: FilterOptions = {}) {
     const filters = this.list(type);
     if (filters.length === 0) return Promise.resolve(data);
 
@@ -87,7 +90,7 @@ class Filter {
     })).then(() => args[0]);
   }
 
-  execSync(type: string, data, options: FilterOptions = {}) {
+  execSync(type: string, data: any[], options: FilterOptions = {}) {
     const filters = this.list(type);
     const filtersLen = filters.length;
     if (filtersLen === 0) return data;

lib/extend/generator.ts

@@ -1,8 +1,30 @@
 import Promise from 'bluebird';
 
+interface BaseObj {
+  path: string;
+  data: any;
+  layout?: string;
+}
+type ReturnType = BaseObj | BaseObj[];
+type GeneratorReturnType = ReturnType | Promise<ReturnType>;
+
+interface GeneratorFunction {
+  (locals: object): GeneratorReturnType;
+}
+
+type StoreFunctionReturn = Promise<ReturnType>;
+
+interface StoreFunction {
+  (locals: object): StoreFunctionReturn;
+}
+
+interface Store {
+  [key: string]: StoreFunction
+}
+
 class Generator {
-  public id: any;
-  public store: any;
+  public id: number;
+  public store: Store;
 
   constructor() {
     this.id = 0;
@@ -17,9 +39,11 @@ class Generator {
     return this.store[name];
   }
 
-  register(name, fn) {
+  register(fn: GeneratorFunction): void
+  register(name: string, fn: GeneratorFunction): void
+  register(name: string | GeneratorFunction, fn?: GeneratorFunction) {
     if (!fn) {
-      if (typeof name === 'function') {
+      if (typeof name === 'function') { // fn
         fn = name;
         name = `generator-${this.id++}`;
       } else {
@@ -28,7 +52,7 @@ class Generator {
     }
 
     if (fn.length > 1) fn = Promise.promisify(fn);
-    this.store[name] = Promise.method(fn);
+    this.store[name as string] = Promise.method(fn);
   }
 }
 

lib/extend/helper.ts

@@ -1,32 +1,41 @@
+interface StoreFunction {
+  (...args: any[]): string;
+}
+
+interface Store {
+  [key: string]: StoreFunction
+}
+
+
 class Helper {
-  public store: any;
+  public store: Store;
 
   constructor() {
     this.store = {};
   }
 
   /**
-   * @returns {Object} - The plugin store
+   * @returns {Store} - The plugin store
    */
-  list() {
+  list(): Store {
     return this.store;
   }
 
   /**
    * Get helper plugin function by name
    * @param {String} name - The name of the helper plugin
-   * @returns {Function}
+   * @returns {StoreFunction}
    */
-  get(name: string) {
+  get(name: string): StoreFunction {
     return this.store[name];
   }
 
   /**
    * Register a helper plugin
    * @param {String} name - The name of the helper plugin
-   * @param {Function} fn - The helper plugin function
+   * @param {StoreFunction} fn - The helper plugin function
    */
-  register(name: string, fn) {
+  register(name: string, fn: StoreFunction) {
     if (!name) throw new TypeError('name is required');
     if (typeof fn !== 'function') throw new TypeError('fn must be a function');
 

lib/extend/injector.ts

@@ -1,7 +1,15 @@
 import { Cache } from 'hexo-util';
 
+type Entry = 'head_begin' | 'head_end' | 'body_begin' | 'body_end';
+
+type Store = {
+  [key in Entry]: {
+    [key: string]: Set<unknown>;
+  };
+};
+
 class Injector {
-  public store: any;
+  public store: Store;
   public cache: any;
   public page: any;
 
@@ -20,21 +28,21 @@ class Injector {
     return this.store;
   }
 
-  get(entry, to = 'default') {
+  get(entry: Entry, to = 'default') {
     return Array.from(this.store[entry][to] || []);
   }
 
-  getText(entry, to = 'default') {
+  getText(entry: Entry, to = 'default') {
     const arr = this.get(entry, to);
     if (!arr || !arr.length) return '';
     return arr.join('');
   }
 
-  getSize(entry) {
+  getSize(entry: Entry) {
     return this.cache.apply(`${entry}-size`, Object.keys(this.store[entry]).length);
   }
 
-  register(entry, value, to = 'default') {
+  register(entry: Entry, value: string | (() => string), to = 'default') {
     if (!entry) throw new TypeError('entry is required');
     if (typeof value === 'function') value = value();
 

lib/extend/migrator.ts

@@ -1,7 +1,14 @@
 import Promise from 'bluebird';
+interface StoreFunction {
+  (args: any): any
+}
+
+interface Store {
+  [key: string]: StoreFunction
+}
 
 class Migrator {
-  public store: any;
+  public store: Store;
 
   constructor() {
     this.store = {};
@@ -15,7 +22,7 @@ class Migrator {
     return this.store[name];
   }
 
-  register(name: string, fn) {
+  register(name: string, fn: StoreFunction) {
     if (!name) throw new TypeError('name is required');
     if (typeof fn !== 'function') throw new TypeError('fn must be a function');
 

lib/extend/processor.ts

@@ -1,8 +1,19 @@
 import Promise from 'bluebird';
 import { Pattern } from 'hexo-util';
+import type File from '../box/file';
 
+interface StoreFunction {
+  (file: File): any
+}
+
+type Store = {
+    pattern: Pattern;
+    process: StoreFunction
+  }[];
+
+type patternType = Exclude<ConstructorParameters<typeof Pattern>[0], ((str: string) => string)>;
 class Processor {
-  public store: any;
+  public store: Store;
 
   constructor() {
     this.store = [];
@@ -12,7 +23,9 @@ class Processor {
     return this.store;
   }
 
-  register(pattern, fn) {
+  register(fn: StoreFunction): void;
+  register(pattern: patternType, fn: StoreFunction): void;
+  register(pattern: patternType | StoreFunction, fn?: StoreFunction) {
     if (!fn) {
       if (typeof pattern === 'function') {
         fn = pattern;
@@ -29,7 +42,7 @@ class Processor {
     }
 
     this.store.push({
-      pattern: new Pattern(pattern),
+      pattern: new Pattern(pattern as patternType),
       process: fn
     });
   }