refactor: add type checking functions for plugin options

- Add checkOptions function to validate plugin options
- Add checkFileContentSpecifier function to validate FileContentSpecifier
- Add checkFileContentSetterReturnValue function to validate return value of FileContentSetter
- Integrate type checking in plugin initialization and utils

Author: lingbopro

src/plugin.ts

@@ -3,6 +3,7 @@ import type { Optionals } from './utils';
 import type { FileContentSpecifier } from './file-content';
 import { filterFile, getFileContent } from './utils';
 import { createFilter } from '@rollup/pluginutils';
+import { checkOptions } from './type-check';
 
 /** The plugin options */
 export interface Options {
@@ -43,6 +44,7 @@ export function customImport(opts: Options): Plugin {
     defaultOptions,
     opts
   ) as Required<Options>;
+  checkOptions(options);
 
   const filter = createFilter(
     // make sure that the include and exclude options are arrays

src/type-check.ts

@@ -0,0 +1,34 @@
+import { FileContentSetter, FileContentSpecifier } from './file-content';
+import { Options } from './plugin';
+
+export function checkOptions(target: Options, varName: string = 'Options') {
+  if (typeof target.include !== 'function' && !Array.isArray(target.include)) {
+    throw new TypeError(`${varName}.include must be a function or an array`);
+  }
+  if (typeof target.exclude === 'function' && !Array.isArray(target.exclude)) {
+    throw new TypeError(`${varName}.exclude must be a function or an array`);
+  }
+  checkFileContentSpecifier(target.content, `${varName}.content`);
+}
+
+export function checkFileContentSpecifier(
+  target: FileContentSpecifier,
+  varName: string = 'FileContentSpecifier'
+) {
+  if (typeof target !== 'string' && typeof target !== 'function') {
+    throw new TypeError(`${varName} must be an string or a function`);
+  }
+}
+
+export function checkFileContentSetterReturnValue(
+  target: ReturnType<FileContentSetter>,
+  varName: string = 'FileContentSetter'
+) {
+  if (typeof target === 'object' && typeof target.code !== 'string') {
+    throw new TypeError(
+      `SourceDescription returned by ${varName} must have a code property of type string`
+    );
+  } else {
+    throw new TypeError(`${varName} must return a string or an object`);
+  }
+}

src/utils.ts

@@ -2,6 +2,10 @@ import type { CreateFilter } from '@rollup/pluginutils';
 import { SourceDescription } from 'rollup';
 import { FileContentSpecifier } from './file-content';
 import type { Options } from './plugin';
+import {
+  checkFileContentSetterReturnValue,
+  checkFileContentSpecifier,
+} from './type-check';
 
 /**
  * Extracts the keys of optional properties from a type T.
@@ -40,30 +44,23 @@ export function getFileContent<self>(
   id: string,
   originalCode: string
 ): SourceDescription {
+  checkFileContentSpecifier(specifier);
   if (typeof specifier === 'string') {
     return {
       code: specifier,
       map: null,
     };
   } else if (typeof specifier === 'function') {
     const ret = specifier.call(_this, id, originalCode);
+    checkFileContentSetterReturnValue(ret);
     if (typeof ret === 'string') {
       return {
         code: ret,
         map: null,
       };
     } else if (typeof ret === 'object') {
-      if (typeof ret.code !== 'string')
-        throw new TypeError(
-          'The returned SourceDescription of the content function must have a code property'
-        );
       return ret;
-    } else
-      throw new TypeError(
-        'The return value of the content function must be string | SourceDescription'
-      );
-  } else
-    throw new TypeError(
-      'Invalid content specifier. It should be a string or a function'
-    );
+    }
+  }
+  throw new Error('Invalid FileContentSpecifier');
 }