Support string types in dynamic import types.

No se nombran archivos del repositorio, pruebas ni puntos de entrada. Empieza reproduciendo en un proyecto TypeScript los ejemplos literales de importación dinámica y del wrapper con parámetro de tipo string; después, rastrea el comportamiento existente de comprobación de tipos para cada uno. La tarea estará terminada cuando el tipo de importación basado en strings solicitado esté especificado y cubierto por pruebas, incluidos tanto el caso de ruta válida de logger como los casos de ruta de módulo no válida.

Search Terms

dynamic import type

Suggestion

I'd like to define a function that wraps a dynamic require or import. Specifically, I'm writing a library that uses node's worker_thread and I want to support 'dependency injection' via dynamic import. You can't pass class instances or functions across execution contexts.

import { isMainThread, Worker, workerData } from 'worker_threads';

export type LoggerImportPath = ???;

export default function lib(logger: LoggerImportPath): Worker {
  return new Worker(__filename, { workerData: { logger });
}

if (!isMainThread) {
  const module: { default: Logger } = await import(workerData.logger);
}

// no type error, ./path/to/logger exports a Logger.
lib(`${__filename}/path/to/logger');

// this should be a type error: import('not-a-module') is not assignable to { default: Logger };
lib('not-a-module');

I don't think you can currently define LoggerImportPath any more precisely than string and import(path: string) returns Promise<any>.

// this returns `{ default: Logger}`
await import('path');

// this returns `any`
const wrapper = path => import(path);
const module: any = await wrapper('path')

Use Cases

I haven't seen this pattern in any other libraries, but I think it's a good way to pass classes or functions across threads or execution contexts. You can't currently limit the kinds of strings that library uses can pass when a module path is expected.

Examples

Checklist

My suggestion meets these guidelines:

• This wouldn't be a breaking change in existing TypeScript/JavaScript code
• This wouldn't change the runtime behavior of existing JavaScript code
• This could be implemented without emitting different JS based on the types of the expressions
• This isn't a runtime feature (e.g. library functionality, non-ECMAScript syntax with JavaScript output, etc.)
• This feature would agree with the rest of TypeScript's Design Goals.