fix: simplify dependency loader

Author: abdulsattar

src/lwc-dev-server/index.ts

@@ -19,7 +19,7 @@ import type { LWCServer, ServerConfig, Workspace } from '@lwc/lwc-dev-server';
 import { Connection, Lifecycle, Logger, SfProject } from '@salesforce/core';
 import { SSLCertificateData } from '@salesforce/lwc-dev-mobile-core';
 import { glob } from 'glob';
-import { DependencyLoader } from '../shared/dependencyLoader.js';
+import { loadLwcDevServer } from '../shared/dependencyLoader.js';
 import { OrgUtils } from '../shared/orgUtils.js';
 import { VersionChannel } from '../shared/versionResolver.js';
 import {
@@ -34,7 +34,7 @@ async function createLWCServerConfig(
   clientType: string,
   serverPorts?: { httpPort: number; httpsPort: number },
   certData?: SSLCertificateData,
-  workspace?: Workspace
+  workspace?: Workspace,
 ): Promise<ServerConfig> {
   const project = await SfProject.resolve();
   const packageDirs = project.getPackageDirectories();
@@ -85,12 +85,12 @@ export async function startLWCServer(
   serverPorts?: { httpPort: number; httpsPort: number },
   certData?: SSLCertificateData,
   workspace?: Workspace,
-  versionChannelOverride?: VersionChannel
+  versionChannelOverride?: VersionChannel,
 ): Promise<LWCServer> {
   const channel = OrgUtils.getVersionChannel(connection, versionChannelOverride);
   logger.trace(`Using version channel: ${channel}`);
 
-  const lwcDevServerModule = await DependencyLoader.loadLwcDevServer(channel);
+  const lwcDevServerModule = await loadLwcDevServer(channel);
 
   const config = await createLWCServerConfig(rootDir, token, clientType, serverPorts, certData, workspace);
 

src/shared/dependencyLoader.ts

@@ -27,85 +27,62 @@ export type LwcDevServerModule = {
 };
 
 /**
- * Dynamically loads LWC dependencies based on version channel
+ * Loads the LWC dev server module for the specified channel
+ * Uses dynamic import to load the aliased package at runtime
+ *
+ * @param channel - The version channel ('latest', 'prerelease', or 'next')
+ * @returns The loaded module
  */
-export class DependencyLoader {
-  private static loadedModules: Map<VersionChannel, LwcDevServerModule> = new Map();
-
-  /**
-   * Loads the LWC dev server module for the specified channel
-   * Uses dynamic import to load the aliased package at runtime
-   *
-   * @param channel - The version channel ('latest' or 'prerelease')
-   * @returns The loaded module
-   */
-  public static async loadLwcDevServer(channel: VersionChannel): Promise<LwcDevServerModule> {
-    // Check cache first
-    if (this.loadedModules.has(channel)) {
-      return this.loadedModules.get(channel)!;
-    }
+export async function loadLwcDevServer(channel: VersionChannel): Promise<LwcDevServerModule> {
+  const packageName = `@lwc/lwc-dev-server-${channel}`;
 
-    // Construct the aliased package name
-    const packageName = `@lwc/lwc-dev-server-${channel}`;
-
-    try {
-      // Dynamic import of the aliased package
-      const module = (await import(packageName)) as LwcDevServerModule;
-      this.loadedModules.set(channel, module);
-      return module;
-    } catch (error) {
-      throw new Error(
-        `Failed to load LWC dev server for channel '${channel}'. ` +
-          `Package '${packageName}' could not be imported. ` +
-          `Error: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
+  try {
+    return (await import(packageName)) as LwcDevServerModule;
+  } catch (error) {
+    throw new Error(
+      `Failed to load LWC dev server for channel '${channel}'. ` +
+        `Package '${packageName}' could not be imported. ` +
+        `Error: ${error instanceof Error ? error.message : String(error)}`,
+    );
   }
+}
 
-  /**
-   * Loads the LWC compiler module for the specified channel
-   *
-   * @param channel - The version channel ('latest' or 'prerelease')
-   * @returns The loaded compiler module
-   */
-  public static async loadLwcCompiler(channel: VersionChannel): Promise<unknown> {
-    const packageName = `@lwc/sfdc-lwc-compiler-${channel}`;
+/**
+ * Loads the LWC compiler module for the specified channel
+ *
+ * @param channel - The version channel ('latest', 'prerelease', or 'next')
+ * @returns The loaded compiler module
+ */
+export async function loadLwcCompiler(channel: VersionChannel): Promise<unknown> {
+  const packageName = `@lwc/sfdc-lwc-compiler-${channel}`;
 
-    try {
-      return (await import(packageName)) as unknown;
-    } catch (error) {
-      throw new Error(
-        `Failed to load LWC compiler for channel '${channel}'. ` +
-          `Package '${packageName}' could not be imported. ` +
-          `Error: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
+  try {
+    return (await import(packageName)) as unknown;
+  } catch (error) {
+    throw new Error(
+      `Failed to load LWC compiler for channel '${channel}'. ` +
+        `Package '${packageName}' could not be imported. ` +
+        `Error: ${error instanceof Error ? error.message : String(error)}`,
+    );
   }
+}
 
-  /**
-   * Loads the base LWC module for the specified channel
-   *
-   * @param channel - The version channel ('latest' or 'prerelease')
-   * @returns The loaded LWC module
-   */
-  public static async loadLwc(channel: VersionChannel): Promise<unknown> {
-    const packageName = `lwc-${channel}`;
-
-    try {
-      return (await import(packageName)) as unknown;
-    } catch (error) {
-      throw new Error(
-        `Failed to load LWC for channel '${channel}'. ` +
-          `Package '${packageName}' could not be imported. ` +
-          `Error: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-  }
+/**
+ * Loads the base LWC module for the specified channel
+ *
+ * @param channel - The version channel ('latest', 'prerelease', or 'next')
+ * @returns The loaded LWC module
+ */
+export async function loadLwc(channel: VersionChannel): Promise<unknown> {
+  const packageName = `lwc-${channel}`;
 
-  /**
-   * Clears the module cache (useful for testing)
-   */
-  public static clearCache(): void {
-    this.loadedModules.clear();
+  try {
+    return (await import(packageName)) as unknown;
+  } catch (error) {
+    throw new Error(
+      `Failed to load LWC for channel '${channel}'. ` +
+        `Package '${packageName}' could not be imported. ` +
+        `Error: ${error instanceof Error ? error.message : String(error)}`,
+    );
   }
 }

test/shared/dependencyLoader.test.ts

@@ -15,26 +15,21 @@
  */
 
 import { expect } from 'chai';
-import { DependencyLoader } from '../../src/shared/dependencyLoader.js';
+import { loadLwcDevServer, loadLwcCompiler, loadLwc } from '../../src/shared/dependencyLoader.js';
 
 describe('DependencyLoader', () => {
-  beforeEach(() => {
-    DependencyLoader.clearCache();
-  });
-
   it('exists and has expected methods', () => {
-    expect(typeof DependencyLoader.loadLwcDevServer).to.equal('function');
-    expect(typeof DependencyLoader.loadLwcCompiler).to.equal('function');
-    expect(typeof DependencyLoader.loadLwc).to.equal('function');
-    expect(typeof DependencyLoader.clearCache).to.equal('function');
+    expect(typeof loadLwcDevServer).to.equal('function');
+    expect(typeof loadLwcCompiler).to.equal('function');
+    expect(typeof loadLwc).to.equal('function');
   });
 
   it('loads the aliased package (real import call)', async () => {
     // This will actually try to call import() which should work since we ran yarn install.
     // However, loading LWC modules in Node might still trigger ReferenceErrors if browser globals are missing.
     // We use a try-catch to handle both cases and just verify the attempt was made.
     try {
-      const module = await DependencyLoader.loadLwcDevServer('latest');
+      const module = await loadLwcDevServer('latest');
       expect(module).to.exist;
     } catch (error) {
       // If it fails with a ReferenceError or similar, it's still "working" in terms of