@tstdl/base 0.90.47 → 0.90.48

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.90.47",
+  "version": "0.90.48",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -106,7 +106,7 @@
   "dependencies": {
     "disposablestack": "^1.1",
     "luxon": "^3.4",
-    "reflect-metadata": "^0.1",
+    "reflect-metadata": "^0.2",
     "rxjs": "^7.8",
     "type-fest": "4.7"
   },
@@ -119,11 +119,11 @@
     "@types/mjml": "4.7",
     "@types/node": "20",
     "@types/nodemailer": "6.4",
-    "@typescript-eslint/eslint-plugin": "6.12",
-    "@typescript-eslint/parser": "6.12",
+    "@typescript-eslint/eslint-plugin": "6.14",
+    "@typescript-eslint/parser": "6.14",
     "concurrently": "8.2",
     "esbuild": "0.19",
-    "eslint": "8.54",
+    "eslint": "8.55",
     "eslint-import-resolver-typescript": "3.6",
     "eslint-plugin-import": "2.29",
     "tsc-alias": "1.8",
@@ -132,7 +132,7 @@
     "typescript": "5.3"
   },
   "peerDependencies": {
-    "@elastic/elasticsearch": "^8.10",
+    "@elastic/elasticsearch": "^8.11",
     "@koa/router": "^12.0",
     "@tstdl/angular": "^0.90",
     "@zxcvbn-ts/core": "^3.0",
@@ -149,7 +149,7 @@
     "playwright": "^1.40",
     "preact": "^10.19",
     "preact-render-to-string": "^6.3",
-    "undici": "^5.27",
+    "undici": "^6.0",
     "urlpattern-polyfill": "^9.0"
   },
   "peerDependenciesMeta": {

package/pdf/pdf.service.d.ts

@@ -5,14 +5,12 @@
  */
 import { BrowserContextController } from '../browser/browser-context-controller.js';
 import type { BrowserControllerArgument } from '../browser/browser-controller.js';
-import { BrowserController } from '../browser/browser-controller.js';
 import { PdfRenderOptions } from '../browser/pdf-options.js';
 import type { Resolvable } from '../injector/index.js';
 import { resolveArgumentType } from '../injector/index.js';
 import { LogLevel } from '../logger/level.js';
-import { Logger } from '../logger/logger.js';
 import type { TemplateField } from '../templates/index.js';
-import { Template, TemplateService } from '../templates/index.js';
+import { Template } from '../templates/index.js';
 export declare class PdfServiceRenderOptions extends PdfRenderOptions {
     browserContext?: BrowserContextController;
     locale?: string;
@@ -50,7 +48,6 @@ export declare class PdfService implements Resolvable<PdfServiceArgument> {
     private readonly logger;
     private readonly defaultLocale;
     readonly [resolveArgumentType]: PdfServiceArgument;
-    constructor(templateService: TemplateService, browserController: BrowserController, logger: Logger, options?: PdfServiceOptions);
     /**
      * Renders HTML to pdf stream
      * @param html html to render
@@ -95,6 +92,7 @@ export declare class PdfService implements Resolvable<PdfServiceArgument> {
      * @returns pdf bytes
      */
     renderTemplate(keyOrTemplate: string | PdfTemplate, templateContext?: object, options?: PdfServiceRenderOptions): Promise<Uint8Array>;
+    merge(pdfs: (string | Uint8Array)[]): Promise<Uint8Array>;
     private renderStream;
 }
 export declare function pdfTemplate(name: string, fields: {

package/pdf/pdf.service.js

@@ -12,13 +12,59 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-var __param = (this && this.__param) || function (paramIndex, decorator) {
-    return function (target, key) { decorator(target, key, paramIndex); }
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
 };
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        function next() {
+            while (env.stack.length) {
+                var rec = env.stack.pop();
+                try {
+                    var result = rec.dispose && rec.dispose.call(rec.value);
+                    if (rec.async) return Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+import { execFile as execFileCallback } from 'node:child_process';
+import { access, readFile, unlink, writeFile } from 'node:fs/promises';
+import { promisify } from 'node:util';
+import { tmpdir } from 'node:os';
 import { BrowserContextController } from '../browser/browser-context-controller.js';
 import { BrowserController } from '../browser/browser-controller.js';
 import { PdfRenderOptions } from '../browser/pdf-options.js';
-import { ForwardArg, InjectArg, ResolveArg, Singleton, resolveArgumentType } from '../injector/index.js';
+import { Singleton, inject, injectArgument, resolveArgumentType } from '../injector/index.js';
 import { LogLevel } from '../logger/level.js';
 import { Logger } from '../logger/logger.js';
 import { Optional } from '../schema/index.js';
@@ -27,7 +73,8 @@ import { finalizeStream } from '../utils/stream/finalize-stream.js';
 import { readableStreamFromPromise } from '../utils/stream/readable-stream-from-promise.js';
 import { readBinaryStream } from '../utils/stream/stream-reader.js';
 import { timeout } from '../utils/timing.js';
-import { isDefined } from '../utils/type-guards.js';
+import { isDefined, isString } from '../utils/type-guards.js';
+const execFile = promisify(execFileCallback);
 export class PdfServiceRenderOptions extends PdfRenderOptions {
     browserContext;
     locale;
@@ -73,16 +120,10 @@ __decorate([
 ], PdfTemplate.prototype, "options", void 0);
 const browserArguments = ['--font-render-hinting=none', '--disable-web-security', '--disable-features=IsolateOrigins', '--disable-site-isolation-trials'];
 let PdfService = class PdfService {
-    templateService;
-    browserController;
-    logger;
-    defaultLocale;
-    constructor(templateService, browserController, logger, options = {}) {
-        this.templateService = templateService;
-        this.browserController = browserController;
-        this.logger = logger;
-        this.defaultLocale = options.locale;
-    }
+    templateService = inject(TemplateService);
+    browserController = inject(BrowserController, injectArgument(this, { optional: true })?.browserControllerArgument ?? { browserArguments });
+    logger = inject(Logger, 'PdfService');
+    defaultLocale = injectArgument(this, { optional: true })?.locale;
     /**
      * Renders HTML to pdf stream
      * @param html html to render
@@ -148,6 +189,43 @@ let PdfService = class PdfService {
         const stream = this.renderTemplateStream(keyOrTemplate, templateContext, options);
         return readBinaryStream(stream);
     }
+    async merge(pdfs) {
+        const env_1 = { stack: [], error: void 0, hasError: false };
+        try {
+            const stack = __addDisposableResource(env_1, new AsyncDisposableStack(), true);
+            const tmp = tmpdir();
+            const sourceFiles = await Promise.all(pdfs.map(async (pdf) => {
+                if (isString(pdf)) {
+                    return pdf;
+                }
+                const file = `${tmp}/${crypto.randomUUID()}.pdf`;
+                await writeFile(file, pdf);
+                stack.defer(async () => unlink(file));
+                return file;
+            }));
+            const resultFile = `${tmp}/${crypto.randomUUID()}.pdf`;
+            const resultPromise = execFile('pdfunite', [...sourceFiles, resultFile]);
+            const result = await resultPromise;
+            try {
+                await access(resultFile);
+                stack.defer(async () => unlink(resultFile));
+            }
+            catch { /* ignore */ }
+            if (resultPromise.child.exitCode != 0) {
+                throw new Error(result.stderr);
+            }
+            return readFile(resultFile);
+        }
+        catch (e_1) {
+            env_1.error = e_1;
+            env_1.hasError = true;
+        }
+        finally {
+            const result_1 = __disposeResources(env_1);
+            if (result_1)
+                await result_1;
+        }
+    }
     renderStream(handler, options = {}) {
         return readableStreamFromPromise(async () => {
             const context = options.browserContext ?? await this.browserController.newContext({ locale: options.locale ?? this.defaultLocale });
@@ -180,13 +258,7 @@ let PdfService = class PdfService {
     }
 };
 PdfService = __decorate([
-    Singleton(),
-    __param(1, ForwardArg((argument) => argument?.browserControllerArgument ?? { browserArguments })),
-    __param(2, ResolveArg('PdfService')),
-    __param(3, InjectArg()),
-    __metadata("design:paramtypes", [TemplateService,
-        BrowserController,
-        Logger, Object])
+    Singleton()
 ], PdfService);
 export { PdfService };
 export function pdfTemplate(name, fields, options) {

package/reflection/decorators.d.ts

@@ -1,4 +1,4 @@
-import 'reflect-metadata';
+import 'reflect-metadata/lite';
 import type { ConstructorParameterDecorator } from '../types.js';
 import type { Decorator, DecoratorHandler } from './types.js';
 import type { CreateDecoratorOptions, SpecificCreateDecoratorOptions } from './utils.js';

package/reflection/decorators.js

@@ -1,5 +1,5 @@
 /* eslint-disable @typescript-eslint/naming-convention */
-import 'reflect-metadata'; // eslint-disable-line import/no-unassigned-import
+import 'reflect-metadata/lite'; // eslint-disable-line import/no-unassigned-import
 import { noop } from '../utils/noop.js';
 import { createAccessorDecorator, createClassDecorator, createConstructorParameterDecorator, createDecorator, createMethodDecorator, createMethodParameterDecorator, createParameterDecorator, createPropertyDecorator, createPropertyOrAccessorDecorator } from './utils.js';
 export function Decorate({ handler, ...options } = {}) {

package/templates/template-renderer.provider.d.ts

@@ -1,7 +1,7 @@
 import type { TemplateRenderer } from './template.renderer.js';
 export declare class TemplateRendererProvider {
     private readonly renderers;
-    constructor(renderers: TemplateRenderer[]);
+    constructor(renderers?: TemplateRenderer[]);
     register(renderer: TemplateRenderer): void;
     has(type: string): boolean;
     get(type: string): TemplateRenderer;

package/templates/template-renderer.provider.js

@@ -10,11 +10,11 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
-import { Inject, Singleton } from '../injector/decorators.js';
+import { Inject, Optional, Singleton } from '../injector/decorators.js';
 import { TEMPLATE_RENDERERS } from './tokens.js';
 let TemplateRendererProvider = class TemplateRendererProvider {
     renderers;
-    constructor(renderers) {
+    constructor(renderers = []) {
         this.renderers = new Set(renderers);
     }
     register(renderer) {
@@ -40,6 +40,7 @@ let TemplateRendererProvider = class TemplateRendererProvider {
 TemplateRendererProvider = __decorate([
     Singleton(),
     __param(0, Inject(TEMPLATE_RENDERERS)),
+    __param(0, Optional()),
     __metadata("design:paramtypes", [Array])
 ], TemplateRendererProvider);
 export { TemplateRendererProvider };

package/templates/template-resolver.provider.d.ts

@@ -1,7 +1,7 @@
 import type { TemplateResolver } from './template.resolver.js';
 export declare class TemplateResolverProvider {
     private readonly resolvers;
-    constructor(resolvers: TemplateResolver[]);
+    constructor(resolvers?: TemplateResolver[]);
     register(renderer: TemplateResolver): void;
     has(type: string): boolean;
     get(type: string): TemplateResolver;

package/templates/template-resolver.provider.js

@@ -10,11 +10,11 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
-import { Inject, Singleton } from '../injector/decorators.js';
+import { Inject, Optional, Singleton } from '../injector/decorators.js';
 import { TEMPLATE_RESOLVERS } from './tokens.js';
 let TemplateResolverProvider = class TemplateResolverProvider {
     resolvers;
-    constructor(resolvers) {
+    constructor(resolvers = []) {
         this.resolvers = new Set(resolvers);
     }
     register(renderer) {
@@ -40,6 +40,7 @@ let TemplateResolverProvider = class TemplateResolverProvider {
 TemplateResolverProvider = __decorate([
     Singleton(),
     __param(0, Inject(TEMPLATE_RESOLVERS)),
+    __param(0, Optional()),
     __metadata("design:paramtypes", [Array])
 ], TemplateResolverProvider);
 export { TemplateResolverProvider };

package/utils/date-time.js

@@ -96,7 +96,11 @@ export function numericDateToDateTime(numericDate, units, options) {
     return DateTime.fromObject({ ...date, ...units }, options);
 }
 export function dateTimeToTime(dateTime) {
-    return dateTime.startOf('day').until(dateTime).count('milliseconds');
+    const interval = dateTime.startOf('day').until(dateTime);
+    if (interval.isValid) {
+        return interval.count('milliseconds');
+    }
+    throw new Error('Invalid DateTime.');
 }
 export function numericDateTimeToDateTime({ date, time }, zone) {
     return numericDateToDateTime(date, undefined, { zone }).set({ millisecond: time });

package/utils/reflection.d.ts

@@ -1,4 +1,4 @@
-import 'reflect-metadata';
+import 'reflect-metadata/lite';
 import type { Type } from '../types.js';
 export declare function getDesignType(target: object, propertyKey?: string | symbol): Type;
 export declare function hasDesignType(target: object, propertyKey?: string | symbol): boolean;

package/utils/reflection.js

@@ -1,4 +1,4 @@
-import 'reflect-metadata'; // eslint-disable-line import/no-unassigned-import
+import 'reflect-metadata/lite'; // eslint-disable-line import/no-unassigned-import
 export function getDesignType(target, propertyKey) {
     return Reflect.getMetadata('design:type', target, propertyKey);
 }