@stemy/backend 3.5.16 → 4.0.0

package/esm2020/socket-controllers/progress.controller.mjs

@@ -0,0 +1,52 @@
+import { __decorate, __param } from "tslib";
+import { inject, singleton } from "tsyringe";
+import { ConnectedSocket, MessageBody, OnMessage, SocketController, } from "socket-controllers";
+import { SOCKET_SERVER } from "../common-types";
+import { broadcast } from "../utils";
+let ProgressController = class ProgressController {
+    constructor(progresses, socketServer) {
+        this.progresses = progresses;
+        this.socketServer = socketServer;
+    }
+    async advanceProgress(client, progressId) {
+        const progress = await this.progresses.get(progressId);
+        if (!progress)
+            return;
+        const json = progress.toJSON();
+        broadcast(this.socketServer, c => {
+            if (c.interestedProgresses instanceof Set && c.interestedProgresses.has(progressId)) {
+                client.emit("background-progress-changed", json);
+            }
+        });
+        console.log(`progress changed: ${client.id}, data: ${JSON.stringify(json)}`);
+    }
+    async setProgressInterest(client, progressId) {
+        const progress = await this.progresses.get(progressId);
+        if (!progress)
+            return;
+        const json = progress.toJSON();
+        client.interestedProgresses = client.interestedProgresses || new Set();
+        if (client.interestedProgresses.has(progressId))
+            return;
+        client.interestedProgresses.add(progressId);
+        client.emit("background-progress-changed", json);
+        console.log(`progress interest added: ${client.id}, data: ${JSON.stringify(json)}`);
+    }
+};
+__decorate([
+    OnMessage("background-progress"),
+    __param(0, ConnectedSocket()),
+    __param(1, MessageBody())
+], ProgressController.prototype, "advanceProgress", null);
+__decorate([
+    OnMessage("background-progress-interest"),
+    __param(0, ConnectedSocket()),
+    __param(1, MessageBody())
+], ProgressController.prototype, "setProgressInterest", null);
+ProgressController = __decorate([
+    singleton(),
+    SocketController(),
+    __param(1, inject(SOCKET_SERVER))
+], ProgressController);
+export { ProgressController };
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/socket-controllers/terminal.controller.mjs

@@ -0,0 +1,48 @@
+import { __decorate, __param } from "tslib";
+import { singleton } from "tsyringe";
+import { ConnectedSocket, MessageBody, OnMessage, SocketController } from "socket-controllers";
+import { Terminal } from "./terminal";
+let TerminalController = class TerminalController {
+    constructor(manager) {
+        this.manager = manager;
+        this.terminals = {};
+    }
+    async terminalInit(client) {
+        const terminal = new Terminal(client);
+        this.manager.loadAddons(terminal);
+        this.terminals[client.id] = terminal;
+        client.on("disconnect", () => terminal.dispose());
+    }
+    async terminalData(client, data) {
+        const terminal = this.terminals[client.id];
+        if (!terminal)
+            return;
+        terminal.input(data);
+    }
+    async terminalUpload(client, upload) {
+        const terminal = this.terminals[client.id];
+        if (!terminal || !upload)
+            return;
+        terminal.addFile(upload);
+    }
+};
+__decorate([
+    OnMessage("terminal-init"),
+    __param(0, ConnectedSocket())
+], TerminalController.prototype, "terminalInit", null);
+__decorate([
+    OnMessage("terminal-data"),
+    __param(0, ConnectedSocket()),
+    __param(1, MessageBody())
+], TerminalController.prototype, "terminalData", null);
+__decorate([
+    OnMessage("terminal-upload"),
+    __param(0, ConnectedSocket()),
+    __param(1, MessageBody())
+], TerminalController.prototype, "terminalUpload", null);
+TerminalController = __decorate([
+    singleton(),
+    SocketController()
+], TerminalController);
+export { TerminalController };
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/socket-controllers/terminal.mjs

@@ -0,0 +1,85 @@
+import { BehaviorSubject, Subject } from "rxjs";
+import { first, map, timeout } from "rxjs/operators";
+import { fileTypeFromBuffer } from "../utils";
+export class Terminal {
+    constructor(client) {
+        this.client = client;
+        this.addons = [];
+        this.files$ = new BehaviorSubject([]);
+        this.input$ = new Subject();
+    }
+    onData(cb) {
+        const sub = this.input$.pipe(map(v => {
+            if (v === "\b") {
+                return "\x7f";
+            }
+            return v;
+        })).subscribe(cb);
+        return {
+            dispose: () => sub.unsubscribe()
+        };
+    }
+    write(data) {
+        this.client.emit("terminal-data", data);
+    }
+    writeln(data) {
+        this.write(data + "\n");
+    }
+    loadAddon(addon) {
+        addon.activate(this);
+        this.addons.push(addon);
+    }
+    dispose() {
+        this.input$.complete();
+        this.client = null;
+        this.addons.forEach(a => a.dispose());
+    }
+    async suggestFiles(accept) {
+        const rand = Math.round(Math.random() * 1000);
+        const id = `${Date.now()}-${rand}`;
+        const files = this.files$.value;
+        return files.filter(f => f.accept === accept).concat([
+            {
+                id,
+                label: "...",
+                onAccept: async () => {
+                    this.client.emit("terminal-upload", {
+                        id,
+                        accept
+                    });
+                    const file = await this.files$
+                        .pipe(first(v => v.some(f => f.id === id)))
+                        .pipe(timeout(120000))
+                        .pipe(map(v => v.find(f => f.id === id)))
+                        .toPromise();
+                    if (file.error) {
+                        this.files$.next(this.files$.value.filter(f => f.id !== id));
+                        throw new Error(file.error);
+                    }
+                    return file;
+                },
+                showAlways: true,
+                accept: accept,
+            }
+        ]);
+    }
+    async downloadFile(filename, buffer) {
+        const type = await fileTypeFromBuffer(buffer);
+        const data = buffer.toString("base64");
+        const content = `data:${type.mime};base64,${data}`;
+        this.client.emit("terminal-download", {
+            filename,
+            content
+        });
+    }
+    addFile(upload) {
+        if (upload.content) {
+            upload.buffer = Buffer.from(upload.content, "base64");
+        }
+        this.files$.next(this.files$.value.concat(upload));
+    }
+    input(data) {
+        this.input$.next(data);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"terminal.js","sourceRoot":"","sources":["../../../src/socket-controllers/terminal.ts"],"names":[],"mappings":"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","sourcesContent":["import {BehaviorSubject, Subject} from \"rxjs\";\r\nimport {first, map, timeout} from \"rxjs/operators\";\r\nimport {IDisposable, ISuggestion, ITerminalAddon} from \"@stemy/terminal-commands-addon\";\r\nimport {IClientSocket, ITerminal, ITerminalFile} from \"../common-types\";\r\nimport {fileTypeFromBuffer} from \"../utils\";\r\n\r\nexport class Terminal implements ITerminal {\r\n    protected addons: ITerminalAddon[];\r\n    protected files$: BehaviorSubject<ITerminalFile[]>;\r\n    protected input$: Subject<string>;\r\n\r\n    constructor(protected client: IClientSocket) {\r\n        this.addons = [];\r\n        this.files$ = new BehaviorSubject([]);\r\n        this.input$ = new Subject();\r\n    }\r\n\r\n    onData(cb: (data: string) => any): IDisposable {\r\n        const sub = this.input$.pipe(map(v => {\r\n            if (v === \"\\b\") {\r\n                return \"\\x7f\";\r\n            }\r\n            return v;\r\n        })).subscribe(cb);\r\n        return {\r\n            dispose: () => sub.unsubscribe()\r\n        };\r\n    }\r\n\r\n    write(data: string): void {\r\n        this.client.emit(\"terminal-data\", data);\r\n    }\r\n\r\n    writeln(data: string): void {\r\n        this.write(data + \"\\n\");\r\n    }\r\n\r\n    loadAddon(addon: ITerminalAddon) {\r\n        addon.activate(this);\r\n        this.addons.push(addon);\r\n    }\r\n\r\n    dispose() {\r\n        this.input$.complete();\r\n        this.client = null;\r\n        this.addons.forEach(a => a.dispose());\r\n    }\r\n\r\n    async suggestFiles(accept: string): Promise<ITerminalFile[]> {\r\n        const rand = Math.round(Math.random() * 1000);\r\n        const id = `${Date.now()}-${rand}`;\r\n        const files = this.files$.value as ISuggestion[];\r\n        return files.filter(f => f.accept === accept).concat([\r\n            {\r\n                id,\r\n                label: \"...\",\r\n                onAccept: async () => {\r\n                    this.client.emit(\"terminal-upload\", {\r\n                        id,\r\n                        accept\r\n                    });\r\n                    const file = await this.files$\r\n                        .pipe(first(v => v.some(f => f.id === id)))\r\n                        .pipe(timeout(120000))\r\n                        .pipe(map(v => v.find(f => f.id === id)))\r\n                        .toPromise();\r\n                    if (file.error) {\r\n                        this.files$.next(this.files$.value.filter(f => f.id !== id));\r\n                        throw new Error(file.error);\r\n                    }\r\n                    return file;\r\n                },\r\n                showAlways: true,\r\n                accept: accept,\r\n            }\r\n        ]);\r\n    }\r\n\r\n    async downloadFile(filename: string, buffer: Buffer): Promise<void> {\r\n        const type = await fileTypeFromBuffer(buffer);\r\n        const data = buffer.toString(\"base64\");\r\n        const content = `data:${type.mime};base64,${data}`;\r\n        this.client.emit(\"terminal-download\", {\r\n            filename,\r\n            content\r\n        });\r\n    }\r\n\r\n    addFile(upload: ITerminalFile) {\r\n        if (upload.content) {\r\n            upload.buffer = Buffer.from(upload.content, \"base64\");\r\n        }\r\n        this.files$.next(this.files$.value.concat(upload));\r\n    }\r\n\r\n    input(data: string) {\r\n        this.input$.next(data);\r\n    }\r\n}\r\n"]}

package/esm2020/socket-middlewares/compression.middleware.mjs

@@ -0,0 +1,14 @@
+import { __decorate } from "tslib";
+import { injectable } from "tsyringe";
+import { Middleware } from "socket-controllers";
+let CompressionMiddleware = class CompressionMiddleware {
+    use(socket, next) {
+        next();
+    }
+};
+CompressionMiddleware = __decorate([
+    injectable(),
+    Middleware()
+], CompressionMiddleware);
+export { CompressionMiddleware };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29tcHJlc3Npb24ubWlkZGxld2FyZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9zb2NrZXQtbWlkZGxld2FyZXMvY29tcHJlc3Npb24ubWlkZGxld2FyZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUEsT0FBTyxFQUFDLFVBQVUsRUFBQyxNQUFNLFVBQVUsQ0FBQztBQUNwQyxPQUFPLEVBQUMsVUFBVSxFQUFzQixNQUFNLG9CQUFvQixDQUFDO0FBSTVELElBQU0scUJBQXFCLEdBQTNCLE1BQU0scUJBQXFCO0lBRTlCLEdBQUcsQ0FBQyxNQUFXLEVBQUUsSUFBd0I7UUFDckMsSUFBSSxFQUFFLENBQUM7SUFDWCxDQUFDO0NBQ0osQ0FBQTtBQUxZLHFCQUFxQjtJQUZqQyxVQUFVLEVBQUU7SUFDWixVQUFVLEVBQUU7R0FDQSxxQkFBcUIsQ0FLakM7U0FMWSxxQkFBcUIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge2luamVjdGFibGV9IGZyb20gXCJ0c3lyaW5nZVwiO1xyXG5pbXBvcnQge01pZGRsZXdhcmUsIE1pZGRsZXdhcmVJbnRlcmZhY2V9IGZyb20gXCJzb2NrZXQtY29udHJvbGxlcnNcIjtcclxuXHJcbkBpbmplY3RhYmxlKClcclxuQE1pZGRsZXdhcmUoKVxyXG5leHBvcnQgY2xhc3MgQ29tcHJlc3Npb25NaWRkbGV3YXJlIGltcGxlbWVudHMgTWlkZGxld2FyZUludGVyZmFjZSB7XHJcblxyXG4gICAgdXNlKHNvY2tldDogYW55LCBuZXh0OiAoZXJyPzogYW55KSA9PiBhbnkpIHtcclxuICAgICAgICBuZXh0KCk7XHJcbiAgICB9XHJcbn1cclxuIl19

package/esm2020/static.mjs

@@ -0,0 +1,23 @@
+import { existsSync } from "fs";
+import { resolve } from "path";
+import { static as serveStatic } from "express";
+import { EXPRESS } from "./common-types";
+import { EndpointProvider } from "./services/endpoint-provider";
+import { getDirName } from "./utils";
+export async function setupStatic(rootFolder, container) {
+    const browserFolder = resolve(rootFolder || getDirName(), `public_html`);
+    const app = container.get(EXPRESS);
+    const ep = container.get(EndpointProvider);
+    console.log(browserFolder, existsSync(browserFolder));
+    if (existsSync(browserFolder)) {
+        console.log(`public_html exists. setting up static files serving...`);
+        app.use(serveStatic(browserFolder, {
+            maxAge: "1y"
+        }));
+    }
+    else {
+        console.log(`public_html does not exist on path: "${browserFolder}"`);
+    }
+    await ep.configure(app);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/utilities/decorators.mjs

@@ -0,0 +1,52 @@
+import { getStatusCode, OpenAPI } from "routing-controllers-openapi";
+export function IsDocumented(summary = null, paramDescriptions = {}) {
+    return OpenAPI(op => {
+        op.summary = summary || op.summary;
+        op.tags = ["Documented"].concat(op.tags || []);
+        op.parameters?.forEach(p => {
+            if (p.$ref)
+                return;
+            const schema = p;
+            schema.description = paramDescriptions[schema.name]
+                || schema.description
+                || `param.${op.operationId}.${schema.name}`.toLowerCase();
+        });
+        return op;
+    });
+}
+export function JsonResponse(description = "Success", statusCode = null) {
+    return OpenAPI((op, route) => {
+        const status = statusCode ?? getStatusCode(route) + "";
+        op.responses = op.responses || {};
+        op.responses[status] = {
+            description,
+            content: {
+                "application/json": {}
+            }
+        };
+        return op;
+    });
+}
+export function ResponseType(type, options = {}) {
+    return OpenAPI((op, route) => {
+        const contentType = "application/json";
+        const statusCode = options?.statusCode ?? getStatusCode(route) + "";
+        const reference = {
+            $ref: `#/components/schemas/${type.name}`,
+        };
+        const schema = options.isArray
+            ? { items: reference, type: "array" }
+            : reference;
+        op.responses = op.responses || {};
+        op.responses[statusCode] = {
+            description: options.description || "Success",
+            content: {
+                [contentType]: {
+                    schema
+                }
+            }
+        };
+        return op;
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/utilities/di-container.mjs

@@ -0,0 +1,83 @@
+import { isFactoryProvider } from "tsyringe";
+import { Tree } from "./tree";
+import { isString } from "../utils";
+export class DiContainer {
+    constructor(container, parent = null) {
+        this.container = container;
+        this.parent = parent;
+        container["wrapperContainer"] = this;
+        this.tokens = [];
+        this.tokenSet = new Set();
+        this.root = new Tree(this, false, "");
+    }
+    get registeredTokens() {
+        return (this.parent?.registeredTokens || []).concat(this.tokens);
+    }
+    get tree() {
+        return this.root;
+    }
+    beforeResolution(token, callback, options) {
+        this.container.beforeResolution(token, callback, options);
+    }
+    afterResolution(token, callback, options) {
+        this.container.afterResolution(token, callback, options);
+    }
+    clearInstances() {
+        this.container.clearInstances();
+    }
+    createChildContainer() {
+        return new DiContainer(this.container.createChildContainer(), this);
+    }
+    isRegistered(token, recursive) {
+        return this.container.isRegistered(token, recursive);
+    }
+    register(token, provider, options) {
+        if (isFactoryProvider(provider)) {
+            this.container.register(token, {
+                useFactory: dc => {
+                    return provider.useFactory(dc["wrapperContainer"]);
+                }
+            });
+            return this.addToken(token);
+        }
+        this.container.register(token, provider);
+        return this.addToken(token);
+    }
+    registerInstance(token, instance) {
+        this.container.registerInstance(token, instance);
+        return this.addToken(token);
+    }
+    registerSingleton(from, to) {
+        this.container.registerSingleton(from, to);
+        return this.addToken(from);
+    }
+    registerType(from, to) {
+        this.container.registerType(from, to);
+        return this.addToken(from);
+    }
+    reset() {
+        this.tokens = [];
+        this.tokenSet = new Set();
+        this.container.reset();
+    }
+    resolve(token) {
+        return this.container.resolve(token);
+    }
+    resolveAll(token) {
+        return this.container.resolveAll(token);
+    }
+    get(token) {
+        return this.container.resolve(token);
+    }
+    addToken(token) {
+        if (this.tokenSet.has(token))
+            return this;
+        this.tokenSet.add(token);
+        this.tokens.push(token);
+        if (isString(token)) {
+            this.root.addPath(token);
+        }
+        return this;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"di-container.js","sourceRoot":"","sources":["../../../src/utilities/di-container.ts"],"names":[],"mappings":"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","sourcesContent":["import {\r\n    ClassProvider,\r\n    DependencyContainer,\r\n    Frequency,\r\n    InjectionToken,\r\n    isFactoryProvider,\r\n    RegistrationOptions,\r\n    TokenProvider,\r\n    ValueProvider\r\n} from \"tsyringe\";\r\nimport {FactoryProvider, IDependencyContainer, ITree, Type} from \"../common-types\";\r\nimport {Tree} from \"./tree\";\r\nimport {isString} from \"../utils\";\r\n\r\ninterface PreResolutionInterceptorCallback<T = any> {\r\n    (token: InjectionToken<T>, resolutionType: \"Single\" | \"All\"): void;\r\n}\r\n\r\ninterface PostResolutionInterceptorCallback<T = any> {\r\n    (token: InjectionToken<T>, result: T | T[], resolutionType: \"Single\" | \"All\"): void;\r\n}\r\n\r\nexport class DiContainer implements IDependencyContainer {\r\n\r\n    get registeredTokens(): ReadonlyArray<InjectionToken> {\r\n        return (this.parent?.registeredTokens || []).concat(this.tokens);\r\n    }\r\n\r\n    get tree(): ITree {\r\n        return this.root;\r\n    }\r\n\r\n    protected tokens: Array<InjectionToken>;\r\n    protected tokenSet: Set<InjectionToken>;\r\n    protected root: Tree;\r\n\r\n    constructor(protected container: DependencyContainer, readonly parent: IDependencyContainer = null) {\r\n        container[\"wrapperContainer\"] = this;\r\n        this.tokens = [];\r\n        this.tokenSet = new Set<InjectionToken>();\r\n        this.root = new Tree(this, false, \"\");\r\n    }\r\n\r\n    beforeResolution<T>(token: InjectionToken<T>, callback: PreResolutionInterceptorCallback<T>, options?: { frequency: Frequency }): void {\r\n        this.container.beforeResolution(token, callback, options);\r\n    }\r\n\r\n    afterResolution<T>(token: InjectionToken<T>, callback: PostResolutionInterceptorCallback<T>, options?: { frequency: Frequency }): void {\r\n        this.container.afterResolution(token, callback, options);\r\n    }\r\n\r\n    clearInstances(): void {\r\n        this.container.clearInstances();\r\n    }\r\n\r\n    createChildContainer(): IDependencyContainer {\r\n        return new DiContainer(this.container.createChildContainer(), this);\r\n    }\r\n\r\n    isRegistered<T>(token: InjectionToken<T>, recursive?: boolean): boolean {\r\n        return this.container.isRegistered(token, recursive);\r\n    }\r\n\r\n    register<T>(token: InjectionToken<T>, provider: ValueProvider<T>): IDependencyContainer;\r\n    register<T>(token: InjectionToken<T>, provider: FactoryProvider<T>): IDependencyContainer;\r\n    register<T>(token: InjectionToken<T>, provider: TokenProvider<T>, options?: RegistrationOptions): IDependencyContainer;\r\n    register<T>(token: InjectionToken<T>, provider: ClassProvider<T>, options?: RegistrationOptions): IDependencyContainer;\r\n    register<T>(token: InjectionToken<T>, provider: Type<T>, options?: RegistrationOptions): IDependencyContainer;\r\n    register(token, provider, options?: RegistrationOptions): IDependencyContainer {\r\n        if (isFactoryProvider(provider)) {\r\n            this.container.register(token, {\r\n                useFactory: dc => {\r\n                    return provider.useFactory(dc[\"wrapperContainer\"]);\r\n                }\r\n            });\r\n            return this.addToken(token);\r\n        }\r\n        this.container.register(token, provider);\r\n        return this.addToken(token);\r\n    }\r\n\r\n    registerInstance<T>(token: InjectionToken<T>, instance: T): IDependencyContainer {\r\n        this.container.registerInstance(token, instance);\r\n        return this.addToken(token);\r\n    }\r\n\r\n    registerSingleton<T>(from: InjectionToken<T>, to: InjectionToken<T>): IDependencyContainer;\r\n    registerSingleton<T>(token: Type<T>): IDependencyContainer;\r\n    registerSingleton(from, to?): IDependencyContainer {\r\n        this.container.registerSingleton(from, to);\r\n        return this.addToken(from);\r\n    }\r\n\r\n    registerType<T>(from: InjectionToken<T>, to: InjectionToken<T>): IDependencyContainer {\r\n        this.container.registerType(from, to);\r\n        return this.addToken(from);\r\n    }\r\n\r\n    reset(): void {\r\n        this.tokens = [];\r\n        this.tokenSet = new Set<InjectionToken>();\r\n        this.container.reset();\r\n    }\r\n\r\n    resolve<T>(token: InjectionToken<T>): T {\r\n        return this.container.resolve(token);\r\n    }\r\n\r\n    resolveAll<T>(token: InjectionToken<T>): T[] {\r\n        return this.container.resolveAll(token);\r\n    }\r\n\r\n    get<T>(token: InjectionToken<T>): T {\r\n        return this.container.resolve(token);\r\n    }\r\n\r\n    protected addToken<T>(token: InjectionToken<T>): this {\r\n        if (this.tokenSet.has(token)) return this;\r\n        this.tokenSet.add(token);\r\n        this.tokens.push(token);\r\n        if (isString(token)) {\r\n            this.root.addPath(token);\r\n        }\r\n        return this;\r\n    }\r\n}\r\n"]}

package/esm2020/utilities/empty-job.mjs

@@ -0,0 +1,13 @@
+import { __decorate } from "tslib";
+import { injectable, Lifecycle, scoped } from "tsyringe";
+let EmptyJob = class EmptyJob {
+    async process() {
+        return null;
+    }
+};
+EmptyJob = __decorate([
+    injectable(),
+    scoped(Lifecycle.ContainerScoped)
+], EmptyJob);
+export { EmptyJob };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW1wdHktam9iLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3V0aWxpdGllcy9lbXB0eS1qb2IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLE9BQU8sRUFBQyxVQUFVLEVBQUUsU0FBUyxFQUFFLE1BQU0sRUFBQyxNQUFNLFVBQVUsQ0FBQztBQUtoRCxJQUFNLFFBQVEsR0FBZCxNQUFNLFFBQVE7SUFFakIsS0FBSyxDQUFDLE9BQU87UUFDVCxPQUFPLElBQUksQ0FBQztJQUNoQixDQUFDO0NBQ0osQ0FBQTtBQUxZLFFBQVE7SUFGcEIsVUFBVSxFQUFFO0lBQ1osTUFBTSxDQUFDLFNBQVMsQ0FBQyxlQUFlLENBQUM7R0FDckIsUUFBUSxDQUtwQjtTQUxZLFFBQVEiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge2luamVjdGFibGUsIExpZmVjeWNsZSwgc2NvcGVkfSBmcm9tIFwidHN5cmluZ2VcIjtcclxuaW1wb3J0IHtJSm9ifSBmcm9tIFwiLi4vY29tbW9uLXR5cGVzXCI7XHJcblxyXG5AaW5qZWN0YWJsZSgpXHJcbkBzY29wZWQoTGlmZWN5Y2xlLkNvbnRhaW5lclNjb3BlZClcclxuZXhwb3J0IGNsYXNzIEVtcHR5Sm9iIGltcGxlbWVudHMgSUpvYiB7XHJcblxyXG4gICAgYXN5bmMgcHJvY2VzcygpOiBQcm9taXNlPGFueT4ge1xyXG4gICAgICAgIHJldHVybiBudWxsO1xyXG4gICAgfVxyXG59XHJcbiJdfQ==

package/esm2020/utilities/lazy-asset-generator.mjs

@@ -0,0 +1,35 @@
+export class LazyAssetGenerator {
+    constructor(assetResolver, progresses, lazyId) {
+        this.assetResolver = assetResolver;
+        this.progresses = progresses;
+        this.lazyId = lazyId;
+    }
+    get assets() {
+        return this.assetResolver.assets;
+    }
+    get lazyAssets() {
+        return this.assetResolver.lazyAssets;
+    }
+    async process(messaging) {
+        const lazyAsset = await this.lazyAssets.read(this.lazyId);
+        let progress = await this.progresses.get(lazyAsset.progressId);
+        if (!progress || progress.canceled)
+            return null;
+        progress.setMessageBridge(messaging);
+        try {
+            const asset = await this.generate(progress, messaging);
+            progress = await progress.load();
+            if (!progress || progress.canceled)
+                return null;
+            await lazyAsset.writeAsset(asset);
+        }
+        catch (e) {
+            await progress.setError(e.message || e);
+            throw e;
+        }
+        if (progress.remaining > 0) {
+            await progress.advance(progress.remaining);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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