Class PluginInterface

packages/api/core/src/util/plugin-interface.ts:28–211

}

export default class PluginInterface implements IForgePluginInterface {
  private plugins: IForgePlugin[] = [];
  private _pluginPromise: Promise<void> = Promise.resolve();

  private config: ResolvedForgeConfig;

  static async create(
    dir: string,
    forgeConfig: ResolvedForgeConfig,
  ): Promise<PluginInterface> {
    const int = new PluginInterface(dir, forgeConfig);
    await int._pluginPromise;
    return int;
  }

  private constructor(dir: string, forgeConfig: ResolvedForgeConfig) {
    this._pluginPromise = Promise.all(
      forgeConfig.plugins.map(async (plugin): Promise<IForgePlugin> => {
        if (isForgePlugin(plugin)) {
          return plugin;
        }

        if (
          typeof plugin === 'object' &&
          'name' in plugin &&
          'config' in plugin
        ) {
          const { name: pluginName, config: opts } = plugin;
          if (typeof pluginName !== 'string') {
            throw new Error(
              `Expected plugin[0] to be a string but found ${pluginName}`,
            );
          }
          // eslint-disable-next-line @typescript-eslint/no-explicit-any
          const Plugin = await importSearch<any>(dir, [pluginName]);
          if (!Plugin) {
            throw new Error(
              `Could not find module with name: ${pluginName}. Make sure it's listed in the devDependencies of your package.json`,
            );
          }
          return new Plugin(opts);
        }

        throw new Error(
          `Expected plugin to either be a plugin instance or a { name, config } object but found ${JSON.stringify(plugin)}`,
        );
      }),
    ).then((plugins) => {
      this.plugins = plugins;
      for (const plugin of this.plugins) {
        plugin.init(dir, forgeConfig);
      }
      return;
    });
    // TODO: fix hack
    // eslint-disable-next-line @typescript-eslint/no-explicit-any
    this.config = null as any;
    Object.defineProperty(this, 'config', {