@tstdl/base 0.86.0 → 0.87.0

package/application/application.d.ts

@@ -1,10 +1,10 @@
+import type { CancellationSignal } from '../cancellation/token.js';
 import type { Resolvable } from '../injector/interfaces.js';
 import { resolveArgumentType } from '../injector/interfaces.js';
 import type { LoggerArgument } from '../logger/index.js';
 import type { Module } from '../module/module.js';
 import type { FunctionModuleFunction } from '../module/modules/function.module.js';
 import type { OneOrMany, Type } from '../types.js';
-import type { ReadonlyCancellationToken } from '../utils/cancellation-token.js';
 export type BootstrapFn = () => void | Promise<void>;
 export type RunOptions = {
     bootstrap?: BootstrapFn;
@@ -14,8 +14,8 @@ export declare class Application implements Resolvable<LoggerArgument> {
     static _instance: Application | undefined;
     private static get instance();
     readonly [resolveArgumentType]: string;
-    get shutdownToken(): ReadonlyCancellationToken;
-    static get shutdownToken(): ReadonlyCancellationToken;
+    get shutdownSignal(): CancellationSignal;
+    static get shutdownSignal(): CancellationSignal;
     static registerModule(moduleType: Type<Module>): void;
     static registerModuleFunction(fn: FunctionModuleFunction): void;
     static run(...functionsAndModules: [RunOptions | OneOrMany<FunctionModuleFunction | Type<Module>>, ...OneOrMany<FunctionModuleFunction | Type<Module>>[]]): void;

package/application/application.js

@@ -53,8 +53,8 @@ let Application = class Application2 {
   static _instance;
   static get instance() {
     if ((0, import_type_guards.isUndefined)(this._instance)) {
-      this._instance = import_core.rootInjector.resolve(Application_1, "App");
-      this._instance.#shutdownToken = import_process_shutdown.shutdownToken;
+      this._instance = (0, import_core.getGlobalInjector)().resolve(Application_1, "App");
+      this._instance.#shutdownToken = (0, import_process_shutdown.getShutdownToken)();
     }
     return this._instance;
   }
@@ -63,12 +63,12 @@ let Application = class Application2 {
   #logger = this.#injector.resolve(import_logger.Logger, this.#name);
   #moduleTypesAndInstances = /* @__PURE__ */ new Set();
   #shutdownPromise = new import_deferred_promise.DeferredPromise();
-  #shutdownToken = import_process_shutdown.shutdownToken.createChild();
-  get shutdownToken() {
-    return this.#shutdownToken.asReadonly();
+  #shutdownToken = (0, import_process_shutdown.getShutdownSignal)().createChild();
+  get shutdownSignal() {
+    return this.#shutdownToken.signal;
   }
-  static get shutdownToken() {
-    return Application_1.instance.shutdownToken;
+  static get shutdownSignal() {
+    return Application_1.instance.shutdownSignal;
   }
   static registerModule(moduleType) {
     Application_1.instance.registerModule(moduleType);
@@ -105,7 +105,7 @@ let Application = class Application2 {
     await this.#shutdownPromise;
   }
   requestShutdown() {
-    if (this.shutdownToken.isSet) {
+    if (this.shutdownSignal.isSet) {
       return;
     }
     this.#shutdownToken.set();
@@ -128,7 +128,7 @@ let Application = class Application2 {
     try {
       await Promise.race([
         this.runModules(modules),
-        this.shutdownToken
+        this.shutdownSignal
       ]);
     } catch (error) {
       this.#logger.error(error, { includeRest: true, includeStack: true });
@@ -137,7 +137,6 @@ let Application = class Application2 {
       this.#logger.info("Shutting down");
       await this.stopModules(modules);
       await this.#injector.dispose();
-      await (0, import_core.disposeInstances)();
       this.#logger.info("Bye");
     }
     this.#shutdownPromise.resolve();

package/authentication/client/authentication.service.js

@@ -22,6 +22,7 @@ __export(authentication_service_exports, {
 });
 module.exports = __toCommonJS(authentication_service_exports);
 var import_rxjs = require("rxjs");
+var import_token = require("../../cancellation/token.js");
 var import_disposable = require("../../disposable/index.js");
 var import_bad_request_error = require("../../error/bad-request.error.js");
 var import_forbidden_error = require("../../error/forbidden.error.js");
@@ -34,7 +35,6 @@ var import_lock = require("../../lock/index.js");
 var import_logger = require("../../logger/index.js");
 var import_message_bus = require("../../message-bus/index.js");
 var import_api = require("../../signals/api.js");
-var import_cancellation_token = require("../../utils/cancellation-token.js");
 var import_date_time = require("../../utils/date-time.js");
 var import_timing = require("../../utils/timing.js");
 var import_type_guards = require("../../utils/type-guards.js");
@@ -124,9 +124,9 @@ let AuthenticationService = class AuthenticationService2 {
     if ((0, import_type_guards.isUndefined)(this.authenticationData)) {
       this.authenticationData = initialAuthenticationData;
     }
-    this.disposeToken = new import_cancellation_token.CancellationToken();
+    this.disposeToken = new import_token.CancellationToken();
     this.errorSubject = new import_rxjs.Subject();
-    this.forceRefreshToken = new import_cancellation_token.CancellationToken();
+    this.forceRefreshToken = new import_token.CancellationToken();
     this.error$ = this.errorSubject.asObservable();
     this.loggedOut$ = loggedOutBus.allMessages$;
   }

package/browser/browser-context-controller.d.ts

@@ -5,7 +5,7 @@ import type { Resolvable } from '../injector/interfaces.js';
 import { resolveArgumentType } from '../injector/interfaces.js';
 import type { Logger } from '../logger/logger.js';
 import type { Record } from '../types.js';
-import type { Opaque } from 'type-fest';
+import type { Tagged } from 'type-fest';
 import type { NewBrowserContextOptions } from './browser-controller.js';
 import type { PageControllerOptions } from './page-controller.js';
 import { PageController } from './page-controller.js';
@@ -16,7 +16,7 @@ export type NewPageOptions = {
     extraHttpHeaders?: Record<string, string>;
     controllerOptions?: PageControllerOptions;
 };
-export type BrowserContextState = Opaque<Record<string | number, unknown>, 'BrowserContextState'>;
+export type BrowserContextState = Tagged<Record<string | number, unknown>, 'BrowserContextState'>;
 export type BrowserContextControllerArgument = NewBrowserContextOptions;
 export declare class BrowserContextController implements AsyncDisposable, Resolvable<BrowserContextControllerArgument> {
     /** @deprecated should be avoided */

package/browser/browser-context-controller.js

@@ -43,8 +43,7 @@ var __metadata = function(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
     return Reflect.metadata(k, v);
 };
-var BrowserContextController_1;
-let BrowserContextController = BrowserContextController_1 = class BrowserContextController2 {
+let BrowserContextController = class BrowserContextController2 {
   /** @deprecated should be avoided */
   context;
   options;
@@ -95,15 +94,15 @@ let BrowserContextController = BrowserContextController_1 = class BrowserContext
     (0, import_utils.attachLogger)(this.context, logger);
   }
 };
-BrowserContextController = BrowserContextController_1 = __decorate([
+BrowserContextController = __decorate([
   (0, import_decorators.Injectable)({
     provider: {
       useFactory: (_, context) => {
-        context.context.browserController = context.resolve(import_browser_controller.BrowserController);
-        return new BrowserContextController_1(null);
+        context.data.browserController = context.resolve(import_browser_controller.BrowserController);
+        return new BrowserContextController(null);
       },
-      async afterResolve(value, argument, context) {
-        const { context: browserContext, controllerOptions } = await context.browserController.newRawContext(argument);
+      async afterResolve(value, argument, { data: { browserController } }) {
+        const { context: browserContext, controllerOptions } = await browserController.newRawContext(argument);
         value.context = browserContext;
         value.options = controllerOptions;
       }

package/browser/browser-controller.js

@@ -44,8 +44,7 @@ var __metadata = function(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
     return Reflect.metadata(k, v);
 };
-var BrowserController_1;
-let BrowserController = BrowserController_1 = class BrowserController2 {
+let BrowserController = class BrowserController2 {
   /** @deprecated should be avoided */
   browser;
   options;
@@ -103,15 +102,15 @@ let BrowserController = BrowserController_1 = class BrowserController2 {
     });
   }
 };
-BrowserController = BrowserController_1 = __decorate([
+BrowserController = __decorate([
   (0, import_decorators.Injectable)({
     provider: {
       useFactory: (_argument, context) => {
-        context.context.browserService = (0, import_inject.inject)(import_browser_service.BrowserService);
-        return new BrowserController_1(null);
+        context.data.browserService = (0, import_inject.inject)(import_browser_service.BrowserService);
+        return new BrowserController(null);
       },
-      async afterResolve(value, argument, context) {
-        const { browser, controllerOptions } = await context.browserService.newRawBrowser(argument);
+      async afterResolve(value, argument, { data: { browserService } }) {
+        const { browser, controllerOptions } = await browserService.newRawBrowser(argument);
         value.browser = browser;
         value.options = controllerOptions;
       }

package/cancellation/index.d.ts

@@ -0,0 +1 @@
+export * from './token.js';

package/{global-this.js → cancellation/index.js}

@@ -3,10 +3,6 @@ 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))
@@ -15,23 +11,8 @@ var __copyProps = (to, from, except, desc) => {
   }
   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 global_this_exports = {};
-__export(global_this_exports, {
-  ensureGlobalThis: () => ensureGlobalThis
-});
-module.exports = __toCommonJS(global_this_exports);
-function ensureGlobalThis() {
-  if (typeof globalThis === "object") {
-    return;
-  }
-  Object.defineProperty(Object.prototype, "__magic__", {
-    get() {
-      return this;
-    },
-    configurable: true
-    // this makes it possible to `delete` the getter later.
-  });
-  __magic__.globalThis = __magic__;
-  delete Object.prototype["__magic__"];
-}
+var cancellation_exports = {};
+module.exports = __toCommonJS(cancellation_exports);
+__reExport(cancellation_exports, require("./token.js"), module.exports);

package/{utils/cancellation-token.d.ts → cancellation/token.d.ts}

@@ -1,4 +1,5 @@
-import type { Observable, Observer, Subscribable, Subscription } from 'rxjs';
+import type { Observable, Observer, Subscribable, Unsubscribable } from 'rxjs';
+import { BehaviorSubject } from 'rxjs';
 export type ConnectConfig = {
     /**
      * Propagate parent set to child.
@@ -31,15 +32,8 @@ export type ConnectConfig = {
      */
     once?: boolean;
 };
-export interface ReadonlyCancellationToken extends PromiseLike<void>, Subscribable<void> {
-    /**
-     * Returns whether this token set.
-     */
-    readonly isSet: boolean;
-    /**
-     * Returns whether this token unset.
-     */
-    readonly isUnset: boolean;
+export declare class CancellationSignal implements PromiseLike<void>, Subscribable<void> {
+    #private;
     /**
      * Observable which emits the current state and every state change.
      */
@@ -47,23 +41,33 @@ export interface ReadonlyCancellationToken extends PromiseLike<void>, Subscribab
     /**
      * Observable which emits when this token is set.
      */
-    readonly set$: Observable<void>;
+    readonly set$: Observable<undefined>;
     /**
      * Observable which emits when this token is unset.
      */
-    readonly unset$: Observable<void>;
+    readonly unset$: Observable<undefined>;
+    /**
+     * Returns a promise which is resolved when this token changes its state.
+     */
+    get $state(): Promise<boolean>;
     /**
      * Returns a promise which is resolved when this token is set.
      */
-    readonly $set: Promise<void>;
+    get $set(): Promise<void>;
     /**
      * Returns a promise which is resolved when this token is unset.
      */
-    readonly $unset: Promise<void>;
+    get $unset(): Promise<void>;
+    get state(): boolean;
     /**
-     * Returns a promise which is resolved when this token changes its state.
+     * Whether this token is set.
      */
-    readonly $state: Promise<boolean>;
+    get isSet(): boolean;
+    /**
+     * Whether this token is unset.
+     */
+    get isUnset(): boolean;
+    constructor(stateSubject: BehaviorSubject<boolean>);
     /**
      * Returns an AbortSignal.
      */
@@ -74,21 +78,17 @@ export interface ReadonlyCancellationToken extends PromiseLike<void>, Subscribab
      */
     createChild(config?: ConnectConfig): CancellationToken;
     /**
-     * Propagate events from this instance to the `child`. Events from the `child` are *not* propagated to this instance.
-     * @param child child to connect
+     * Propagate events from this instance to `target`. Events from the `target` are *not* propagated to this instance.
+     * @param target receiver to connect
      */
-    connect(child: CancellationToken, config?: ConnectConfig): void;
+    connect(target: CancellationToken, config?: ConnectConfig): void;
+    then<TResult>(onfulfilled?: ((value: void) => TResult | PromiseLike<TResult>) | undefined | null): Promise<TResult>;
+    subscribe(observer: Partial<Observer<void>>): Unsubscribable;
 }
-export declare class CancellationToken implements ReadonlyCancellationToken {
-    private readonly stateSubject;
-    readonly state$: Observable<boolean>;
-    readonly set$: Observable<void>;
-    readonly unset$: Observable<void>;
-    get isSet(): boolean;
-    get isUnset(): boolean;
-    get $set(): Promise<void>;
-    get $unset(): Promise<void>;
-    get $state(): Promise<boolean>;
+export declare class CancellationToken extends CancellationSignal {
+    #private;
+    /** Signal for this token */
+    readonly signal: CancellationSignal;
     /**
      * @param initialState which state to initialze this token to
      * - `false`: unset
@@ -109,15 +109,11 @@ export declare class CancellationToken implements ReadonlyCancellationToken {
      * @param observable observable to subscribe. Takes emitted value as state if type is boolean otherwise sets state to true.
      */
     static from(source: Observable<boolean>, config?: ConnectConfig): CancellationToken;
-    private static connect;
-    asAbortSignal(): AbortSignal;
-    asReadonly(): ReadonlyCancellationToken;
-    createChild(config?: ConnectConfig): CancellationToken;
-    connect(child: CancellationToken, config?: ConnectConfig): void;
+    static connect(state$: Observable<boolean>, target: CancellationToken, config?: ConnectConfig): void;
     /**
      * Become a child of the provided parent. Events from the parent are propagated to this token. Events from this token are *not* propagated to the parent.
      */
-    inherit(parent: ReadonlyCancellationToken, config?: ConnectConfig): this;
+    inherit(parent: CancellationToken | CancellationSignal, config?: ConnectConfig): this;
     /**
      * Set this token.
      */
@@ -140,6 +136,4 @@ export declare class CancellationToken implements ReadonlyCancellationToken {
      * Keep in mind that *active* awaits (promise) on this token will throw.
      */
     complete(): void;
-    then<TResult>(onfulfilled?: ((value: void) => TResult | PromiseLike<TResult>) | undefined | null): Promise<TResult>;
-    subscribe(observer: Partial<Observer<void>>): Subscription;
 }

package/{utils/cancellation-token.js → cancellation/token.js}

@@ -16,35 +16,102 @@ var __copyProps = (to, from2, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var cancellation_token_exports = {};
-__export(cancellation_token_exports, {
+var token_exports = {};
+__export(token_exports, {
+  CancellationSignal: () => CancellationSignal,
   CancellationToken: () => CancellationToken
 });
-module.exports = __toCommonJS(cancellation_token_exports);
-var import_noop = require("../rxjs/noop.js");
+module.exports = __toCommonJS(token_exports);
 var import_rxjs = require("rxjs");
-var import_noop2 = require("./noop.js");
-var import_type_guards = require("./type-guards.js");
-class CancellationToken {
-  stateSubject;
-  state$;
-  set$;
-  unset$;
-  get isSet() {
-    return this.stateSubject.value;
-  }
-  get isUnset() {
-    return !this.stateSubject.value;
+var import_noop = require("../rxjs/noop.js");
+var import_noop2 = require("../utils/noop.js");
+var import_type_guards = require("../utils/type-guards.js");
+class CancellationSignal {
+  #stateSubject;
+  /**
+   * Observable which emits the current state and every state change.
+   */
+  state$ = (0, import_rxjs.defer)(() => this.#stateSubject);
+  /**
+   * Observable which emits when this token is set.
+   */
+  set$ = this.state$.pipe((0, import_rxjs.filter)((state) => state), (0, import_rxjs.map)(() => void 0));
+  /**
+   * Observable which emits when this token is unset.
+   */
+  unset$ = this.state$.pipe((0, import_rxjs.filter)((state) => !state), (0, import_rxjs.map)(() => void 0));
+  /**
+   * Returns a promise which is resolved when this token changes its state.
+   */
+  get $state() {
+    return (0, import_rxjs.firstValueFrom)(this.state$.pipe((0, import_rxjs.skip)(1)));
   }
+  /**
+   * Returns a promise which is resolved when this token is set.
+   */
   get $set() {
     return (0, import_rxjs.firstValueFrom)(this.set$);
   }
+  /**
+   * Returns a promise which is resolved when this token is unset.
+   */
   get $unset() {
     return (0, import_rxjs.firstValueFrom)(this.unset$);
   }
-  get $state() {
-    return (0, import_rxjs.firstValueFrom)(this.state$.pipe((0, import_rxjs.skip)(1)));
+  get state() {
+    return this.#stateSubject.value;
+  }
+  /**
+   * Whether this token is set.
+   */
+  get isSet() {
+    return this.#stateSubject.value;
   }
+  /**
+   * Whether this token is unset.
+   */
+  get isUnset() {
+    return !this.#stateSubject.value;
+  }
+  constructor(stateSubject) {
+    this.#stateSubject = stateSubject;
+  }
+  /**
+   * Returns an AbortSignal.
+   */
+  asAbortSignal() {
+    const abortController = new AbortController();
+    this.set$.pipe((0, import_rxjs.first)()).subscribe(() => abortController.abort());
+    return abortController.signal;
+  }
+  /**
+   * Create a new token and connect it to this instance.
+   * @see {@link connect}
+   */
+  createChild(config) {
+    const child = new CancellationToken();
+    this.connect(child, config);
+    return child;
+  }
+  /**
+   * Propagate events from this instance to `target`. Events from the `target` are *not* propagated to this instance.
+   * @param target receiver to connect
+   */
+  connect(target, config) {
+    CancellationToken.connect(this.state$, target, config);
+  }
+  async then(onfulfilled) {
+    await this.$set;
+    return onfulfilled?.();
+  }
+  subscribe(observer) {
+    return this.set$.subscribe(observer);
+  }
+}
+class CancellationToken extends CancellationSignal {
+  #stateSubject;
+  /** Signal for this token */
+  signal;
   /**
    * @param initialState which state to initialze this token to
    * - `false`: unset
@@ -52,10 +119,10 @@ class CancellationToken {
    * @default false
    */
   constructor(initialState = false) {
-    this.stateSubject = new import_rxjs.BehaviorSubject(initialState);
-    this.state$ = this.stateSubject.pipe((0, import_rxjs.distinctUntilChanged)());
-    this.set$ = this.state$.pipe((0, import_rxjs.filter)((state) => state), (0, import_rxjs.map)(() => void 0));
-    this.unset$ = this.state$.pipe((0, import_rxjs.filter)((state) => !state), (0, import_rxjs.map)(() => void 0));
+    const stateSubject = new import_rxjs.BehaviorSubject(initialState);
+    super(stateSubject);
+    this.#stateSubject = new import_rxjs.BehaviorSubject(initialState);
+    this.signal = new CancellationSignal(this.#stateSubject);
   }
   static from(source, config) {
     const source$ = source instanceof AbortSignal ? (0, import_rxjs.fromEvent)(source, "abort", () => true) : (0, import_rxjs.isObservable)(source) ? source.pipe((0, import_rxjs.map)((state) => (0, import_type_guards.isBoolean)(state) ? state : true)) : (0, import_rxjs.from)(source).pipe((0, import_rxjs.map)(() => true));
@@ -63,65 +130,50 @@ class CancellationToken {
     CancellationToken.connect(source$, token, config);
     return token;
   }
-  static connect(stateObservable, target, config = {}) {
+  static connect(state$, target, config = {}) {
     const { set = true, unset = true, complete = true, error = true, immediate = true, once = false } = config;
-    const state$ = stateObservable.pipe(immediate ? (0, import_noop.noopOperator)() : (0, import_rxjs.skip)(1), set && unset ? (0, import_noop.noopOperator)() : set ? (0, import_rxjs.filter)((state) => state) : unset ? (0, import_rxjs.filter)((state) => !state) : (0, import_rxjs.filter)(() => false), once ? (0, import_rxjs.take)(1) : (0, import_noop.noopOperator)());
-    const subscription = state$.subscribe({
+    const stateObservable = state$.pipe(immediate ? (0, import_noop.noopOperator)() : (0, import_rxjs.skip)(1), set && unset ? (0, import_noop.noopOperator)() : set ? (0, import_rxjs.filter)((state) => state) : unset ? (0, import_rxjs.filter)((state) => !state) : (0, import_rxjs.filter)(() => false), once ? (0, import_rxjs.take)(1) : (0, import_noop.noopOperator)());
+    const subscription = stateObservable.subscribe({
       next: (state) => target.setState(state),
       error: error ? (errorValue) => target.error(errorValue) : import_noop2.noop,
       complete: complete ? () => target.complete() : import_noop2.noop
     });
-    target.stateSubject.subscribe({
+    target.#stateSubject.subscribe({
       error: () => subscription.unsubscribe(),
       complete: () => subscription.unsubscribe()
     });
   }
-  asAbortSignal() {
-    const abortController = new AbortController();
-    this.set$.pipe((0, import_rxjs.first)()).subscribe(() => abortController.abort());
-    return abortController.signal;
-  }
-  asReadonly() {
-    return this;
-  }
-  createChild(config) {
-    const child = new CancellationToken();
-    this.connect(child, config);
-    return child;
-  }
-  connect(child, config) {
-    CancellationToken.connect(this.state$, child, config);
-  }
   /**
    * Become a child of the provided parent. Events from the parent are propagated to this token. Events from this token are *not* propagated to the parent.
    */
   inherit(parent, config) {
-    CancellationToken.connect(parent.state$, this, config);
+    const state$ = (parent instanceof CancellationToken ? parent.signal : parent).state$;
+    CancellationToken.connect(state$, this, config);
     return this;
   }
   /**
    * Set this token.
    */
   set() {
-    this.stateSubject.next(true);
+    this.setState(true);
   }
   /**
    * Unset this token.
    */
   unset() {
-    this.stateSubject.next(false);
+    this.setState(false);
   }
   /**
    * Set the state.
    */
   setState(state) {
-    this.stateSubject.next(state);
+    this.#stateSubject.next(state);
   }
   /**
    * Errors the token.
    */
   error(error) {
-    this.stateSubject.error(error);
+    this.#stateSubject.error(error);
   }
   /**
    * Clean up subscriptions.
@@ -129,13 +181,6 @@ class CancellationToken {
    * Keep in mind that *active* awaits (promise) on this token will throw.
    */
   complete() {
-    this.stateSubject.complete();
-  }
-  async then(onfulfilled) {
-    await this.$set;
-    return onfulfilled?.();
-  }
-  subscribe(observer) {
-    return this.set$.subscribe(observer);
+    this.#stateSubject.complete();
   }
 }

package/core.d.ts

@@ -1,16 +1,17 @@
-import { AsyncDisposer } from './disposable/async-disposer.js';
+import type { CancellationSignal } from './cancellation/token.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, never>;
-export declare const rootInjector: Injector;
-export declare const disposer: AsyncDisposer;
+/**
+ * @deprecated Should be avoided. Use `Application` scoped injector instead.
+ */
+export declare function getGlobalInjector(): Injector;
 export declare function isDevMode(): boolean;
 export declare function isProdMode(): boolean;
 export declare function enableProdMode(): void;
-export declare function connect(name: string, connectFunction: (() => Promise<any>), logger: Logger, maxTries?: number): Promise<void>;
-export declare function disposeInstances(): Promise<void>;
+export declare function connect(name: string, connectFunction: (() => Promise<any>), logger: Logger, cancellationSignal: CancellationSignal, maxTries?: number): Promise<void>;
 export type CoreConfiguration = {
     production?: boolean;
     logger?: InjectionToken<Logger, LoggerArgument>;

package/core.js

@@ -21,15 +21,12 @@ __export(core_exports, {
   CORE_LOGGER: () => CORE_LOGGER,
   configureTstdl: () => configureTstdl,
   connect: () => connect,
-  disposeInstances: () => disposeInstances,
-  disposer: () => disposer,
   enableProdMode: () => enableProdMode,
+  getGlobalInjector: () => getGlobalInjector,
   isDevMode: () => isDevMode,
-  isProdMode: () => isProdMode,
-  rootInjector: () => rootInjector
+  isProdMode: () => isProdMode
 });
 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");
@@ -38,9 +35,14 @@ 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 globalInjector;
 let _isDevMode = true;
+function getGlobalInjector() {
+  if ((0, import_type_guards.isUndefined)(globalInjector)) {
+    globalInjector = new import_injector.Injector("GlobalInjector");
+  }
+  return globalInjector;
+}
 function isDevMode() {
   return _isDevMode;
 }
@@ -50,10 +52,10 @@ function isProdMode() {
 function enableProdMode() {
   _isDevMode = false;
 }
-async function connect(name, connectFunction, logger, maxTries = 5) {
+async function connect(name, connectFunction, logger, cancellationSignal, maxTries = 5) {
   let triesLeft = maxTries;
   let success = false;
-  while (!success && !disposer.disposing && triesLeft-- > 0) {
+  while (!success && cancellationSignal.isUnset && triesLeft-- > 0) {
     try {
       logger.verbose(`connecting to ${name}...`);
       await connectFunction();
@@ -69,15 +71,12 @@ async function connect(name, connectFunction, logger, maxTries = 5) {
     }
   }
 }
-async function disposeInstances() {
-  await disposer.dispose();
-}
 let coreLogPrefix;
 function configureTstdl(config = {}) {
   if (config.production == true) {
     enableProdMode();
   }
-  const logger = rootInjector.resolve(CORE_LOGGER);
+  const logger = getGlobalInjector().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 });