@stemy/backend 5.2.2 → 6.0.0

package/esm2022/services/entities/progress.mjs

@@ -0,0 +1,182 @@
+import { BaseEntity } from "./base-entity";
+export class Progress extends BaseEntity {
+    messageBridge;
+    get current() {
+        return this.data.current;
+    }
+    get max() {
+        return this.data.max;
+    }
+    get message() {
+        return this.data.message;
+    }
+    get error() {
+        return this.data.error;
+    }
+    get canceled() {
+        return this.data.canceled;
+    }
+    get percent() {
+        return this.max > 0 ? Math.round(this.current / this.max * 100) : 0;
+    }
+    get remaining() {
+        return this.max > 0 ? this.max - this.current : 0;
+    }
+    constructor(id, data, collection) {
+        super(id, data, collection);
+    }
+    setMessageBridge(messageBridge) {
+        this.messageBridge = messageBridge || this.messageBridge;
+        return this;
+    }
+    async createSubProgress(progressValue, max, message) {
+        if (max <= 0 && progressValue > 0) {
+            await this.advance(progressValue);
+        }
+        if (message !== null) {
+            this.data.message = message;
+            await this.save();
+        }
+        return new SubProgress(this, this.current, progressValue, Math.max(max, 1));
+    }
+    async setMax(max) {
+        if (isNaN(max) || max <= 0) {
+            throw "Max progress value must be bigger than zero";
+        }
+        this.data.max = max;
+        await this.save();
+    }
+    async setMessage(message) {
+        this.data.message = message;
+        await this.save();
+    }
+    async setError(error) {
+        this.data.error = error;
+        await this.save();
+    }
+    async advance(value = 1) {
+        if (isNaN(value) || value <= 0) {
+            throw new Error(`Advance value must be bigger than zero: ${this.id}`);
+        }
+        await this.load();
+        if (this.deleted || this.canceled) {
+            const status = this.deleted ? "deleted" : "canceled";
+            throw new Error(`Can't advance ${status} progress: ${this.id}`);
+        }
+        this.data.current = Math.min(this.max, this.current + value);
+        await this.save();
+    }
+    async cancel() {
+        this.data.canceled = true;
+        await this.save();
+    }
+    save() {
+        if (this.messageBridge) {
+            this.messageBridge.sendMessage(`progress-changed`, this.toJSON());
+        }
+        return super.save();
+    }
+}
+export class SubProgress {
+    parent;
+    progressFrom;
+    progressValue;
+    mMax;
+    get id() {
+        return this.parent.id;
+    }
+    get current() {
+        return this.mCurrent;
+    }
+    get max() {
+        return this.mMax;
+    }
+    get message() {
+        return this.parent.message;
+    }
+    get error() {
+        return this.parent.error;
+    }
+    get percent() {
+        return this.parent.percent;
+    }
+    get remaining() {
+        return this.max - this.mCurrent;
+    }
+    get canceled() {
+        return !this.parent || this.parent.canceled;
+    }
+    mCurrent;
+    constructor(parent, progressFrom, progressValue, mMax = 100) {
+        this.parent = parent;
+        this.progressFrom = progressFrom;
+        this.progressValue = progressValue;
+        this.mMax = mMax;
+        if (progressFrom < 0) {
+            throw "Progress from must be bigger than or zero";
+        }
+        if (progressValue <= 0) {
+            throw "Progress value must be bigger than zero";
+        }
+        this.mCurrent = 0;
+    }
+    setMessageBridge(messageBridge) {
+        if (!this.parent)
+            return this;
+        this.parent.setMessageBridge(messageBridge);
+        return this;
+    }
+    async createSubProgress(progressValue, max, message) {
+        if (max <= 0 && progressValue > 0) {
+            await this.advance(progressValue);
+        }
+        if (message !== null) {
+            await this.setMessage(message);
+        }
+        return new SubProgress(this, this.current, progressValue, Math.max(max, 1));
+    }
+    async setMax(max) {
+        if (isNaN(max) || max <= 0) {
+            throw "Max progress value must be bigger than zero";
+        }
+        this.mMax = max;
+        await this.save();
+    }
+    async setMessage(message) {
+        if (!this.parent)
+            return null;
+        await this.parent.setMessage(message);
+    }
+    async setError(error) {
+        if (!this.parent)
+            return null;
+        await this.parent.setError(error);
+    }
+    async advance(value = 1) {
+        if (isNaN(value) || value <= 0) {
+            throw "Advance value must be bigger than zero";
+        }
+        this.mCurrent = Math.min(this.max, this.mCurrent + value);
+        await this.save();
+    }
+    async cancel() {
+        if (!this.parent)
+            return null;
+        await this.parent.cancel();
+    }
+    async save() {
+        const ratio = this.max > 0 ? this.mCurrent / this.max : 0;
+        const newProgress = this.progressFrom + Math.round(this.progressValue * ratio);
+        const current = this.parent.current;
+        if (newProgress <= current)
+            return null;
+        await this.parent.advance(newProgress);
+    }
+    async load() {
+        return null;
+    }
+    toJSON() {
+        return this.parent.toJSON();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"progress.js","sourceRoot":"","sources":["../../../../src/services/entities/progress.ts"],"names":[],"mappings":"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","sourcesContent":["import {ObjectId} from \"bson\";\r\nimport {Collection} from \"mongodb\";\r\nimport {IMessageBridge, IProgress} from \"../../common-types\";\r\nimport {BaseEntity} from \"./base-entity\";\r\n\r\nexport class Progress extends BaseEntity<IProgress> implements IProgress {\r\n\r\n    protected messageBridge: IMessageBridge;\r\n\r\n    get current(): number {\r\n        return this.data.current;\r\n    }\r\n\r\n    get max(): number {\r\n        return this.data.max;\r\n    }\r\n\r\n    get message(): string {\r\n        return this.data.message;\r\n    }\r\n\r\n    get error(): string {\r\n        return this.data.error;\r\n    }\r\n\r\n    get canceled(): boolean {\r\n        return this.data.canceled;\r\n    }\r\n\r\n    get percent(): number {\r\n        return this.max > 0 ? Math.round(this.current / this.max * 100) : 0;\r\n    }\r\n\r\n    get remaining(): number {\r\n        return this.max > 0 ? this.max - this.current : 0;\r\n    }\r\n\r\n    constructor(id: ObjectId,\r\n                data: Partial<IProgress>,\r\n                collection: Collection) {\r\n        super(id, data, collection);\r\n    }\r\n\r\n    setMessageBridge(messageBridge: IMessageBridge): this {\r\n        this.messageBridge = messageBridge || this.messageBridge;\r\n        return this;\r\n    }\r\n\r\n    async createSubProgress(progressValue: number, max?: number, message?: string): Promise<IProgress> {\r\n        if (max <= 0 && progressValue > 0) {\r\n            await this.advance(progressValue);\r\n        }\r\n        if (message !== null) {\r\n            this.data.message = message;\r\n            await this.save();\r\n        }\r\n        return new SubProgress(this, this.current, progressValue, Math.max(max, 1));\r\n    }\r\n\r\n    async setMax(max: number): Promise<any> {\r\n        if (isNaN(max) || max <= 0) {\r\n            throw \"Max progress value must be bigger than zero\";\r\n        }\r\n        this.data.max = max;\r\n        await this.save();\r\n    }\r\n\r\n    async setMessage(message: string): Promise<any> {\r\n        this.data.message = message;\r\n        await this.save();\r\n    }\r\n\r\n    async setError(error: string): Promise<any> {\r\n        this.data.error = error;\r\n        await this.save();\r\n    }\r\n\r\n    async advance(value: number = 1): Promise<any> {\r\n        if (isNaN(value) || value <= 0) {\r\n            throw new Error(`Advance value must be bigger than zero: ${this.id}`);\r\n        }\r\n        await this.load();\r\n        if (this.deleted || this.canceled) {\r\n            const status = this.deleted ? \"deleted\" : \"canceled\";\r\n            throw new Error(`Can't advance ${status} progress: ${this.id}`);\r\n        }\r\n        this.data.current = Math.min(this.max, this.current + value);\r\n        await this.save();\r\n    }\r\n\r\n    async cancel(): Promise<any> {\r\n        this.data.canceled = true;\r\n        await this.save();\r\n    }\r\n\r\n    save(): Promise<any> {\r\n        if (this.messageBridge) {\r\n            this.messageBridge.sendMessage(`progress-changed`, this.toJSON());\r\n        }\r\n        return super.save();\r\n    }\r\n}\r\n\r\nexport class SubProgress implements IProgress {\r\n\r\n    get id(): string {\r\n        return this.parent.id;\r\n    }\r\n\r\n    get current(): number {\r\n        return this.mCurrent;\r\n    }\r\n\r\n    get max(): number {\r\n        return this.mMax;\r\n    }\r\n\r\n    get message(): string {\r\n        return this.parent.message;\r\n    }\r\n\r\n    get error(): string {\r\n        return this.parent.error;\r\n    }\r\n\r\n    get percent(): number {\r\n        return this.parent.percent;\r\n    }\r\n\r\n    get remaining(): number {\r\n        return this.max - this.mCurrent;\r\n    }\r\n\r\n    get canceled(): boolean {\r\n        return !this.parent || this.parent.canceled;\r\n    }\r\n\r\n    protected mCurrent: number;\r\n\r\n    constructor(protected parent: IProgress, protected progressFrom: number, protected progressValue: number, protected mMax: number = 100) {\r\n        if (progressFrom < 0) {\r\n            throw \"Progress from must be bigger than or zero\";\r\n        }\r\n        if (progressValue <= 0) {\r\n            throw \"Progress value must be bigger than zero\";\r\n        }\r\n        this.mCurrent = 0;\r\n    }\r\n\r\n    setMessageBridge(messageBridge: IMessageBridge): this {\r\n        if (!this.parent) return this;\r\n        this.parent.setMessageBridge(messageBridge);\r\n        return this;\r\n    }\r\n\r\n    async createSubProgress(progressValue: number, max?: number, message?: string): Promise<IProgress> {\r\n        if (max <= 0 && progressValue > 0) {\r\n            await this.advance(progressValue);\r\n        }\r\n        if (message !== null) {\r\n            await this.setMessage(message);\r\n        }\r\n        return new SubProgress(this, this.current, progressValue, Math.max(max, 1));\r\n    }\r\n\r\n    async setMax(max: number): Promise<any> {\r\n        if (isNaN(max) || max <= 0) {\r\n            throw \"Max progress value must be bigger than zero\";\r\n        }\r\n        this.mMax = max;\r\n        await this.save();\r\n    }\r\n\r\n    async setMessage(message: string): Promise<any> {\r\n        if (!this.parent) return null;\r\n        await this.parent.setMessage(message);\r\n    }\r\n\r\n    async setError(error: string): Promise<any> {\r\n        if (!this.parent) return null;\r\n        await this.parent.setError(error);\r\n    }\r\n\r\n    async advance(value: number = 1): Promise<any> {\r\n        if (isNaN(value) || value <= 0) {\r\n            throw \"Advance value must be bigger than zero\";\r\n        }\r\n        this.mCurrent = Math.min(this.max, this.mCurrent + value);\r\n        await this.save();\r\n    }\r\n\r\n    async cancel(): Promise<any> {\r\n        if (!this.parent) return null;\r\n        await this.parent.cancel();\r\n    }\r\n\r\n    async save(): Promise<any> {\r\n        const ratio = this.max > 0 ? this.mCurrent / this.max : 0;\r\n        const newProgress = this.progressFrom + Math.round(this.progressValue * ratio);\r\n        const current = this.parent.current;\r\n        if (newProgress <= current) return null;\r\n        await this.parent.advance(newProgress)\r\n    }\r\n\r\n    async load(): Promise<any> {\r\n        return null;\r\n    }\r\n\r\n    toJSON(): any {\r\n        return this.parent.toJSON();\r\n    }\r\n}\r\n"]}

package/esm2022/services/entities/temp-asset.mjs

@@ -0,0 +1,53 @@
+import { ObjectId } from "bson";
+import { bufferToStream, toImage } from "../../utils";
+export class TempAsset {
+    buffer;
+    filename;
+    contentType;
+    metadata;
+    id;
+    get stream() {
+        return bufferToStream(this.buffer);
+    }
+    constructor(buffer, filename, contentType, metadata) {
+        this.buffer = buffer;
+        this.filename = filename;
+        this.contentType = contentType;
+        this.metadata = metadata;
+        this.id = new ObjectId().toHexString();
+    }
+    async unlink() {
+        throw new Error(`Temp asset '${this.id}' can not be removed!`);
+    }
+    async setMeta(meta) {
+        Object.assign(this.metadata, meta || {});
+    }
+    async getBuffer() {
+        return this.buffer;
+    }
+    async download(metadata) {
+        return this.stream;
+    }
+    downloadImage(params, metadata) {
+        Object.assign(this.metadata, metadata || {});
+        return toImage(this.stream, params, this.metadata);
+    }
+    getImage(params) {
+        return this.downloadImage(params);
+    }
+    async save() {
+        return this;
+    }
+    async load() {
+        return this;
+    }
+    toJSON() {
+        return {
+            id: this.id,
+            filename: this.filename,
+            contentType: this.contentType,
+            metadata: this.metadata
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/services/fixtures.mjs

@@ -0,0 +1,38 @@
+import { __decorate, __metadata, __param } from "tslib";
+import { inject, injectable, Lifecycle, scoped } from "tsyringe";
+import { DI_CONTAINER, FIXTURE } from "../common-types";
+let Fixtures = class Fixtures {
+    container;
+    fixtures;
+    constructor(container) {
+        this.container = container;
+    }
+    init(output) {
+        try {
+            return this.container.resolveAll(FIXTURE);
+        }
+        catch (e) {
+            output.writeln(e.message);
+            return [];
+        }
+    }
+    async load(output) {
+        output = output || {
+            write: console.log,
+            writeln: t => console.log(t + "\n")
+        };
+        this.fixtures = this.fixtures || this.init(output);
+        output.write(`Loading fixtures: ${this.fixtures.length} items`);
+        for (let fixture of this.fixtures) {
+            await fixture.load(output);
+        }
+    }
+};
+Fixtures = __decorate([
+    injectable(),
+    scoped(Lifecycle.ContainerScoped),
+    __param(0, inject(DI_CONTAINER)),
+    __metadata("design:paramtypes", [Object])
+], Fixtures);
+export { Fixtures };
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/services/gallery-cache.mjs

@@ -0,0 +1,29 @@
+import { __decorate, __metadata } from "tslib";
+import { injectable, Lifecycle, scoped } from "tsyringe";
+import { GalleryImage } from "./gallery-image";
+let GalleryCache = class GalleryCache {
+    imgCache;
+    constructor() {
+        this.imgCache = {};
+    }
+    put(img) {
+        this.imgCache[img.thumb] = img;
+        this.imgCache[img.big] = img;
+    }
+    serve(id) {
+        const img = this.imgCache[id];
+        return !img ? null : img.serve(id);
+    }
+    create(folder, targetSize, handler) {
+        const image = new GalleryImage(folder, targetSize, handler);
+        this.put(image);
+        return image;
+    }
+};
+GalleryCache = __decorate([
+    injectable(),
+    scoped(Lifecycle.ContainerScoped),
+    __metadata("design:paramtypes", [])
+], GalleryCache);
+export { GalleryCache };
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/services/gallery-image.mjs

@@ -0,0 +1,42 @@
+import { v4 as uuidv4 } from "uuid";
+import sharp_ from "sharp";
+const sharp = sharp_;
+const bigSize = 1500;
+const thumbSize = 250;
+export class GalleryImage {
+    folder;
+    handler;
+    thumb;
+    big;
+    targetSize;
+    constructor(folder, size, handler) {
+        this.folder = folder;
+        this.handler = handler;
+        this.thumb = uuidv4();
+        this.big = uuidv4();
+        this.targetSize = !size ? { width: thumbSize, height: thumbSize } : size;
+    }
+    async serve(id) {
+        const isThumb = id == this.thumb;
+        if (await this.handler.hasResult(isThumb)) {
+            return this.handler.serveResult(isThumb);
+        }
+        const original = sharp(await this.handler.getOriginal()).rotate();
+        const meta = await original.metadata();
+        const ratio = meta.width / meta.height;
+        const sizeRatio = isThumb ? this.targetSize.width / this.targetSize.height : 1;
+        const size = isThumb ? Math.max(this.targetSize.width, this.targetSize.height) : bigSize;
+        const targetHeight = ratio > sizeRatio ? size : Math.round(size / ratio);
+        const targetWidth = Math.round(targetHeight * ratio);
+        const resized = original.resize(targetWidth, targetHeight);
+        const buffer = await (isThumb ? resized.extract({
+            left: Math.floor((targetWidth - this.targetSize.width) / 2),
+            top: Math.floor((targetHeight - this.targetSize.height) / 2),
+            width: this.targetSize.width,
+            height: this.targetSize.height
+        }).toBuffer() : resized.toBuffer());
+        await this.handler.writeResult(isThumb, buffer);
+        return this.handler.serveResult(isThumb);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/services/gallery.mjs

@@ -0,0 +1,124 @@
+import { __decorate, __metadata } from "tslib";
+import { injectable, Lifecycle, scoped } from "tsyringe";
+import sharp_ from "sharp";
+import { access, constants, lstat, readdir, readFile, writeFile } from "fs";
+import { join, dirname } from "path";
+import { Configuration } from "./configuration";
+import { GalleryCache } from "./gallery-cache";
+import { mkdirRecursive } from "../utils";
+const sharp = sharp_;
+let Gallery = class Gallery {
+    config;
+    galleryCache;
+    dir;
+    output;
+    cache;
+    constructor(config, galleryCache) {
+        this.config = config;
+        this.galleryCache = galleryCache;
+        this.cache = {};
+        this.dir = this.config.resolve("galleryDir");
+        this.output = join(this.config.resolve("cacheDir"), "gallery");
+    }
+    async getFolder(folder, size = null) {
+        this.cache[folder] = this.cache[folder] || new Promise(resolve => {
+            lstat(join(this.dir, folder), (err, stats) => {
+                if (err || !stats.isDirectory()) {
+                    resolve([]);
+                    return;
+                }
+                this.readRecursive(folder, "", size).then(resolve, () => resolve([]));
+            });
+        });
+        return this.cache[folder];
+    }
+    readRecursive(path, folder, size) {
+        return new Promise(resolve => {
+            readdir(join(this.dir, path), (err, files) => {
+                if (err) {
+                    resolve([]);
+                    return;
+                }
+                const promises = files.map(file => {
+                    return new Promise(async (resolve) => {
+                        const filePath = join(path, file);
+                        const absoluteFilePath = join(this.dir, filePath);
+                        lstat(absoluteFilePath, (err, stats) => {
+                            if (err) {
+                                resolve([]);
+                                return;
+                            }
+                            if (stats.isDirectory()) {
+                                this.readRecursive(filePath, join(folder, file), size).then(resolve);
+                                return;
+                            }
+                            const sharpImg = sharp(absoluteFilePath);
+                            sharpImg.rotate().metadata().then(() => {
+                                const getResultPath = (isThumb) => {
+                                    return join(this.output, filePath.replace(/.([a-z|A-Z]+)$/gi, function (ext) {
+                                        const suffix = isThumb ? 'thumb' : 'big';
+                                        return `-${suffix}${ext}`;
+                                    }));
+                                };
+                                resolve([this.galleryCache.create(folder, size, {
+                                        getOriginal: () => {
+                                            return new Promise((res, rej) => {
+                                                readFile(absoluteFilePath, (err, data) => {
+                                                    if (err) {
+                                                        rej(err);
+                                                        return;
+                                                    }
+                                                    res(data);
+                                                });
+                                            });
+                                        },
+                                        writeResult: (isThumb, buffer) => {
+                                            return new Promise(async (res, rej) => {
+                                                const resultPath = getResultPath(isThumb);
+                                                await mkdirRecursive(dirname(resultPath));
+                                                writeFile(resultPath, buffer, err => {
+                                                    if (err) {
+                                                        rej(err);
+                                                        return;
+                                                    }
+                                                    res();
+                                                });
+                                            });
+                                        },
+                                        hasResult: (isThumb) => {
+                                            return new Promise(res => {
+                                                access(getResultPath(isThumb), constants.R_OK, err => {
+                                                    res(!err);
+                                                });
+                                            });
+                                        },
+                                        serveResult: (isThumb) => {
+                                            return new Promise((res, rej) => {
+                                                readFile(getResultPath(isThumb), (err, data) => {
+                                                    if (err) {
+                                                        rej(err);
+                                                        return;
+                                                    }
+                                                    res(data);
+                                                });
+                                            });
+                                        }
+                                    })]);
+                            }, () => resolve([]));
+                        });
+                    });
+                });
+                Promise.all(promises).then(folders => {
+                    resolve([].concat.apply([], folders));
+                });
+            });
+        });
+    }
+};
+Gallery = __decorate([
+    injectable(),
+    scoped(Lifecycle.ContainerScoped),
+    __metadata("design:paramtypes", [Configuration, GalleryCache])
+], Gallery);
+export { Gallery };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"gallery.js","sourceRoot":"","sources":["../../../src/services/gallery.ts"],"names":[],"mappings":"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","sourcesContent":["import {injectable, Lifecycle, scoped} from \"tsyringe\";\r\nimport sharp_ from \"sharp\";\r\nimport {access, constants, lstat, readdir, readFile, writeFile} from \"fs\";\r\nimport {join, dirname} from \"path\";\r\nimport {IGalleryImage, IGallerySize} from \"../common-types\";\r\nimport {Configuration} from \"./configuration\";\r\nimport {GalleryCache} from \"./gallery-cache\";\r\nimport {mkdirRecursive} from \"../utils\";\r\n\r\nconst sharp = sharp_;\r\n\r\n@injectable()\r\n@scoped(Lifecycle.ContainerScoped)\r\nexport class Gallery {\r\n\r\n    private readonly dir: string;\r\n    private readonly output: string;\r\n    private readonly cache: { [folder: string]: Promise<IGalleryImage[]> };\r\n\r\n    constructor(readonly config: Configuration, readonly galleryCache: GalleryCache) {\r\n        this.cache = {};\r\n        this.dir = this.config.resolve(\"galleryDir\");\r\n        this.output = join(this.config.resolve(\"cacheDir\"), \"gallery\");\r\n    }\r\n\r\n    async getFolder(folder: string, size: IGallerySize = null): Promise<IGalleryImage[]> {\r\n        this.cache[folder] = this.cache[folder] || new Promise<IGalleryImage[]>(resolve => {\r\n            lstat(join(this.dir, folder), (err, stats) => {\r\n                if (err || !stats.isDirectory()) {\r\n                    resolve([]);\r\n                    return;\r\n                }\r\n                this.readRecursive(folder, \"\", size).then(resolve, () => resolve([]));\r\n            });\r\n        });\r\n        return this.cache[folder];\r\n    }\r\n\r\n    protected readRecursive(path: string, folder: string, size: IGallerySize): Promise<IGalleryImage[]> {\r\n        return new Promise<IGalleryImage[]>(resolve => {\r\n            readdir(join(this.dir, path), (err, files) => {\r\n                if (err) {\r\n                    resolve([]);\r\n                    return;\r\n                }\r\n                const promises = files.map(file => {\r\n                    return new Promise<IGalleryImage[]>(async resolve => {\r\n                        const filePath = join(path, file);\r\n                        const absoluteFilePath = join(this.dir, filePath);\r\n                        lstat(absoluteFilePath, (err, stats) => {\r\n                            if (err) {\r\n                                resolve([]);\r\n                                return;\r\n                            }\r\n                            if (stats.isDirectory()) {\r\n                                this.readRecursive(filePath, join(folder, file), size).then(resolve);\r\n                                return;\r\n                            }\r\n                            const sharpImg = sharp(absoluteFilePath);\r\n                            sharpImg.rotate().metadata().then(() => {\r\n                                const getResultPath = (isThumb) => {\r\n                                    return join(this.output, filePath.replace(/.([a-z|A-Z]+)$/gi, function (ext) {\r\n                                        const suffix = isThumb ? 'thumb' : 'big';\r\n                                        return `-${suffix}${ext}`;\r\n                                    }));\r\n                                };\r\n                                resolve([this.galleryCache.create(folder, size, {\r\n                                    getOriginal: () => {\r\n                                        return new Promise<Buffer>((res, rej) => {\r\n                                            readFile(absoluteFilePath, (err, data) => {\r\n                                                if (err) {\r\n                                                    rej(err);\r\n                                                    return;\r\n                                                }\r\n                                                res(data);\r\n                                            });\r\n                                        });\r\n                                    },\r\n                                    writeResult: (isThumb: boolean, buffer: Buffer) => {\r\n                                        return new Promise<void>(async (res, rej) => {\r\n                                            const resultPath = getResultPath(isThumb);\r\n                                            await mkdirRecursive(dirname(resultPath));\r\n                                            writeFile(resultPath, buffer, err => {\r\n                                                if (err) {\r\n                                                    rej(err);\r\n                                                    return;\r\n                                                }\r\n                                                res();\r\n                                            });\r\n                                        });\r\n                                    },\r\n                                    hasResult: (isThumb: boolean) => {\r\n                                        return new Promise<boolean>(res => {\r\n                                            access(getResultPath(isThumb), constants.R_OK, err => {\r\n                                                res(!err);\r\n                                            });\r\n                                        });\r\n                                    },\r\n                                    serveResult: (isThumb: boolean) => {\r\n                                        return new Promise<Buffer>((res, rej) => {\r\n                                            readFile(getResultPath(isThumb), (err, data) => {\r\n                                                if (err) {\r\n                                                    rej(err);\r\n                                                    return;\r\n                                                }\r\n                                                res(data);\r\n                                            });\r\n                                        });\r\n                                    }\r\n                                })]);\r\n                            }, () => resolve([]));\r\n                        });\r\n                    });\r\n                });\r\n                Promise.all(promises).then(folders => {\r\n                    resolve([].concat.apply([], folders));\r\n                });\r\n            });\r\n        });\r\n    }\r\n}\r\n"]}

package/esm2022/services/id-generator.mjs

@@ -0,0 +1,49 @@
+import { __decorate, __metadata } from "tslib";
+import { injectable, Lifecycle, scoped } from "tsyringe";
+import { Configuration } from "./configuration";
+import { rand } from "../utils";
+let IdGenerator = class IdGenerator {
+    config;
+    prefix;
+    separator;
+    chars;
+    parts;
+    constructor(config) {
+        this.config = config;
+        this.prefix = config.resolve("idPrefix");
+        this.separator = config.resolve("idSeparator");
+        this.chars = config.resolve("idChars");
+        this.parts = config.resolve("idParts");
+    }
+    async generate(checkCb) {
+        let id = null;
+        let tries = 0;
+        let notGood = true;
+        while (notGood && tries < 5) {
+            id = this.generateId();
+            notGood = await checkCb(id);
+            tries++;
+        }
+        if (notGood) {
+            throw `Couldn't generate an unique id..`;
+        }
+        return id;
+    }
+    generateId() {
+        return this.prefix + this.parts.map(num => {
+            let s = "";
+            for (let i = 0; i < num; i++) {
+                const ix = rand(0, this.chars.length - 1);
+                s += this.chars[ix];
+            }
+            return s;
+        }).join(this.separator);
+    }
+};
+IdGenerator = __decorate([
+    injectable(),
+    scoped(Lifecycle.ContainerScoped),
+    __metadata("design:paramtypes", [Configuration])
+], IdGenerator);
+export { IdGenerator };
+//# sourceMappingURL=data:application/json;base64,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