Class Loader

packages/hydrooj/src/loader.ts:48–164

}

export class Loader extends Service {
    public state: Record<string, Fiber> = Object.create(null);
    public suspend = false;
    public cache: Record<string, string> = Object.create(null);
    private schemaCache = new WeakMap<Schema<any>, Record<string, Schema<any>>>();
    // public warnings: Record<string, string> = Object.create(null);

    static inject = ['setting', 'timer', 'i18n', 'logger'];

    constructor(ctx: Context) {
        super(ctx, 'loader');

        ctx.on('app/started', () => {
            ctx.interval(async () => {
                const pending = Object.entries(this.state).filter((v) => v[1].state === FiberState.PENDING);
                if (pending.length) {
                    logger.warn('Plugins are still pending: %s', pending.map((v) => v[0]).join(', '));
                    for (const [key, value] of pending) {
                        logger.warn('Plugin %s is still pending', key);
                        console.log(value);
                    }
                }
                const loading = Object.entries(this.state).filter((v) => v[1].state === FiberState.LOADING);
                if (loading.length) {
                    logger.warn('Plugins are still loading: %s', loading.map((v) => v[0]).join(', '));
                    for (const [key, value] of loading) {
                        logger.warn('Plugin %s is still loading', key);
                        console.log(value);
                    }
                }
                const failed = Object.entries(this.state).filter((v) => v[1].state === FiberState.FAILED);
                if (failed.length) {
                    logger.warn('Plugins failed to load: %s', failed.map((v) => v[0]).join(', '));
                    for (const [key, value] of failed) {
                        logger.warn('Plugin %s failed to load', key);
                        console.log(value);
                    }
                }
            }, 10000);
        });
    }

    unloadPlugin(key: string) {
        const fork = this.state[key];
        if (fork) {
            fork.dispose();
            delete this.state[key];
            logger.info('unload plugin %c', key);
        }
    }

    buildSchema(schema: Schema<any>, scope?: string) {
        if (!scope) return schema;
        const cache = this.schemaCache.get(schema) || {};
        cache[scope] ||= Schema.object({ [scope]: schema });
        this.schemaCache.set(schema, cache);
        return cache[scope];
    }