Promotes the experimental loader as the defeault module loading mechanism

Author: Daniel Del Core

packages/cli/package.json

@@ -30,7 +30,6 @@
     "fs-extra": "^9.1.0",
     "inquirer": "^8.2.4",
     "jscodeshift": "^0.13.1",
-    "live-plugin-manager": "^0.18.1",
     "lodash": "^4.17.21",
     "ora": "^5.4.1",
     "semver": "^7.3.5",

packages/cli/src/index.ts

@@ -70,10 +70,6 @@ program
     '--registryToken <value>',
     'Define an authentication token to use as credentials for the registry',
   )
-  .option(
-    '--experimental-loader',
-    'Enables the experimental package downloader',
-  )
   .addOption(
     new Option(
       '--verbose <parser>',

packages/cli/src/list.ts

@@ -1,19 +1,14 @@
 import chalk from 'chalk';
-import { PluginManager } from 'live-plugin-manager';
 
 import { fetchPackages } from './utils/fetch-package.js';
 import { getHypermodPackageName } from './utils/package-names.js';
 
 export default async function list(packages: string[]) {
-  const packageManager = new PluginManager();
   const configs = [];
 
   for (const packageName of packages) {
     try {
-      const { community, remote } = await fetchPackages(
-        packageName,
-        packageManager,
-      );
+      const { community, remote } = await fetchPackages(packageName);
       community &&
         configs.push({
           packageName: getHypermodPackageName(packageName),

packages/cli/src/main.ts

@@ -3,9 +3,7 @@ import semver from 'semver';
 import chalk from 'chalk';
 import findUp from 'find-up';
 import inquirer from 'inquirer';
-import fs from 'fs-extra';
-import { PluginManager, PluginManagerOptions } from 'live-plugin-manager';
-import { installPackage } from '@antfu/install-pkg';
+import { PluginManagerOptions } from 'live-plugin-manager';
 
 import * as core from '@hypermod/core';
 import { fetchConfigAtPath } from '@hypermod/fetcher';
@@ -19,57 +17,6 @@ import {
 } from './utils/file-system.js';
 import { getConfigPrompt, getMultiConfigPrompt } from './prompt.js';
 
-const ExperimentalModuleLoader = () => {
-  const getInfo = async (packageName: string) => {
-    // @ts-expect-error Experimental loader
-    const entryPath = import.meta.resolve(packageName);
-    // @ts-expect-error Experimental loader
-    const location = (entryPath.split(packageName)[0] + packageName).replace(
-      'file://',
-      '',
-    );
-    const pkgJsonRaw = fs.readFileSync(
-      path.join(location.replace('file://', ''), 'package.json'),
-      'utf8',
-    );
-    const pkgJson = JSON.parse(pkgJsonRaw);
-
-    return { location, entryPath, pkgJson };
-  };
-
-  const install = async (packageName: string) => {
-    const __dirname = path.dirname(new URL(import.meta.url).pathname);
-    await installPackage(packageName, {
-      cwd: __dirname,
-      packageManager: 'npm',
-      additionalArgs: ['--force'],
-    });
-
-    const { pkgJson } = await getInfo(packageName);
-
-    // Install whitelisted devDependencies
-    if (pkgJson?.hypermod?.dependencies) {
-      await Promise.all(
-        pkgJson.hypermod.dependencies.map((dep: string) => {
-          const version = pkgJson.devDependencies[dep];
-          if (!version) return;
-          return installPackage(`${dep}@${version}`, {
-            cwd: __dirname,
-            packageManager: 'npm',
-            additionalArgs: ['--force'],
-          });
-        }),
-      );
-    }
-  };
-
-  return {
-    install,
-    getInfo,
-    require: async (packageName: string) => import(packageName),
-  };
-};
-
 export default async function main(
   paths: string[],
   flags: Partial<core.Flags>,
@@ -100,10 +47,6 @@ export default async function main(
     };
   }
 
-  const packageManager = flags.experimentalLoader
-    ? ExperimentalModuleLoader()
-    : new PluginManager(pluginManagerConfig);
-
   let transforms: string[] = [];
 
   if (!flags.transform && !flags.packages) {
@@ -254,11 +197,7 @@ export default async function main(
         .filter(id => id.startsWith('#'))
         .map(id => id.substring(1));
 
-      const { community, remote } = await fetchPackages(
-        pkgName,
-        // @ts-expect-error Experimental loader
-        packageManager,
-      );
+      const { community, remote } = await fetchPackages(pkgName);
 
       const config = mergeConfigs(community, remote);
 

packages/cli/src/utils/fetch-package.ts

@@ -1,6 +1,5 @@
 import ora from 'ora';
 import chalk from 'chalk';
-import { PluginManager } from 'live-plugin-manager';
 
 import {
   fetchPackage,
@@ -11,10 +10,7 @@ import { isValidConfig } from '@hypermod/validator';
 
 import { getHypermodPackageName } from './package-names.js';
 
-export async function fetchPackages(
-  packageName: string,
-  packageManager: PluginManager,
-) {
+export async function fetchPackages(packageName: string) {
   const hypermodPackageName = getHypermodPackageName(packageName);
   let hypermodPackage: ConfigMeta | undefined;
   let remotePackage: ConfigMeta | undefined;
@@ -24,7 +20,7 @@ export async function fetchPackages(
   ).start();
 
   try {
-    hypermodPackage = await fetchPackage(hypermodPackageName, packageManager);
+    hypermodPackage = await fetchPackage(hypermodPackageName);
     spinner.succeed(
       `${chalk.green('Found Hypermod package:')} ${hypermodPackageName}`,
     );
@@ -46,7 +42,7 @@ export async function fetchPackages(
     spinner.info(
       `${chalk.green(`Attempting to download npm package:`)} ${packageName}`,
     );
-    remotePackage = await fetchRemotePackage(packageName, packageManager);
+    remotePackage = await fetchRemotePackage(packageName);
     spinner.succeed(
       `${chalk.green('Found remote Hypermod package:')} ${packageName}`,
     );

packages/fetcher/src/index.ts

@@ -2,16 +2,19 @@
 import fs from 'fs';
 import path from 'path';
 import globby from 'globby';
-import { PluginManager } from 'live-plugin-manager';
 
 import { Config } from '@hypermod/types';
-import { register } from 'tsx/esm/api';
+
+import ModuleLoader from './module-loader.js';
 
 /**
  * Register the TSX plugin to allow require TS(X) files.
  */
+import { register } from 'tsx/esm/api';
 register();
 
+const moduleLoader = ModuleLoader();
+
 export interface ConfigMeta {
   filePath: string;
   config: Config;
@@ -80,13 +83,10 @@ export async function fetchConfigAtPath(filePath: string): Promise<Config> {
   return requireConfig(filePath, resolvedFilePath);
 }
 
-export async function fetchPackage(
-  packageName: string,
-  packageManager: PluginManager,
-): Promise<ConfigMeta> {
-  await packageManager.install(packageName);
-  const pkg = await packageManager.require(packageName);
-  const info = await packageManager.getInfo(packageName);
+export async function fetchPackage(packageName: string): Promise<ConfigMeta> {
+  await moduleLoader.install(packageName);
+  const pkg = await moduleLoader.require(packageName);
+  const info = await moduleLoader.getInfo(packageName);
 
   if (!info) {
     throw new Error(`Unable to find package info for: ${packageName}`);
@@ -100,14 +100,13 @@ export async function fetchPackage(
 
 export async function fetchRemotePackage(
   packageName: string,
-  packageManager: PluginManager,
 ): Promise<ConfigMeta | undefined> {
   if (['javascript', 'typescript'].includes(packageName)) {
     throw new Error(`'${packageName}' is ignored as a remote package.`);
   }
 
-  await packageManager.install(packageName);
-  const info = await packageManager.getInfo(packageName);
+  await moduleLoader.install(packageName);
+  const info = await moduleLoader.getInfo(packageName);
 
   if (!info) {
     throw new Error(
@@ -117,7 +116,7 @@ export async function fetchRemotePackage(
 
   // Search main entrypoint for transform/presets from the default import
   try {
-    const pkg = await packageManager.require(packageName);
+    const pkg = await moduleLoader.require(packageName);
     const configExport = resolveConfigExport(pkg);
 
     if (configExport.transforms || configExport.presets) {

packages/fetcher/src/module-loader.ts

@@ -0,0 +1,55 @@
+import path from 'path';
+import fs from 'fs-extra';
+import { installPackage } from '@antfu/install-pkg';
+
+const ModuleLoader = () => {
+  const getInfo = async (packageName: string) => {
+    // @ts-expect-error Experimental loader
+    const entryPath = await import.meta.resolve(packageName);
+    const location = (entryPath.split(packageName)[0] + packageName).replace(
+      'file://',
+      '',
+    );
+    const pkgJsonRaw = fs.readFileSync(
+      path.join(location.replace('file://', ''), 'package.json'),
+      'utf8',
+    );
+    const pkgJson = JSON.parse(pkgJsonRaw);
+
+    return { location, entryPath, pkgJson };
+  };
+
+  const install = async (packageName: string) => {
+    const __dirname = path.dirname(new URL(import.meta.url).pathname);
+    await installPackage(packageName, {
+      cwd: __dirname,
+      packageManager: 'npm',
+      additionalArgs: ['--force'],
+    });
+
+    const { pkgJson } = await getInfo(packageName);
+
+    // Install whitelisted devDependencies
+    if (pkgJson?.hypermod?.dependencies) {
+      await Promise.all(
+        pkgJson.hypermod.dependencies.map((dep: string) => {
+          const version = pkgJson.devDependencies[dep];
+          if (!version) return;
+          return installPackage(`${dep}@${version}`, {
+            cwd: __dirname,
+            packageManager: 'npm',
+            additionalArgs: ['--force'],
+          });
+        }),
+      );
+    }
+  };
+
+  return {
+    install,
+    getInfo,
+    require: async (packageName: string) => import(packageName),
+  };
+};
+
+export default ModuleLoader;