Refactor types

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
  });
  }