more type annotations and cleanups

Author: ef4

src/index.ts

@@ -1,35 +1,34 @@
 import path from 'path';
 import Macros from './utils/macros';
-import { normalizeOptions } from './utils/normalize-options';
+import { UserOptions, NormalizedOptions, normalizeOptions } from './utils/normalize-options';
+import * as Babel from '@babel/core';
+import type { types as t } from '@babel/core';
 
-export default function macros(babel) {
+interface State {
+  opts: NormalizedOptions;
+  macroBuilder: Macros;
+}
+
+export default function macros(babel: typeof Babel): Babel.PluginObj<State> {
   let t = babel.types;
 
-  function buildIdentifier(value, name) {
+  function buildIdentifier(value: boolean, name: string) {
     let replacement = t.booleanLiteral(value);
-
-    // when we only support babel@7 we should change this
-    // to `path.addComment` or `t.addComment`
-    let comment = {
-      type: 'CommentBlock',
-      value: ` ${name} `,
-      leading: false,
-      trailing: true,
-    };
-    replacement.trailingComments = [comment];
-
+    t.addComment(replacement, 'trailing', ` ${name} `);
     return replacement;
   }
 
   return {
     name: 'babel-feature-flags-and-debug-macros',
     visitor: {
       ImportSpecifier(path, state) {
-        let importPath = path.parent.source.value;
+        let importPath = (path.parent as t.ImportDeclaration).source.value;
         let flagsForImport = state.opts.flags[importPath];
 
         if (flagsForImport) {
-          let flagName = path.node.imported.name;
+          let flagName = t.isIdentifier(path.node.imported)
+            ? path.node.imported.name
+            : path.node.imported.value;
           let localBindingName = path.node.local.name;
 
           if (!(flagName in flagsForImport)) {
@@ -43,7 +42,7 @@ export default function macros(babel) {
             return;
           }
 
-          let binding = path.scope.getBinding(localBindingName);
+          let binding = path.scope.getBinding(localBindingName)!;
 
           binding.referencePaths.forEach((p) => {
             p.replaceWith(buildIdentifier(flagValue, flagName));
@@ -68,7 +67,9 @@ export default function macros(babel) {
 
       Program: {
         enter(path, state) {
-          state.opts = normalizeOptions(state.opts);
+          // most of our plugin declares state.opts as already being normalized.
+          // This is the spot where we force it become so.
+          state.opts = normalizeOptions(state.opts as unknown as UserOptions);
           this.macroBuilder = new Macros(babel, state.opts);
 
           let body = path.get('body');
@@ -105,5 +106,3 @@ export default function macros(babel) {
 macros.baseDir = function () {
   return path.resolve(__dirname, '..', '..');
 };
-
-

src/utils/macros.ts

@@ -1,10 +1,11 @@
 import Builder from './builder';
+import type * as Babel from '@babel/core';
+import type { NormalizedOptions } from './normalize-options';
 
 const SUPPORTED_MACROS = ['assert', 'deprecate', 'warn', 'log'];
 
 export default class Macros {
-  constructor(babel, options) {
-    this.babel = babel;
+  constructor(babel: typeof Babel, options: NormalizedOptions) {
     this.localDebugBindings = [];
 
     this.debugHelpers = options.externalizeHelpers || {};

src/utils/normalize-options.ts

@@ -1,6 +1,10 @@
 import { gt } from 'semver';
 
-function parseDebugTools(options: any): NormalizedOptions["debugTools"] {
+function parseDebugTools(options: UserOptions): {
+  isDebug: boolean;
+  debugToolsImport: string;
+  assertPredicateIndex: number | undefined;
+} {
   let debugTools = options.debugTools || {
     isDebug: false,
     source: '',
@@ -11,21 +15,22 @@ function parseDebugTools(options: any): NormalizedOptions["debugTools"] {
   let debugToolsImport = debugTools.source;
   let assertPredicateIndex = debugTools.assertPredicateIndex;
 
-  if (options.envFlags && isDebug === undefined) {
-    isDebug = options.envFlags.flags.DEBUG;
-  }
-
   return {
     isDebug,
     debugToolsImport,
     assertPredicateIndex,
   };
 }
 
-function evaluateFlagValue(options, name, flagName, flagValue) {
+function evaluateFlagValue(
+  options: UserOptions,
+  name: string | undefined,
+  flagName: string,
+  flagValue: string | boolean | null
+): boolean | null {
   let svelte = options.svelte;
 
-  if (typeof flagValue === 'string') {
+  if (typeof flagValue === 'string' && name) {
     if (svelte && svelte[name]) {
       return gt(flagValue, svelte[name]);
     } else {
@@ -38,10 +43,10 @@ function evaluateFlagValue(options, name, flagName, flagValue) {
   }
 }
 
-function parseFlags(options) {
+function parseFlags(options: UserOptions): Record<string, Record<string, boolean | null>> {
   let flagsProvided = options.flags || [];
 
-  let combinedFlags = {};
+  let combinedFlags: Record<string, Record<string, boolean | null>> = {};
   flagsProvided.forEach((flagsDefinition) => {
     let source = flagsDefinition.source;
     let flagsForSource = (combinedFlags[source] = combinedFlags[source] || {});
@@ -62,27 +67,38 @@ function parseFlags(options) {
 }
 
 export interface NormalizedOptions {
-  externalizeHelpers: unknown;
-  flags: unknown;
+  externalizeHelpers: {
+    module?: boolean;
+    global?: string;
+  };
+  flags: Record<string, Record<string, boolean | null>>;
   svelte: unknown;
-  debugTools: unknown;
+  debugTools: {
+    isDebug: boolean;
+    debugToolsImport: string;
+    assertPredicateIndex: number | undefined;
+  };
 }
 
-export function normalizeOptions(options: any): NormalizedOptions {
-  let features = options.features || [];
-  let externalizeHelpers = options.externalizeHelpers;
-  let svelte = options.svelte;
-
-  if (!Array.isArray(features)) {
-    features = [features];
-  }
+export interface UserOptions {
+  externalizeHelpers?: {
+    module?: boolean;
+    global?: string;
+  };
+  svelte?: Record<string, string>;
+  flags?: { source: string; name?: string; flags: Record<string, boolean | string | null> }[];
+  debugTools?: {
+    isDebug: boolean;
+    source: string;
+    assertPredicateIndex?: number;
+  };
+}
 
+export function normalizeOptions(options: UserOptions): NormalizedOptions {
   return {
-    externalizeHelpers,
+    externalizeHelpers: options.externalizeHelpers ?? {},
     flags: parseFlags(options),
-    svelte,
+    svelte: options.svelte,
     debugTools: parseDebugTools(options),
   };
 }
-
-