@stemy/backend 5.2.1 → 6.0.0

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

@@ -0,0 +1,63 @@
+import { __decorate, __metadata, __param } from "tslib";
+import { inject, singleton } from "tsyringe";
+import { ConnectedSocket, MessageBody, OnMessage, SocketController } from "socket-controllers";
+import { Server } from "socket.io";
+import { SOCKET_SERVER } from "../common-types";
+import { broadcast } from "../utils";
+import { Progresses } from "../services/progresses";
+let ProgressController = class ProgressController {
+    progresses;
+    socketServer;
+    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()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, String]),
+    __metadata("design:returntype", Promise)
+], ProgressController.prototype, "advanceProgress", null);
+__decorate([
+    OnMessage("background-progress-interest"),
+    __param(0, ConnectedSocket()),
+    __param(1, MessageBody()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, String]),
+    __metadata("design:returntype", Promise)
+], ProgressController.prototype, "setProgressInterest", null);
+ProgressController = __decorate([
+    singleton(),
+    SocketController(),
+    __param(1, inject(SOCKET_SERVER)),
+    __metadata("design:paramtypes", [Progresses, Server])
+], ProgressController);
+export { ProgressController };
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,61 @@
+import { __decorate, __metadata, __param } from "tslib";
+import { singleton } from "tsyringe";
+import { ConnectedSocket, MessageBody, OnMessage, SocketController } from "socket-controllers";
+import { TerminalManager } from "../services/terminal-manager";
+import { Terminal } from "./terminal";
+let TerminalController = class TerminalController {
+    manager;
+    terminals;
+    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()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], TerminalController.prototype, "terminalInit", null);
+__decorate([
+    OnMessage("terminal-data"),
+    __param(0, ConnectedSocket()),
+    __param(1, MessageBody()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, String]),
+    __metadata("design:returntype", Promise)
+], TerminalController.prototype, "terminalData", null);
+__decorate([
+    OnMessage("terminal-upload"),
+    __param(0, ConnectedSocket()),
+    __param(1, MessageBody()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], TerminalController.prototype, "terminalUpload", null);
+TerminalController = __decorate([
+    singleton(),
+    SocketController(),
+    __metadata("design:paramtypes", [TerminalManager])
+], TerminalController);
+export { TerminalController };
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/socket-controllers/terminal.mjs

@@ -0,0 +1,89 @@
+import { BehaviorSubject, Subject } from "rxjs";
+import { first, map, timeout } from "rxjs/operators";
+import { fileTypeFromBuffer } from "../utils";
+export class Terminal {
+    client;
+    addons;
+    files$;
+    input$;
+    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/esm2022/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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29tcHJlc3Npb24ubWlkZGxld2FyZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9zb2NrZXQtbWlkZGxld2FyZXMvY29tcHJlc3Npb24ubWlkZGxld2FyZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUEsT0FBTyxFQUFDLFVBQVUsRUFBQyxNQUFNLFVBQVUsQ0FBQztBQUNwQyxPQUFPLEVBQUMsVUFBVSxFQUFzQixNQUFNLG9CQUFvQixDQUFDO0FBSTVELElBQU0scUJBQXFCLEdBQTNCLE1BQU0scUJBQXFCO0lBRTlCLEdBQUcsQ0FBQyxNQUFXLEVBQUUsSUFBd0I7UUFDckMsSUFBSSxFQUFFLENBQUM7SUFDWCxDQUFDO0NBQ0osQ0FBQTtBQUxZLHFCQUFxQjtJQUZqQyxVQUFVLEVBQUU7SUFDWixVQUFVLENBQUMsRUFBRSxDQUFDO0dBQ0YscUJBQXFCLENBS2pDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtpbmplY3RhYmxlfSBmcm9tIFwidHN5cmluZ2VcIjtcclxuaW1wb3J0IHtNaWRkbGV3YXJlLCBNaWRkbGV3YXJlSW50ZXJmYWNlfSBmcm9tIFwic29ja2V0LWNvbnRyb2xsZXJzXCI7XHJcblxyXG5AaW5qZWN0YWJsZSgpXHJcbkBNaWRkbGV3YXJlKHt9KVxyXG5leHBvcnQgY2xhc3MgQ29tcHJlc3Npb25NaWRkbGV3YXJlIGltcGxlbWVudHMgTWlkZGxld2FyZUludGVyZmFjZSB7XHJcblxyXG4gICAgdXNlKHNvY2tldDogYW55LCBuZXh0OiAoZXJyPzogYW55KSA9PiBhbnkpIHtcclxuICAgICAgICBuZXh0KCk7XHJcbiAgICB9XHJcbn1cclxuIl19

package/esm2022/static.mjs

@@ -0,0 +1,23 @@
+import { existsSync } from "fs";
+import { resolve } from "path";
+import express 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(express.static(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/esm2022/stemy-backend.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public_api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RlbXktYmFja2VuZC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9zdGVteS1iYWNrZW5kLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsY0FBYyxjQUFjLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEdlbmVyYXRlZCBidW5kbGUgaW5kZXguIERvIG5vdCBlZGl0LlxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vcHVibGljX2FwaSc7XG4iXX0=

package/esm2022/utilities/base-doc.mjs

@@ -0,0 +1,33 @@
+import mongoose from "mongoose";
+import { getModelForClass } from "@typegoose/typegoose";
+export class BaseDoc {
+    _id;
+    /**
+     * This getter/setter doesn't exist if "schemaOptions.id" being set to "false"
+     */
+    id;
+    /**
+     * This getter doesn't exist if "schemaOptions.timestamps" being set to "false"
+     */
+    createdAt;
+    /**
+     * This getter doesn't exist if "schemaOptions.timestamps" being set to "false"
+     */
+    updatedAt;
+    /**
+     * Casts this to DocumentType<this> to allow using document methods in get/set-s
+     */
+    cast() {
+        return this;
+    }
+    /**
+     * Gets a pre-compiled model from typegoose cache by its class type
+     * @param type
+     */
+    model(type) {
+        return getModelForClass(type);
+    }
+}
+export const PrimitiveArray = mongoose.Types.Array;
+export const DocumentArray = mongoose.Types.DocumentArray;
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/utilities/decorators.mjs

@@ -0,0 +1,51 @@
+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}`,
+        };
+        op.responses = op.responses || {};
+        op.responses[statusCode] = {
+            description: options.description || "Success",
+            content: {
+                [contentType]: {
+                    schema: options.isArray
+                        ? { items: reference, type: "array" }
+                        : reference
+                }
+            }
+        };
+        return op;
+    });
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVjb3JhdG9ycy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy91dGlsaXRpZXMvZGVjb3JhdG9ycy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUMsYUFBYSxFQUFFLE9BQU8sRUFBQyxNQUFNLDZCQUE2QixDQUFDO0FBR25FLE1BQU0sVUFBVSxZQUFZLENBQUMsVUFBa0IsSUFBSSxFQUFFLG9CQUE4QyxFQUFFO0lBQ2pHLE9BQU8sT0FBTyxDQUFDLEVBQUUsQ0FBQyxFQUFFO1FBQ2hCLEVBQUUsQ0FBQyxPQUFPLEdBQUcsT0FBTyxJQUFJLEVBQUUsQ0FBQyxPQUFPLENBQUM7UUFDbkMsRUFBRSxDQUFDLElBQUksR0FBRyxDQUFDLFlBQVksQ0FBQyxDQUFDLE1BQU0sQ0FBQyxFQUFFLENBQUMsSUFBSSxJQUFJLEVBQUUsQ0FBQyxDQUFDO1FBQy9DLEVBQUUsQ0FBQyxVQUFVLEVBQUUsT0FBTyxDQUFDLENBQUMsQ0FBQyxFQUFFO1lBQ3ZCLElBQUssQ0FBcUIsRUFBRSxJQUFJO2dCQUFFLE9BQU87WUFDekMsTUFBTSxNQUFNLEdBQUcsQ0FBb0IsQ0FBQztZQUNwQyxNQUFNLENBQUMsV0FBVyxHQUFHLGlCQUFpQixDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUM7bUJBQzVDLE1BQU0sQ0FBQyxXQUFXO21CQUNsQixTQUFTLEVBQUUsQ0FBQyxXQUFXLElBQUksTUFBTSxDQUFDLElBQUksRUFBRSxDQUFDLFdBQVcsRUFBRSxDQUFDO1FBQ2xFLENBQUMsQ0FBQyxDQUFDO1FBQ0gsT0FBTyxFQUFFLENBQUM7SUFDZCxDQUFDLENBQUMsQ0FBQztBQUNQLENBQUM7QUFFRCxNQUFNLFVBQVUsWUFBWSxDQUFDLGNBQXNCLFNBQVMsRUFBRSxhQUFxQixJQUFJO0lBQ25GLE9BQU8sT0FBTyxDQUFDLENBQUMsRUFBRSxFQUFFLEtBQUssRUFBRSxFQUFFO1FBQ3pCLE1BQU0sTUFBTSxHQUFHLFVBQVUsSUFBSSxhQUFhLENBQUMsS0FBSyxDQUFDLEdBQUcsRUFBRSxDQUFDO1FBQ3ZELEVBQUUsQ0FBQyxTQUFTLEdBQUcsRUFBRSxDQUFDLFNBQVMsSUFBSSxFQUFFLENBQUM7UUFDbEMsRUFBRSxDQUFDLFNBQVMsQ0FBQyxNQUFNLENBQUMsR0FBRztZQUNuQixXQUFXO1lBQ1gsT0FBTyxFQUFFO2dCQUNMLGtCQUFrQixFQUFFLEVBQUU7YUFDekI7U0FDSixDQUFDO1FBQ0YsT0FBTyxFQUFFLENBQUM7SUFDZCxDQUFDLENBQUMsQ0FBQztBQUNQLENBQUM7QUFRRCxNQUFNLFVBQVUsWUFBWSxDQUFDLElBQWMsRUFBRSxVQUFnQyxFQUFFO0lBQzNFLE9BQU8sT0FBTyxDQUFDLENBQUMsRUFBRSxFQUFFLEtBQUssRUFBRSxFQUFFO1FBQ3pCLE1BQU0sV0FBVyxHQUFHLGtCQUFrQixDQUFDO1FBQ3ZDLE1BQU0sVUFBVSxHQUFHLE9BQU8sRUFBRSxVQUFVLElBQUksYUFBYSxDQUFDLEtBQUssQ0FBQyxHQUFHLEVBQUUsQ0FBQztRQUNwRSxNQUFNLFNBQVMsR0FBb0I7WUFDL0IsSUFBSSxFQUFFLHdCQUF3QixJQUFJLENBQUMsSUFBSSxFQUFFO1NBQzVDLENBQUM7UUFDRixFQUFFLENBQUMsU0FBUyxHQUFHLEVBQUUsQ0FBQyxTQUFTLElBQUksRUFBRSxDQUFDO1FBQ2xDLEVBQUUsQ0FBQyxTQUFTLENBQUMsVUFBVSxDQUFDLEdBQUc7WUFDdkIsV0FBVyxFQUFFLE9BQU8sQ0FBQyxXQUFXLElBQUksU0FBUztZQUM3QyxPQUFPLEVBQUU7Z0JBQ0wsQ0FBQyxXQUFXLENBQUMsRUFBRTtvQkFDWCxNQUFNLEVBQUUsT0FBTyxDQUFDLE9BQU87d0JBQ25CLENBQUMsQ0FBQyxFQUFFLEtBQUssRUFBRSxTQUFTLEVBQUUsSUFBSSxFQUFFLE9BQU8sRUFBRTt3QkFDckMsQ0FBQyxDQUFDLFNBQVM7aUJBQ2xCO2FBQ0o7U0FDSixDQUFDO1FBQ0YsT0FBTyxFQUFFLENBQUM7SUFDZCxDQUFDLENBQUMsQ0FBQztBQUNQLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge2dldFN0YXR1c0NvZGUsIE9wZW5BUEl9IGZyb20gXCJyb3V0aW5nLWNvbnRyb2xsZXJzLW9wZW5hcGlcIjtcclxuaW1wb3J0IHtQYXJhbWV0ZXJPYmplY3QsIFJlZmVyZW5jZU9iamVjdH0gZnJvbSBcIm9wZW5hcGkzLXRzXCI7XHJcblxyXG5leHBvcnQgZnVuY3Rpb24gSXNEb2N1bWVudGVkKHN1bW1hcnk6IHN0cmluZyA9IG51bGwsIHBhcmFtRGVzY3JpcHRpb25zOiB7W25hbWU6IHN0cmluZ106IHN0cmluZ30gPSB7fSkge1xyXG4gICAgcmV0dXJuIE9wZW5BUEkob3AgPT4ge1xyXG4gICAgICAgIG9wLnN1bW1hcnkgPSBzdW1tYXJ5IHx8IG9wLnN1bW1hcnk7XHJcbiAgICAgICAgb3AudGFncyA9IFtcIkRvY3VtZW50ZWRcIl0uY29uY2F0KG9wLnRhZ3MgfHwgW10pO1xyXG4gICAgICAgIG9wLnBhcmFtZXRlcnM/LmZvckVhY2gocCA9PiB7XHJcbiAgICAgICAgICAgIGlmICgocCBhcyBSZWZlcmVuY2VPYmplY3QpPy4kcmVmKSByZXR1cm47XHJcbiAgICAgICAgICAgIGNvbnN0IHNjaGVtYSA9IHAgYXMgUGFyYW1ldGVyT2JqZWN0O1xyXG4gICAgICAgICAgICBzY2hlbWEuZGVzY3JpcHRpb24gPSBwYXJhbURlc2NyaXB0aW9uc1tzY2hlbWEubmFtZV1cclxuICAgICAgICAgICAgICAgIHx8IHNjaGVtYS5kZXNjcmlwdGlvblxyXG4gICAgICAgICAgICAgICAgfHwgYHBhcmFtLiR7b3Aub3BlcmF0aW9uSWR9LiR7c2NoZW1hLm5hbWV9YC50b0xvd2VyQ2FzZSgpO1xyXG4gICAgICAgIH0pO1xyXG4gICAgICAgIHJldHVybiBvcDtcclxuICAgIH0pO1xyXG59XHJcblxyXG5leHBvcnQgZnVuY3Rpb24gSnNvblJlc3BvbnNlKGRlc2NyaXB0aW9uOiBzdHJpbmcgPSBcIlN1Y2Nlc3NcIiwgc3RhdHVzQ29kZTogbnVtYmVyID0gbnVsbCkge1xyXG4gICAgcmV0dXJuIE9wZW5BUEkoKG9wLCByb3V0ZSkgPT4ge1xyXG4gICAgICAgIGNvbnN0IHN0YXR1cyA9IHN0YXR1c0NvZGUgPz8gZ2V0U3RhdHVzQ29kZShyb3V0ZSkgKyBcIlwiO1xyXG4gICAgICAgIG9wLnJlc3BvbnNlcyA9IG9wLnJlc3BvbnNlcyB8fCB7fTtcclxuICAgICAgICBvcC5yZXNwb25zZXNbc3RhdHVzXSA9IHtcclxuICAgICAgICAgICAgZGVzY3JpcHRpb24sXHJcbiAgICAgICAgICAgIGNvbnRlbnQ6IHtcclxuICAgICAgICAgICAgICAgIFwiYXBwbGljYXRpb24vanNvblwiOiB7fVxyXG4gICAgICAgICAgICB9XHJcbiAgICAgICAgfTtcclxuICAgICAgICByZXR1cm4gb3A7XHJcbiAgICB9KTtcclxufVxyXG5cclxuZXhwb3J0IGludGVyZmFjZSBJUmVzcG9uc2VUeXBlT3B0aW9ucyB7XHJcbiAgICBkZXNjcmlwdGlvbj86IHN0cmluZztcclxuICAgIHN0YXR1c0NvZGU/OiBudW1iZXI7XHJcbiAgICBpc0FycmF5PzogYm9vbGVhbjtcclxufVxyXG5cclxuZXhwb3J0IGZ1bmN0aW9uIFJlc3BvbnNlVHlwZSh0eXBlOiBGdW5jdGlvbiwgb3B0aW9uczogSVJlc3BvbnNlVHlwZU9wdGlvbnMgPSB7fSkge1xyXG4gICAgcmV0dXJuIE9wZW5BUEkoKG9wLCByb3V0ZSkgPT4ge1xyXG4gICAgICAgIGNvbnN0IGNvbnRlbnRUeXBlID0gXCJhcHBsaWNhdGlvbi9qc29uXCI7XHJcbiAgICAgICAgY29uc3Qgc3RhdHVzQ29kZSA9IG9wdGlvbnM/LnN0YXR1c0NvZGUgPz8gZ2V0U3RhdHVzQ29kZShyb3V0ZSkgKyBcIlwiO1xyXG4gICAgICAgIGNvbnN0IHJlZmVyZW5jZTogUmVmZXJlbmNlT2JqZWN0ID0ge1xyXG4gICAgICAgICAgICAkcmVmOiBgIy9jb21wb25lbnRzL3NjaGVtYXMvJHt0eXBlLm5hbWV9YCxcclxuICAgICAgICB9O1xyXG4gICAgICAgIG9wLnJlc3BvbnNlcyA9IG9wLnJlc3BvbnNlcyB8fCB7fTtcclxuICAgICAgICBvcC5yZXNwb25zZXNbc3RhdHVzQ29kZV0gPSB7XHJcbiAgICAgICAgICAgIGRlc2NyaXB0aW9uOiBvcHRpb25zLmRlc2NyaXB0aW9uIHx8IFwiU3VjY2Vzc1wiLFxyXG4gICAgICAgICAgICBjb250ZW50OiB7XHJcbiAgICAgICAgICAgICAgICBbY29udGVudFR5cGVdOiB7XHJcbiAgICAgICAgICAgICAgICAgICAgc2NoZW1hOiBvcHRpb25zLmlzQXJyYXlcclxuICAgICAgICAgICAgICAgICAgICAgICAgPyB7IGl0ZW1zOiByZWZlcmVuY2UsIHR5cGU6IFwiYXJyYXlcIiB9XHJcbiAgICAgICAgICAgICAgICAgICAgICAgIDogcmVmZXJlbmNlXHJcbiAgICAgICAgICAgICAgICB9XHJcbiAgICAgICAgICAgIH1cclxuICAgICAgICB9O1xyXG4gICAgICAgIHJldHVybiBvcDtcclxuICAgIH0pO1xyXG59XHJcbiJdfQ==

package/esm2022/utilities/di-container.mjs

@@ -0,0 +1,88 @@
+import { isFactoryProvider } from "tsyringe";
+import { Tree } from "./tree";
+import { isString } from "../utils";
+export class DiContainer {
+    container;
+    parent;
+    get registeredTokens() {
+        return (this.parent?.registeredTokens || []).concat(this.tokens);
+    }
+    get tree() {
+        return this.root;
+    }
+    tokens;
+    tokenSet;
+    root;
+    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, "");
+    }
+    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/esm2022/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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW1wdHktam9iLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3V0aWxpdGllcy9lbXB0eS1qb2IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLE9BQU8sRUFBQyxVQUFVLEVBQUUsU0FBUyxFQUFFLE1BQU0sRUFBQyxNQUFNLFVBQVUsQ0FBQztBQUtoRCxJQUFNLFFBQVEsR0FBZCxNQUFNLFFBQVE7SUFFakIsS0FBSyxDQUFDLE9BQU87UUFDVCxPQUFPLElBQUksQ0FBQztJQUNoQixDQUFDO0NBQ0osQ0FBQTtBQUxZLFFBQVE7SUFGcEIsVUFBVSxFQUFFO0lBQ1osTUFBTSxDQUFDLFNBQVMsQ0FBQyxlQUFlLENBQUM7R0FDckIsUUFBUSxDQUtwQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7aW5qZWN0YWJsZSwgTGlmZWN5Y2xlLCBzY29wZWR9IGZyb20gXCJ0c3lyaW5nZVwiO1xyXG5pbXBvcnQge0lKb2J9IGZyb20gXCIuLi9jb21tb24tdHlwZXNcIjtcclxuXHJcbkBpbmplY3RhYmxlKClcclxuQHNjb3BlZChMaWZlY3ljbGUuQ29udGFpbmVyU2NvcGVkKVxyXG5leHBvcnQgY2xhc3MgRW1wdHlKb2IgaW1wbGVtZW50cyBJSm9iIHtcclxuXHJcbiAgICBhc3luYyBwcm9jZXNzKCk6IFByb21pc2U8YW55PiB7XHJcbiAgICAgICAgcmV0dXJuIG51bGw7XHJcbiAgICB9XHJcbn1cclxuIl19

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

@@ -0,0 +1,38 @@
+export class LazyAssetGenerator {
+    assetResolver;
+    progresses;
+    lazyId;
+    get assets() {
+        return this.assetResolver.assets;
+    }
+    get lazyAssets() {
+        return this.assetResolver.lazyAssets;
+    }
+    constructor(assetResolver, progresses, lazyId) {
+        this.assetResolver = assetResolver;
+        this.progresses = progresses;
+        this.lazyId = lazyId;
+    }
+    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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