Class FPLNodeModuleFactory

src/back/extensions/NodeInterceptor.ts:82–134

/** Module interceptor for the Flashpoint API 'flashpoint-launcher' module */
export class FPLNodeModuleFactory implements INodeModuleFactory {
  public readonly nodeModuleName = 'flashpoint-launcher';

  private readonly _extApiImpl = new Map<string, typeof flashpoint>();
  private _defaultApiImpl?: typeof flashpoint;
  private readonly _apiFactory: IExtensionApiFactory;

  constructor(
    protected readonly _extensionPaths: TernarySearchTree<string, IExtension>,
    private readonly _addExtLogFactory: (extId: string) => (entry: ILogEntry) => void,
    private readonly _version: string,
    private readonly _state: BackState
  ) {
    this._apiFactory = createApiFactory;
  }

  /**
   * Return an API implementation given an import request
   *
   * @param _request Unused
   * @param parent Module that made this request, substring of an extension path
   */
  public load(_request: string, parent: string): any {
    const ext = this._extensionPaths.findSubstr(parent);
    if (ext) {
      // Call was from an extension, use its own implementation
      let apiImpl = this._extApiImpl.get(ext.id);
      if (!apiImpl) {
        // No API for extension yet, make one
        apiImpl = this._apiFactory(
          ext.id,
          ext.manifest,
          this._addExtLogFactory(ext.id),
          this._version,
          this._state,
          ext.extensionPath);
        this._extApiImpl.set(ext.id, apiImpl);
      }
      return apiImpl;
    }

    // Import not from an extension, give default implementation
    if (!this._defaultApiImpl) {
      this._defaultApiImpl = this._apiFactory(
        '',
        nullExtensionDescription,
        this._addExtLogFactory('null'),
        this._version,
        this._state);
    }
    return this._defaultApiImpl;
  }
}