@tstdl/base 0.86.0-beta2 → 0.86.0-beta3

package/sse/model.js

@@ -1 +1,16 @@
-export {};
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var model_exports = {};
+module.exports = __toCommonJS(model_exports);

package/sse/server-sent-events-source.js

@@ -1,61 +1,83 @@
-import { isDefined } from '../utils/type-guards.js';
-export class ServerSentEventsSource {
-    writable;
-    writer;
-    _closed;
-    _error;
-    readable;
-    get closed() {
-        return this._closed;
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var server_sent_events_source_exports = {};
+__export(server_sent_events_source_exports, {
+  ServerSentEventsSource: () => ServerSentEventsSource
+});
+module.exports = __toCommonJS(server_sent_events_source_exports);
+var import_type_guards = require("../utils/type-guards.js");
+class ServerSentEventsSource {
+  writable;
+  writer;
+  _closed;
+  _error;
+  readable;
+  get closed() {
+    return this._closed;
+  }
+  get error() {
+    return this._error;
+  }
+  constructor() {
+    const { writable, readable } = new TransformStream();
+    this.writable = writable;
+    this.readable = readable;
+    this._closed = false;
+    this._error = void 0;
+    this.writer = this.writable.getWriter();
+    this.writer.closed.then(() => this._closed = true).catch((error) => this._error = error);
+  }
+  async close() {
+    await this.writer.close();
+  }
+  async sendComment(comment) {
+    const text = formatText(comment, "");
+    await this.writer.write(text);
+  }
+  async sendText({ name, data, id, retry }) {
+    let message = "";
+    if ((0, import_type_guards.isDefined)(name)) {
+      message += formatText(name, "event");
     }
-    get error() {
-        return this._error;
+    if ((0, import_type_guards.isDefined)(data)) {
+      message += formatText(data, "data");
     }
-    constructor() {
-        const { writable, readable } = new TransformStream();
-        this.writable = writable;
-        this.readable = readable;
-        this._closed = false;
-        this._error = undefined;
-        this.writer = this.writable.getWriter();
-        this.writer.closed
-            .then(() => (this._closed = true))
-            .catch((error) => (this._error = error));
+    if ((0, import_type_guards.isDefined)(id)) {
+      message += formatText(id, "id");
     }
-    async close() {
-        await this.writer.close();
-    }
-    async sendComment(comment) {
-        const text = formatText(comment, '');
-        await this.writer.write(text);
-    }
-    async sendText({ name, data, id, retry }) {
-        let message = '';
-        if (isDefined(name)) {
-            message += formatText(name, 'event');
-        }
-        if (isDefined(data)) {
-            message += formatText(data, 'data');
-        }
-        if (isDefined(id)) {
-            message += formatText(id, 'id');
-        }
-        if (isDefined(retry)) {
-            message += formatText(retry.toString(), 'retry');
-        }
-        message += '\n';
-        await this.writer.write(message);
-    }
-    async sendJson({ name, data, id, retry }) {
-        return this.sendText({
-            name,
-            data: JSON.stringify(data),
-            id,
-            retry
-        });
+    if ((0, import_type_guards.isDefined)(retry)) {
+      message += formatText(retry.toString(), "retry");
     }
+    message += "\n";
+    await this.writer.write(message);
+  }
+  async sendJson({ name, data, id, retry }) {
+    return this.sendText({
+      name,
+      data: JSON.stringify(data),
+      id,
+      retry
+    });
+  }
 }
 function formatText(text, type) {
-    const formatted = text.split('\n').map((line) => `${type}: ${line}`).join('\n');
-    return `${formatted}\n`;
+  const formatted = text.split("\n").map((line) => `${type}: ${line}`).join("\n");
+  return `${formatted}
+`;
 }

package/sse/server-sent-events.js

@@ -1,51 +1,75 @@
-import { NotSupportedError } from '../error/not-supported.error.js';
-import { distinctUntilChanged, filter, fromEvent, map, merge, ReplaySubject, share, shareReplay, startWith, takeUntil } from 'rxjs';
-export var ServerSentEventsState;
-(function (ServerSentEventsState) {
-    ServerSentEventsState[ServerSentEventsState["Connecting"] = 0] = "Connecting";
-    ServerSentEventsState[ServerSentEventsState["Open"] = 1] = "Open";
-    ServerSentEventsState[ServerSentEventsState["Closed"] = 2] = "Closed";
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var server_sent_events_exports = {};
+__export(server_sent_events_exports, {
+  ServerSentEvents: () => ServerSentEvents,
+  ServerSentEventsState: () => ServerSentEventsState
+});
+module.exports = __toCommonJS(server_sent_events_exports);
+var import_not_supported_error = require("../error/not-supported.error.js");
+var import_rxjs = require("rxjs");
+var ServerSentEventsState;
+(function(ServerSentEventsState2) {
+  ServerSentEventsState2[ServerSentEventsState2["Connecting"] = 0] = "Connecting";
+  ServerSentEventsState2[ServerSentEventsState2["Open"] = 1] = "Open";
+  ServerSentEventsState2[ServerSentEventsState2["Closed"] = 2] = "Closed";
 })(ServerSentEventsState || (ServerSentEventsState = {}));
-export class ServerSentEvents {
-    eventSource;
-    closeSubject;
-    open$;
-    close$;
-    error$;
-    state$;
-    isConnecting$;
-    isOpen$;
-    isClosed$;
-    get state() {
-        switch (this.eventSource.readyState) {
-            case EventSource.CONNECTING:
-                return ServerSentEventsState.Connecting;
-            case EventSource.OPEN:
-                return ServerSentEventsState.Open;
-            case EventSource.CLOSED:
-                return ServerSentEventsState.Closed;
-            default:
-                throw new NotSupportedError(`Unknown EventSource readyState ${this.eventSource.readyState}`);
-        }
-    }
-    constructor(url, options) {
-        this.eventSource = new EventSource(url, options);
-        this.closeSubject = new ReplaySubject(1);
-        const open$ = fromEvent(this.eventSource, 'open');
-        this.close$ = this.closeSubject.asObservable();
-        this.error$ = fromEvent(this.eventSource, 'error').pipe(takeUntil(this.close$), share());
-        this.state$ = merge(open$, this.error$, this.close$).pipe(startWith(undefined), map(() => this.state), distinctUntilChanged(), shareReplay({ bufferSize: 1, refCount: true }));
-        this.isConnecting$ = this.state$.pipe(map((state) => state == ServerSentEventsState.Connecting), shareReplay({ bufferSize: 1, refCount: true }));
-        this.isOpen$ = this.state$.pipe(map((state) => state == ServerSentEventsState.Open), shareReplay({ bufferSize: 1, refCount: true }));
-        this.isClosed$ = this.state$.pipe(map((state) => state == ServerSentEventsState.Closed), shareReplay({ bufferSize: 1, refCount: true }));
-        this.open$ = this.isOpen$.pipe(filter((open) => open), map(() => undefined), takeUntil(this.close$), share());
-    }
-    message$(event) {
-        return fromEvent(this.eventSource, event ?? 'message').pipe(takeUntil(this.close$));
-    }
-    close() {
-        this.eventSource.close();
-        this.closeSubject.next();
-        this.closeSubject.complete();
+class ServerSentEvents {
+  eventSource;
+  closeSubject;
+  open$;
+  close$;
+  error$;
+  state$;
+  isConnecting$;
+  isOpen$;
+  isClosed$;
+  get state() {
+    switch (this.eventSource.readyState) {
+      case EventSource.CONNECTING:
+        return ServerSentEventsState.Connecting;
+      case EventSource.OPEN:
+        return ServerSentEventsState.Open;
+      case EventSource.CLOSED:
+        return ServerSentEventsState.Closed;
+      default:
+        throw new import_not_supported_error.NotSupportedError(`Unknown EventSource readyState ${this.eventSource.readyState}`);
     }
+  }
+  constructor(url, options) {
+    this.eventSource = new EventSource(url, options);
+    this.closeSubject = new import_rxjs.ReplaySubject(1);
+    const open$ = (0, import_rxjs.fromEvent)(this.eventSource, "open");
+    this.close$ = this.closeSubject.asObservable();
+    this.error$ = (0, import_rxjs.fromEvent)(this.eventSource, "error").pipe((0, import_rxjs.takeUntil)(this.close$), (0, import_rxjs.share)());
+    this.state$ = (0, import_rxjs.merge)(open$, this.error$, this.close$).pipe((0, import_rxjs.startWith)(void 0), (0, import_rxjs.map)(() => this.state), (0, import_rxjs.distinctUntilChanged)(), (0, import_rxjs.shareReplay)({ bufferSize: 1, refCount: true }));
+    this.isConnecting$ = this.state$.pipe((0, import_rxjs.map)((state) => state == ServerSentEventsState.Connecting), (0, import_rxjs.shareReplay)({ bufferSize: 1, refCount: true }));
+    this.isOpen$ = this.state$.pipe((0, import_rxjs.map)((state) => state == ServerSentEventsState.Open), (0, import_rxjs.shareReplay)({ bufferSize: 1, refCount: true }));
+    this.isClosed$ = this.state$.pipe((0, import_rxjs.map)((state) => state == ServerSentEventsState.Closed), (0, import_rxjs.shareReplay)({ bufferSize: 1, refCount: true }));
+    this.open$ = this.isOpen$.pipe((0, import_rxjs.filter)((open) => open), (0, import_rxjs.map)(() => void 0), (0, import_rxjs.takeUntil)(this.close$), (0, import_rxjs.share)());
+  }
+  message$(event) {
+    return (0, import_rxjs.fromEvent)(this.eventSource, event ?? "message").pipe((0, import_rxjs.takeUntil)(this.close$));
+  }
+  close() {
+    this.eventSource.close();
+    this.closeSubject.next();
+    this.closeSubject.complete();
+  }
 }

package/supports.js

@@ -1,5 +1,32 @@
-export const supportsReadableStream = (typeof ReadableStream == 'function');
-export const supportsBlob = (typeof Blob == 'function');
-export const supportsBuffer = (typeof Buffer == 'function');
-export const supportsStructuredClone = (typeof structuredClone == 'function');
-export const supportsNotification = (typeof Notification == 'function');
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var supports_exports = {};
+__export(supports_exports, {
+  supportsBlob: () => supportsBlob,
+  supportsBuffer: () => supportsBuffer,
+  supportsNotification: () => supportsNotification,
+  supportsReadableStream: () => supportsReadableStream,
+  supportsStructuredClone: () => supportsStructuredClone
+});
+module.exports = __toCommonJS(supports_exports);
+const supportsReadableStream = typeof ReadableStream == "function";
+const supportsBlob = typeof Blob == "function";
+const supportsBuffer = typeof Buffer == "function";
+const supportsStructuredClone = typeof structuredClone == "function";
+const supportsNotification = typeof Notification == "function";

package/templates/index.js

@@ -1,9 +1,26 @@
-export * from './module.js';
-export * from './template-renderer.provider.js';
-export * from './template-resolver.provider.js';
-export * from './template.model.js';
-export * from './template.provider.js';
-export * from './template.renderer.js';
-export * from './template.resolver.js';
-export * from './template.service.js';
-export * from './tokens.js';
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var templates_exports = {};
+module.exports = __toCommonJS(templates_exports);
+__reExport(templates_exports, require("./module.js"), module.exports);
+__reExport(templates_exports, require("./template-renderer.provider.js"), module.exports);
+__reExport(templates_exports, require("./template-resolver.provider.js"), module.exports);
+__reExport(templates_exports, require("./template.model.js"), module.exports);
+__reExport(templates_exports, require("./template.provider.js"), module.exports);
+__reExport(templates_exports, require("./template.renderer.js"), module.exports);
+__reExport(templates_exports, require("./template.resolver.js"), module.exports);
+__reExport(templates_exports, require("./template.service.js"), module.exports);
+__reExport(templates_exports, require("./tokens.js"), module.exports);

package/templates/module.d.ts

@@ -1,7 +1,7 @@
 import type { Type } from '../types.js';
 import { TemplateProvider } from './template.provider.js';
-import type { TemplateRenderer } from './template.renderer.js';
-import type { TemplateResolver } from './template.resolver.js';
+import { TemplateRenderer } from './template.renderer.js';
+import { TemplateResolver } from './template.resolver.js';
 export type TemplateModuleConfig = {
     templateProvider: Type<TemplateProvider> | undefined;
     templateResolvers: Type<TemplateResolver>[];

package/templates/module.js

@@ -1,43 +1,50 @@
-import { container } from '../container/index.js';
-import { isDefined } from '../utils/type-guards.js';
-import { StringTemplateRenderer } from './renderers/string.template-renderer.js';
-import { StringTemplateResolver } from './resolvers/string.template-resolver.js';
-import { TemplateProvider } from './template.provider.js';
-import { TEMPLATE_RENDERERS, TEMPLATE_RESOLVERS } from './tokens.js';
-export const templateModuleConfig = {
-    templateProvider: undefined,
-    templateResolvers: [StringTemplateResolver],
-    templateRenderers: [StringTemplateRenderer]
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-container.registerSingleton(TEMPLATE_RESOLVERS, {
-    useFactory: (_, context) => {
-        if (context.isAsync) {
-            return (async () => {
-                const resolves = templateModuleConfig.templateResolvers.map(async (type) => context.resolveAsync(type));
-                return Promise.all(resolves);
-            })();
-        }
-        return templateModuleConfig.templateResolvers.map((type) => context.resolve(type));
-    }
-});
-container.registerSingleton(TEMPLATE_RENDERERS, {
-    useFactory: (_, context) => {
-        if (context.isAsync) {
-            return (async () => {
-                const resolves = templateModuleConfig.templateRenderers.map(async (type) => context.resolveAsync(type));
-                return Promise.all(resolves);
-            })();
-        }
-        return templateModuleConfig.templateRenderers.map((type) => context.resolve(type));
-    }
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var module_exports = {};
+__export(module_exports, {
+  configureTemplates: () => configureTemplates,
+  templateModuleConfig: () => templateModuleConfig
 });
-/**
- * configure mail module
- */
-export function configureTemplates(config = {}) {
-    if (isDefined(config.templateProvider)) {
-        container.registerSingleton(TemplateProvider, { useToken: config.templateProvider });
-    }
-    templateModuleConfig.templateResolvers = [...new Set([...templateModuleConfig.templateResolvers, ...(config.templateResolvers ?? [])])];
-    templateModuleConfig.templateRenderers = [...new Set([...templateModuleConfig.templateRenderers, ...(config.templateRenderers ?? [])])];
+module.exports = __toCommonJS(module_exports);
+var import_injector = require("../injector/injector.js");
+var import_type_guards = require("../utils/type-guards.js");
+var import_string_template_renderer = require("./renderers/string.template-renderer.js");
+var import_string_template_resolver = require("./resolvers/string.template-resolver.js");
+var import_template_provider = require("./template.provider.js");
+var import_template_renderer = require("./template.renderer.js");
+var import_template_resolver = require("./template.resolver.js");
+var import_tokens = require("./tokens.js");
+const templateModuleConfig = {
+  templateProvider: void 0,
+  templateResolvers: [import_string_template_resolver.StringTemplateResolver],
+  templateRenderers: [import_string_template_renderer.StringTemplateRenderer]
+};
+import_injector.Injector.registerSingleton(import_tokens.TEMPLATE_RESOLVERS, { useToken: import_template_resolver.TemplateResolver, resolveAll: true });
+import_injector.Injector.registerSingleton(import_tokens.TEMPLATE_RENDERERS, { useToken: import_template_renderer.TemplateRenderer, resolveAll: true });
+function configureTemplates(config = {}) {
+  if ((0, import_type_guards.isDefined)(config.templateProvider)) {
+    import_injector.Injector.registerSingleton(import_template_provider.TemplateProvider, { useToken: config.templateProvider });
+  }
+  if ((0, import_type_guards.isDefined)(config.templateResolvers)) {
+    import_injector.Injector.register(import_template_resolver.TemplateResolver, config.templateResolvers.map((resolver) => ({ useToken: resolver })));
+  }
+  if ((0, import_type_guards.isDefined)(config.templateRenderers)) {
+    import_injector.Injector.register(import_template_renderer.TemplateRenderer, config.templateRenderers.map((renderer) => ({ useToken: renderer })));
+  }
 }

package/templates/providers/file.template-provider.d.ts

@@ -1,5 +1,5 @@
-import type { Injectable } from '../../container/index.js';
-import { type resolveArgumentType } from '../../container/index.js';
+import type { Resolvable } from '../../injector/interfaces.js';
+import { resolveArgumentType } from '../../injector/interfaces.js';
 import { Template } from '../template.model.js';
 import { TemplateProvider } from '../template.provider.js';
 export type FileTemplateProviderConfig = {
@@ -7,7 +7,7 @@ export type FileTemplateProviderConfig = {
 };
 export type FileTemplateProviderArgument = string;
 export declare const fileTemplateProviderConfig: FileTemplateProviderConfig;
-export declare class FileTemplateProvider extends TemplateProvider implements Injectable<FileTemplateProviderArgument> {
+export declare class FileTemplateProvider extends TemplateProvider implements Resolvable<FileTemplateProviderArgument> {
     private readonly basePath;
     readonly [resolveArgumentType]: FileTemplateProviderArgument;
     constructor(basePath: string);

package/templates/providers/file.template-provider.js

@@ -1,49 +1,92 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
-var __param = (this && this.__param) || function (paramIndex, decorator) {
-    return function (target, key) { decorator(target, key, paramIndex); }
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var file_template_provider_exports = {};
+__export(file_template_provider_exports, {
+  FileTemplateProvider: () => FileTemplateProvider,
+  configureFileTemplateProvider: () => configureFileTemplateProvider,
+  fileTemplateProviderConfig: () => fileTemplateProviderConfig
+});
+module.exports = __toCommonJS(file_template_provider_exports);
+var path = __toESM(require("node:path"), 1);
+var import_bad_request_error = require("../../error/bad-request.error.js");
+var import_decorators = require("../../injector/decorators.js");
+var import_interfaces = require("../../injector/interfaces.js");
+var import_schema = require("../../schema/index.js");
+var import_template_model = require("../template.model.js");
+var import_template_provider = require("../template.provider.js");
+var __decorate = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1; i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-import { injectArg, singleton } from '../../container/index.js';
-import { BadRequestError } from '../../error/bad-request.error.js';
-import { Schema } from '../../schema/index.js';
-import * as path from 'node:path';
-import { Template } from '../template.model.js';
-import { TemplateProvider } from '../template.provider.js';
-export const fileTemplateProviderConfig = {};
+var __metadata = function(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+var __param = function(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+};
+const fileTemplateProviderConfig = {};
 const keyPattern = /^[\w\-/]+$/u;
-export let FileTemplateProvider = class FileTemplateProvider extends TemplateProvider {
-    basePath;
-    constructor(basePath) {
-        super();
-        this.basePath = path.resolve(basePath);
+let FileTemplateProvider = class FileTemplateProvider2 extends import_template_provider.TemplateProvider {
+  basePath;
+  constructor(basePath) {
+    super();
+    this.basePath = path.resolve(basePath);
+  }
+  async get(key) {
+    if (!keyPattern.test(key)) {
+      throw new import_bad_request_error.BadRequestError("Illegal template key. Only a-z, A-Z, 0-9, _ and - are allowed.");
     }
-    async get(key) {
-        if (!keyPattern.test(key)) {
-            throw new BadRequestError('Illegal template key. Only a-z, A-Z, 0-9, _ and - are allowed.');
-        }
-        const filePath = path.resolve(this.basePath, `${key}.js`);
-        if (!filePath.startsWith(this.basePath)) {
-            throw new BadRequestError(`Illegal file path. Must be inside "${this.basePath}".`);
-        }
-        const templateModule = await import(filePath);
-        const fileContent = templateModule.template ?? templateModule.default;
-        return Schema.parse(Template, fileContent);
+    const filePath = path.resolve(this.basePath, `${key}.js`);
+    if (!filePath.startsWith(this.basePath)) {
+      throw new import_bad_request_error.BadRequestError(`Illegal file path. Must be inside "${this.basePath}".`);
     }
+    const templateModule = await import(filePath);
+    const fileContent = templateModule.template ?? templateModule.default;
+    return import_schema.Schema.parse(import_template_model.Template, fileContent);
+  }
 };
 FileTemplateProvider = __decorate([
-    singleton({
-        defaultArgumentProvider: () => fileTemplateProviderConfig.basePath
-    }),
-    __param(0, injectArg()),
-    __metadata("design:paramtypes", [String])
+  (0, import_decorators.Singleton)({
+    defaultArgumentProvider: () => fileTemplateProviderConfig.basePath
+  }),
+  __param(0, (0, import_decorators.InjectArg)()),
+  __metadata("design:paramtypes", [String])
 ], FileTemplateProvider);
-export function configureFileTemplateProvider(config = {}) {
-    fileTemplateProviderConfig.basePath = config.basePath ?? fileTemplateProviderConfig.basePath;
+function configureFileTemplateProvider(config = {}) {
+  fileTemplateProviderConfig.basePath = config.basePath ?? fileTemplateProviderConfig.basePath;
 }