@tstdl/base 0.86.0-beta1 → 0.86.0-beta10

package/container/decorators.js

@@ -1,126 +1,34 @@
-import { createClassDecorator, createDecorator } from '../reflection/index.js';
-import { toArray } from '../utils/array/array.js';
-import { isDefined, isFunction } from '../utils/type-guards.js';
-import { container, injectMetadataSymbol } from './container.js';
-/**
- * Helper decorator to replace a class definition with an other
- * can be used for example to type external classes with the {@link Injectable} interface
- * @param constructor class to replace with
- */
-export function replaceClass(constructor) {
-    return createClassDecorator({ handler: () => constructor });
-}
-/**
- * registers the class in the global container. Decorated class is not modified in any way
- * @param options registration options
- */
-export function injectable(options = {}) {
-    return createClassDecorator({
-        data: { [injectMetadataSymbol]: {} },
-        mergeData: true,
-        handler: (data) => {
-            const { alias: aliases, provider, ...registrationOptions } = options;
-            const targetProvider = provider ?? { useClass: data.constructor };
-            container.register(data.constructor, targetProvider, registrationOptions);
-            if (isDefined(aliases)) {
-                for (const alias of toArray(aliases)) {
-                    container.register(alias, { useToken: data.constructor }, registrationOptions);
-                }
-            }
-        }
-    });
-}
-/**
- * registers the class in the global container with singleton lifecycle. Decorated class is not modified in any way
- * @param options registration options
- */
-export function singleton(options = {}) {
-    return injectable({ ...options, lifecycle: 'singleton' });
-}
-/**
- * registers the class in the global container with scoped lifecycle. Decorated class is not modified in any way
- * @param options registration options
- */
-export function scoped(lifecycle, options = {}) {
-    return injectable({ ...options, lifecycle });
-}
-/**
- * sets the token used to resolve the parameter
- * @param token token used for resolving
- * @param argument resolve argument
- * @param mapperOrKey map the resolved value. If {@link PropertyKey} is provided, that property of the resolved value will be injected
- */
-export function inject(token, argument, mapperOrKey) {
-    const injectMetadata = {};
-    if (isDefined(token)) {
-        injectMetadata.injectToken = token;
-    }
-    if (isDefined(argument)) {
-        injectMetadata.resolveArgumentProvider = () => argument;
-    }
-    if (isDefined(mapperOrKey)) {
-        injectMetadata.mapper = isFunction(mapperOrKey) ? mapperOrKey : ((value) => value[mapperOrKey]);
-    }
-    return createInjectDecorator(injectMetadata);
-}
-/**
- * sets the argument used for resolving the parameter
- * @param argument
- */
-export function resolveArg(argument) {
-    return resolveArgProvider(() => argument);
-}
-/**
- * sets the argument provider used for resolving the parameter
- * @param argumentProvider
- */
-export function resolveArgProvider(argumentProvider) {
-    return createInjectDecorator({ resolveArgumentProvider: argumentProvider });
-}
-/**
- * injects the argument used for resolving the class instead of resolving the parameter
- * @param argument
- * @param mapperOrKey map the resolved value. If {@link PropertyKey} is provided, that property of the resolved value will be injected
- */
-export function injectArg(mapperOrKey) {
-    return createInjectDecorator({
-        injectArgumentMapper: isFunction(mapperOrKey)
-            ? mapperOrKey
-            : isDefined(mapperOrKey)
-                ? ((value) => value[mapperOrKey])
-                : ((value) => value)
-    });
-}
-export function forwardArg(mapper = (value) => value) {
-    return createInjectDecorator({ forwardArgumentMapper: mapper });
-}
-/**
- * marks the argument as optional
- * @param argument
- */
-export function optional() {
-    return createInjectDecorator({ optional: true });
-}
-/**
- * resolve using ForwardRef to handle circular dependencies. Resolve logic derefs all ForwardRefs which are direct properties of resolved instances automatically
- * @param token token to resolve
- * @param argument resolve argument
- */
-export function forwardRef(token, argument) {
-    const injectMetadata = {
-        forwardRefToken: token
-    };
-    if (isDefined(argument)) {
-        injectMetadata.resolveArgumentProvider = () => argument;
-    }
-    return createInjectDecorator(injectMetadata);
-}
-function createInjectDecorator(metadata) {
-    return createDecorator({
-        property: true,
-        accessor: true,
-        constructorParameter: true,
-        data: { [injectMetadataSymbol]: metadata },
-        mergeData: true
-    });
-}
+"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 decorators_exports = {};
+__export(decorators_exports, {
+  forwardArg: () => import_decorators.ForwardArg,
+  forwardRef: () => import_decorators.ForwardRef,
+  inject: () => import_decorators.Inject,
+  injectArg: () => import_decorators.InjectArg,
+  injectable: () => import_decorators.Injectable,
+  optional: () => import_decorators.Optional,
+  replaceClass: () => import_decorators.ReplaceClass,
+  resolveArg: () => import_decorators.ResolveArg,
+  resolveArgProvider: () => import_decorators.ResolveArgProvider,
+  scoped: () => import_decorators.Scoped,
+  singleton: () => import_decorators.Singleton
+});
+module.exports = __toCommonJS(decorators_exports);
+var import_decorators = require("../injector/decorators.js");

package/container/index.d.ts

@@ -1,10 +1,3 @@
-export * from './container.js';
 export * from './decorators.js';
 export * from './interfaces.js';
-export * from './provider.js';
-export * from './resolve-chain.js';
-export * from './resolve.error.js';
 export * from './token.js';
-export * from './type-info.js';
-export * from './types.js';
-export * from './utils.js';

package/container/index.js

@@ -1,10 +1,20 @@
-export * from './container.js';
-export * from './decorators.js';
-export * from './interfaces.js';
-export * from './provider.js';
-export * from './resolve-chain.js';
-export * from './resolve.error.js';
-export * from './token.js';
-export * from './type-info.js';
-export * from './types.js';
-export * from './utils.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 container_exports = {};
+module.exports = __toCommonJS(container_exports);
+__reExport(container_exports, require("./decorators.js"), module.exports);
+__reExport(container_exports, require("./interfaces.js"), module.exports);
+__reExport(container_exports, require("./token.js"), module.exports);

package/container/interfaces.d.ts

@@ -1,16 +1,2 @@
-export declare const resolveArgumentType: unique symbol;
-export declare const afterResolve: unique symbol;
-export type InjectableArgument<T, Fallback> = T extends Injectable<infer A> ? A : Fallback;
-export interface Injectable<T = unknown> {
-    /**
-     * type of resolve argument
-     * @deprecated only used for type inference
-     */
-    readonly [resolveArgumentType]: T;
-}
-export interface AfterResolve {
-    /**
-     * called after resolve through container
-     */
-    [afterResolve](): void | Promise<void>;
-}
+export { afterResolve, resolveArgumentType } from '../injector/interfaces.js';
+export type { AfterResolve, Resolvable as Injectable, ResolveArgument as InjectableArgument } from '../injector/interfaces.js';

package/container/interfaces.js

@@ -1,2 +1,25 @@
-export const resolveArgumentType = Symbol('resolveArgumentType');
-export const afterResolve = Symbol('after resolve');
+"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 interfaces_exports = {};
+__export(interfaces_exports, {
+  afterResolve: () => import_interfaces.afterResolve,
+  resolveArgumentType: () => import_interfaces.resolveArgumentType
+});
+module.exports = __toCommonJS(interfaces_exports);
+var import_interfaces = require("../injector/interfaces.js");

package/container/token.d.ts

@@ -1,18 +1,2 @@
-import type { AbstractConstructor, EnumerationObject } from '../types.js';
-declare const type: unique symbol;
-declare const argument: unique symbol;
-export type ArgumentedInjectionToken<T, A> = SimpleInjectionToken<T> & {
-    [argument]?: A;
-};
-export type SimpleInjectionToken<T> = AbstractConstructor<T> | EnumerationObject;
-export type InjectionToken<T = any, A = any> = SimpleInjectionToken<T> | ArgumentedInjectionToken<T, A> | ReifyingInjectionToken<T, A>;
-export declare class ReifyingInjectionToken<T = any, A = any> {
-    private readonly [type];
-    private readonly [argument];
-    readonly description: string;
-    constructor(description: string);
-    toString(): string;
-}
-export declare function injectionToken<T, A = any>(description: string): InjectionToken<T, A>;
-export declare function getTokenName(token: InjectionToken | undefined): string;
-export {};
+export { ReifyingInjectionToken, getTokenName, injectionToken } from '../injector/token.js';
+export type { ArgumentedInjectionToken, InjectionToken, SimpleInjectionToken } from '../injector/token.js';

package/container/token.js

@@ -1,20 +1,26 @@
-import { isFunction, isString } from '../utils/type-guards.js';
-export class ReifyingInjectionToken {
-    description;
-    constructor(description) {
-        this.description = description;
-    }
-    toString() {
-        return `InjectionToken["${this.description}"]`;
-    }
-}
-export function injectionToken(description) {
-    return new ReifyingInjectionToken(description);
-}
-export function getTokenName(token) {
-    return isFunction(token)
-        ? token.name
-        : isString(token)
-            ? `"${token}"`
-            : String(token);
-}
+"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 token_exports = {};
+__export(token_exports, {
+  ReifyingInjectionToken: () => import_token.ReifyingInjectionToken,
+  getTokenName: () => import_token.getTokenName,
+  injectionToken: () => import_token.injectionToken
+});
+module.exports = __toCommonJS(token_exports);
+var import_token = require("../injector/token.js");

package/cookie/cookie.js

@@ -1,54 +1,76 @@
-import { NotSupportedError } from '../error/not-supported.error.js';
-import { trim } from '../utils/string/trim.js';
-import { isDefined, isNumber, isUndefined } from '../utils/type-guards.js';
+"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 cookie_exports = {};
+__export(cookie_exports, {
+  formatSetCookie: () => formatSetCookie,
+  parseCookieString: () => parseCookieString
+});
+module.exports = __toCommonJS(cookie_exports);
+var import_not_supported_error = require("../error/not-supported.error.js");
+var import_trim = require("../utils/string/trim.js");
+var import_type_guards = require("../utils/type-guards.js");
 const sameSiteMap = {
-    none: 'None',
-    lax: 'Lax',
-    strict: 'Strict'
+  none: "None",
+  lax: "Lax",
+  strict: "Strict"
 };
-export function formatSetCookie(name, value, options = {}) {
-    const encodedValue = encodeURIComponent(value);
-    let cookie = `${name}="${encodedValue}"`;
-    if (isDefined(options.domain)) {
-        cookie = `${cookie}; Domain=${options.domain}`;
-    }
-    if (isDefined(options.expires)) {
-        const date = isNumber(options.expires) ? new Date(options.expires) : options.expires;
-        cookie = `${cookie}; Expires=${date.toUTCString()}`;
-    }
-    if (isDefined(options.httpOnly) && options.httpOnly) {
-        cookie = `${cookie}; HttpOnly`;
-    }
-    if (isDefined(options.maxAge)) {
-        cookie = `${cookie}; Max-Age=${options.maxAge}`;
-    }
-    if (isDefined(options.partitioned) && options.partitioned) {
-        cookie = `${cookie}; Partitioned`;
-    }
-    if (isDefined(options.path)) {
-        cookie = `${cookie}; Path=${options.path}`;
-    }
-    if (isDefined(options.sameSite)) {
-        const sameSiteValue = sameSiteMap[options.sameSite];
-        if (isUndefined(sameSiteValue)) {
-            throw new NotSupportedError(`Unknown option SameSite "${options.sameSite}".`);
-        }
-        cookie = `${cookie}; SameSite=${sameSiteValue}`;
-    }
-    if (isDefined(options.secure) && options.secure) {
-        cookie = `${cookie}; Secure`;
+function formatSetCookie(name, value, options = {}) {
+  const encodedValue = encodeURIComponent(value);
+  let cookie = `${name}="${encodedValue}"`;
+  if ((0, import_type_guards.isDefined)(options.domain)) {
+    cookie = `${cookie}; Domain=${options.domain}`;
+  }
+  if ((0, import_type_guards.isDefined)(options.expires)) {
+    const date = (0, import_type_guards.isNumber)(options.expires) ? new Date(options.expires) : options.expires;
+    cookie = `${cookie}; Expires=${date.toUTCString()}`;
+  }
+  if ((0, import_type_guards.isDefined)(options.httpOnly) && options.httpOnly) {
+    cookie = `${cookie}; HttpOnly`;
+  }
+  if ((0, import_type_guards.isDefined)(options.maxAge)) {
+    cookie = `${cookie}; Max-Age=${options.maxAge}`;
+  }
+  if ((0, import_type_guards.isDefined)(options.partitioned) && options.partitioned) {
+    cookie = `${cookie}; Partitioned`;
+  }
+  if ((0, import_type_guards.isDefined)(options.path)) {
+    cookie = `${cookie}; Path=${options.path}`;
+  }
+  if ((0, import_type_guards.isDefined)(options.sameSite)) {
+    const sameSiteValue = sameSiteMap[options.sameSite];
+    if ((0, import_type_guards.isUndefined)(sameSiteValue)) {
+      throw new import_not_supported_error.NotSupportedError(`Unknown option SameSite "${options.sameSite}".`);
     }
-    return cookie;
+    cookie = `${cookie}; SameSite=${sameSiteValue}`;
+  }
+  if ((0, import_type_guards.isDefined)(options.secure) && options.secure) {
+    cookie = `${cookie}; Secure`;
+  }
+  return cookie;
 }
-export function parseCookieString(cookieString) {
-    const cookieEntries = cookieString
-        .split(';')
-        .map((cookiePartString) => {
-        const splitIndex = cookiePartString.indexOf('=');
-        const name = cookiePartString.slice(0, splitIndex).trim();
-        const rawValue = trim(cookiePartString.slice(splitIndex + 1).trim(), '"');
-        const value = decodeURIComponent(rawValue);
-        return [name, value];
-    });
-    return new Map(cookieEntries);
+function parseCookieString(cookieString) {
+  const cookieEntries = cookieString.split(";").map((cookiePartString) => {
+    const splitIndex = cookiePartString.indexOf("=");
+    const name = cookiePartString.slice(0, splitIndex).trim();
+    const rawValue = (0, import_trim.trim)(cookiePartString.slice(splitIndex + 1).trim(), '"');
+    const value = decodeURIComponent(rawValue);
+    return [name, value];
+  });
+  return new Map(cookieEntries);
 }

package/cookie/index.js

@@ -1 +1,18 @@
-export * from './cookie.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 cookie_exports = {};
+module.exports = __toCommonJS(cookie_exports);
+__reExport(cookie_exports, require("./cookie.js"), module.exports);

package/core.d.ts

@@ -1,8 +1,10 @@
-import type { InjectionToken } from './container/index.js';
 import { AsyncDisposer } from './disposable/async-disposer.js';
+import { Injector } from './injector/injector.js';
+import type { InjectionToken } from './injector/token.js';
 import type { LoggerArgument } from './logger/index.js';
 import { LogLevel, Logger } from './logger/index.js';
-export declare const CORE_LOGGER: InjectionToken<Logger, any>;
+export declare const CORE_LOGGER: InjectionToken<Logger, never>;
+export declare const rootInjector: Injector;
 export declare const disposer: AsyncDisposer;
 export declare function isDevMode(): boolean;
 export declare function isProdMode(): boolean;

package/core.js

@@ -1,55 +1,91 @@
-import { container, injectionToken } from './container/index.js';
-import { AsyncDisposer } from './disposable/async-disposer.js';
-import { ConsoleLogger } from './logger/console/logger.js';
-import { LogLevel, Logger } from './logger/index.js';
-import { timeout } from './utils/timing.js';
-import { assertDefinedPass, isDefined } from './utils/type-guards.js';
-export const CORE_LOGGER = injectionToken('core logger');
-export const disposer = new AsyncDisposer();
+"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 core_exports = {};
+__export(core_exports, {
+  CORE_LOGGER: () => CORE_LOGGER,
+  configureTstdl: () => configureTstdl,
+  connect: () => connect,
+  disposeInstances: () => disposeInstances,
+  disposer: () => disposer,
+  enableProdMode: () => enableProdMode,
+  isDevMode: () => isDevMode,
+  isProdMode: () => isProdMode,
+  rootInjector: () => rootInjector
+});
+module.exports = __toCommonJS(core_exports);
+var import_async_disposer = require("./disposable/async-disposer.js");
+var import_injector = require("./injector/injector.js");
+var import_token = require("./injector/token.js");
+var import_logger = require("./logger/console/logger.js");
+var import_logger2 = require("./logger/index.js");
+var import_process_shutdown = require("./process-shutdown.js");
+var import_timing = require("./utils/timing.js");
+var import_type_guards = require("./utils/type-guards.js");
+const CORE_LOGGER = (0, import_token.injectionToken)("core logger");
+const rootInjector = new import_injector.Injector("RootInjector");
+const disposer = new import_async_disposer.AsyncDisposer();
 let _isDevMode = true;
-export function isDevMode() {
-    return _isDevMode;
+function isDevMode() {
+  return _isDevMode;
 }
-export function isProdMode() {
-    return !_isDevMode;
+function isProdMode() {
+  return !_isDevMode;
 }
-export function enableProdMode() {
-    _isDevMode = false;
+function enableProdMode() {
+  _isDevMode = false;
 }
-export async function connect(name, connectFunction, logger, maxTries = 5) {
-    let triesLeft = maxTries;
-    let success = false;
-    while (!success && !disposer.disposing && triesLeft-- > 0) {
-        try {
-            logger.verbose(`connecting to ${name}...`);
-            await connectFunction();
-            success = true;
-            logger.info(`connected to ${name}`);
-        }
-        catch (error) {
-            logger.verbose(`error connecting to ${name}${triesLeft > 0 ? ', trying again...' : ''}`);
-            logger.error(error);
-            if (triesLeft == 0) {
-                throw new Error(`Failed to connect to ${name} - no tries left.`);
-            }
-            await timeout(3000);
-        }
+async function connect(name, connectFunction, logger, maxTries = 5) {
+  let triesLeft = maxTries;
+  let success = false;
+  while (!success && !disposer.disposing && triesLeft-- > 0) {
+    try {
+      logger.verbose(`connecting to ${name}...`);
+      await connectFunction();
+      success = true;
+      logger.info(`connected to ${name}`);
+    } catch (error) {
+      logger.verbose(`error connecting to ${name}${triesLeft > 0 ? ", trying again..." : ""}`);
+      logger.error(error);
+      if (triesLeft == 0) {
+        throw new Error(`Failed to connect to ${name} - no tries left.`);
+      }
+      await (0, import_timing.timeout)(3e3);
     }
+  }
 }
-export async function disposeInstances() {
-    await disposer.dispose();
+async function disposeInstances() {
+  await disposer.dispose();
 }
 let coreLogPrefix;
-export function configureTstdl(config = {}) {
-    if (config.production == true) {
-        enableProdMode();
-    }
-    container.register(Logger, { useToken: config.logger ?? ConsoleLogger });
-    container.registerSingleton(LogLevel, { useFactory: (level) => assertDefinedPass(level, 'LogLevel argument not provided') }, { defaultArgumentProvider: () => config.logLevel ?? LogLevel.Trace });
-    if (isDefined(config.coreLogPrefix)) {
-        coreLogPrefix = config.coreLogPrefix;
-    }
+function configureTstdl(config = {}) {
+  if (config.production == true) {
+    enableProdMode();
+  }
+  const logger = rootInjector.resolve(CORE_LOGGER);
+  (0, import_process_shutdown.setProcessShutdownLogger)(logger);
+  (0, import_process_shutdown.initializeSignals)();
+  import_injector.Injector.register(import_logger2.Logger, { useToken: config.logger ?? import_logger.ConsoleLogger });
+  import_injector.Injector.registerSingleton(import_logger2.LogLevel, { useFactory: (level) => (0, import_type_guards.assertDefinedPass)(level, "LogLevel argument not provided") }, { defaultArgumentProvider: () => config.logLevel ?? import_logger2.LogLevel.Trace });
+  if ((0, import_type_guards.isDefined)(config.coreLogPrefix)) {
+    coreLogPrefix = config.coreLogPrefix;
+  }
 }
-container.register(Logger, { useToken: ConsoleLogger });
-container.register(LogLevel, { useValue: LogLevel.Trace });
-container.register(CORE_LOGGER, { useToken: Logger, argumentProvider: () => coreLogPrefix });
+import_injector.Injector.register(import_logger2.Logger, { useToken: import_logger.ConsoleLogger });
+import_injector.Injector.register(import_logger2.LogLevel, { useValue: import_logger2.LogLevel.Trace });
+import_injector.Injector.register(CORE_LOGGER, { useToken: import_logger2.Logger, defaultArgumentProvider: () => coreLogPrefix });