Class ExtensionService

src/services/extensionService.ts:114–272

@singleton()
export class ExtensionService implements IExtensionService {
    private extensions: IExtension[] = [];
    private readonly colorThemeService: IColorThemeService;
    private readonly monacoService: IMonacoService;
    private _inactive: Function | undefined;
    private readonly localeService: ILocaleService;
    /**
     * TODO: This property is used for marking the extensions were loaded
     * we are going to refactor this logic after redesign the Molecule lifecycle.
     */
    private _isLoaded: boolean = false;

    constructor() {
        this.colorThemeService = container.resolve(ColorThemeService);
        this.monacoService = container.resolve(MonacoService);
        this.localeService = container.resolve(LocaleService);
    }

    public setLoaded(flag?: boolean): void {
        this._isLoaded = flag !== undefined ? flag : true;
    }

    public isLoaded(): boolean {
        return this._isLoaded;
    }

    public getExtension(id: UniqueId): IExtension | undefined {
        return this.extensions.find(searchById(id));
    }

    public reset(): void {
        this.extensions = [];
    }

    public getAllExtensions(): IExtension[] {
        return this.extensions.concat();
    }

    public add(extensions: IExtension[]): IExtension[] | null {
        if (!extensions || extensions?.length === 0) return null;
        /**
         * Filtered the exist Extensions
         */
        const unloadExtensions = extensions.filter((ext) => {
            const isExist = this.extensions.find(searchById(ext.id));
            if (isExist) {
                logger.warn(
                    'Warning: Unable to load the existed Extension:' + ext.id
                );
            }
            return !isExist;
        });
        if (unloadExtensions.length > 0) {
            this.extensions = this.extensions.concat(unloadExtensions);
        }
        return unloadExtensions;
    }