@tstdl/base 0.87.3 → 0.87.5

package/authentication/client/module.js

@@ -36,12 +36,11 @@ function configureAuthenticationClient(config, injector = (0, import_inject.getC
     (injector ?? import_injector.Injector).register(import_tokens2.INITIAL_AUTHENTICATION_DATA, { useValue: config.initialAuthenticationData });
   }
   if ((0, import_type_guards.isDefined)(config.registerMiddleware)) {
-    (0, import_type_guards.assertNotNull)(injector);
-    injector.register(import_tokens.HTTP_CLIENT_MIDDLEWARE, {
+    (injector ?? import_injector.Injector).register(import_tokens.HTTP_CLIENT_MIDDLEWARE, {
       useFactory(_, context) {
         const authenticationService = context.resolve(import_authentication_service.AuthenticationService);
         return (0, import_http_client_middleware.waitForAuthenticationCredentialsMiddleware)(authenticationService);
       }
-    });
+    }, { multi: true });
   }
 }

package/browser/document-controller.d.ts

@@ -16,6 +16,8 @@ export declare class DocumentController<T extends Page | Frame = Page | Frame> e
     readonly context: BrowserContextController;
     readonly options: DocumentControllerOptions;
     constructor(document: T, context: BrowserContextController, options: DocumentControllerOptions);
+    evaluate<R, A>(fn: string | ((argument: A) => R | Promise<R>), argument: A): Promise<R>;
+    evaluate<R, A>(fn: string | ((argument?: A) => R | Promise<R>), argument?: A): Promise<R>;
     frames(): FrameController[];
     /**
      * Get a controller for the frame.

package/browser/document-controller.js

@@ -42,6 +42,9 @@ class DocumentController extends import_locator_controller.LocatorController {
     this.context = context;
     this.options = options;
   }
+  async evaluate(fn, argument) {
+    return this.document.evaluate(fn, argument);
+  }
   frames() {
     const frames = (0, import_utils.isPage)(this.document) ? this.document.frames() : this.document.childFrames();
     return frames.map((page) => this.getControllerByFrame(page));

package/core.js

@@ -31,6 +31,7 @@ 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_tokens = require("./logger/tokens.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");
@@ -80,11 +81,11 @@ function configureTstdl(config = {}) {
   (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 });
+  import_injector.Injector.register(import_tokens.LOG_LEVEL, { 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;
   }
 }
 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(import_tokens.LOG_LEVEL, { useValue: import_logger2.LogLevel.Trace });
 import_injector.Injector.register(CORE_LOGGER, { useToken: import_logger2.Logger, defaultArgumentProvider: () => coreLogPrefix });

package/http/client/http-client.d.ts

@@ -2,22 +2,21 @@ import { resolveArgumentType } from '../../injector/index.js';
 import type { Resolvable } from '../../injector/interfaces.js';
 import type { OneOrMany, UndefinableJson } from '../../types.js';
 import type { HttpMethod, HttpValue } from '../types.js';
-import { HttpClientOptions } from './http-client-options.js';
+import type { HttpClientOptions } from './http-client-options.js';
 import type { HttpClientRequestOptions } from './http-client-request.js';
 import { HttpClientRequest } from './http-client-request.js';
 import type { HttpClientResponse } from './http-client-response.js';
-import { HttpClientAdapter } from './http-client.adapter.js';
 import type { HttpClientMiddleware } from './middleware.js';
 export type HttpClientArgument = HttpClientOptions;
 export declare class HttpClient implements Resolvable<HttpClientArgument> {
     private readonly adapter;
-    private readonly headers;
     private readonly middleware;
+    private readonly headers;
     private readonly internalMiddleware;
     private callHandler;
     readonly options: HttpClientOptions;
     readonly [resolveArgumentType]: HttpClientOptions;
-    constructor(adapter: HttpClientAdapter, options?: HttpClientOptions, middlewares?: HttpClientMiddleware[]);
+    constructor();
     addMiddleware(middleware: HttpClientMiddleware): void;
     setDefaultHeader(name: string, value: OneOrMany<HttpValue>): void;
     deleteDefaultHeader(name: string): void;

package/http/client/http-client.js

@@ -34,7 +34,6 @@ var import_url_builder = require("../../utils/url-builder.js");
 var import_http_headers = require("../http-headers.js");
 var import_http_error = require("../http.error.js");
 var import_types = require("../types.js");
-var import_http_client_options = require("./http-client-options.js");
 var import_http_client_request = require("./http-client-request.js");
 var import_http_client_adapter = require("./http-client.adapter.js");
 var import_tokens = require("./tokens.js");
@@ -52,27 +51,18 @@ 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);
-  };
-};
 let HttpClient = class HttpClient2 {
-  adapter;
-  headers;
-  middleware;
+  adapter = (0, import_injector.inject)(import_http_client_adapter.HttpClientAdapter);
+  middleware = (0, import_injector.inject)(import_tokens.HTTP_CLIENT_MIDDLEWARES);
+  headers = new import_http_headers.HttpHeaders();
   internalMiddleware;
   callHandler;
-  options;
-  constructor(adapter, options = {}, middlewares = []) {
-    this.adapter = adapter;
-    this.options = options;
-    this.middleware = middlewares;
-    this.headers = new import_http_headers.HttpHeaders();
+  options = (0, import_injector.injectArgument)(this, { optional: true }) ?? {};
+  constructor() {
     this.internalMiddleware = [
-      getBuildRequestUrlMiddleware(options.baseUrl),
+      getBuildRequestUrlMiddleware(this.options.baseUrl),
       addRequestHeadersMiddleware,
-      ...options.enableErrorHandling ?? true ? [errorMiddleware] : []
+      ...this.options.enableErrorHandling ?? true ? [errorMiddleware] : []
     ];
     this.updateHandlers();
   }
@@ -226,11 +216,7 @@ let HttpClient = class HttpClient2 {
 };
 HttpClient = __decorate([
   (0, import_injector.Singleton)(),
-  __param(1, (0, import_injector.Optional)()),
-  __param(1, (0, import_injector.InjectArg)()),
-  __param(2, (0, import_injector.InjectAll)(import_tokens.HTTP_CLIENT_MIDDLEWARE)),
-  __param(2, (0, import_injector.Optional)()),
-  __metadata("design:paramtypes", [import_http_client_adapter.HttpClientAdapter, import_http_client_options.HttpClientOptions, Array])
+  __metadata("design:paramtypes", [])
 ], HttpClient);
 function getBuildRequestUrlMiddleware(baseUrl) {
   async function buildUrlParametersMiddleware(request, next) {

package/http/client/module.d.ts

@@ -1,4 +1,4 @@
-import type { Type } from '../../types.js';
+import type { OneOrMany, Type } from '../../types.js';
 import { HttpClientOptions } from './http-client-options.js';
 import { HttpClientAdapter } from './http-client.adapter.js';
 import type { HttpClientMiddleware } from './middleware.js';
@@ -7,6 +7,6 @@ export type HttpClientModuleConfig = HttpClientOptions & {
     /**
      * middlewares to add
      */
-    middleware?: HttpClientMiddleware[];
+    middleware?: OneOrMany<HttpClientMiddleware>;
 };
 export declare function configureHttpClient({ adapter, middleware, ...rest }: HttpClientModuleConfig): void;

package/http/client/module.js

@@ -22,6 +22,7 @@ __export(module_exports, {
 });
 module.exports = __toCommonJS(module_exports);
 var import_injector = require("../../injector/injector.js");
+var import_array = require("../../utils/array/array.js");
 var import_type_guards = require("../../utils/type-guards.js");
 var import_http_client_options = require("./http-client-options.js");
 var import_http_client_adapter = require("./http-client.adapter.js");
@@ -37,8 +38,8 @@ function configureHttpClient({ adapter, middleware, ...rest }) {
     enableErrorHandling: rest.enableErrorHandling ?? options.enableErrorHandling
   };
   if ((0, import_type_guards.isDefined)(middleware)) {
-    for (const m of middleware) {
-      import_injector.Injector.register(import_tokens.HTTP_CLIENT_MIDDLEWARE, { useToken: m }, { multi: true });
+    for (const m of (0, import_array.toArray)(middleware)) {
+      import_injector.Injector.register(import_tokens.HTTP_CLIENT_MIDDLEWARE, { useValue: m }, { multi: true });
     }
   }
   import_injector.Injector.register(import_http_client_options.HttpClientOptions, { useValue: options });

package/http/client/tokens.d.ts

@@ -1,2 +1,3 @@
 import type { HttpClientMiddleware } from './middleware.js';
 export declare const HTTP_CLIENT_MIDDLEWARE: import("../../injector/token.js").InjectionToken<HttpClientMiddleware, never>;
+export declare const HTTP_CLIENT_MIDDLEWARES: import("../../injector/token.js").InjectionToken<HttpClientMiddleware[], never>;

package/http/client/tokens.js

@@ -18,8 +18,12 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var tokens_exports = {};
 __export(tokens_exports, {
-  HTTP_CLIENT_MIDDLEWARE: () => HTTP_CLIENT_MIDDLEWARE
+  HTTP_CLIENT_MIDDLEWARE: () => HTTP_CLIENT_MIDDLEWARE,
+  HTTP_CLIENT_MIDDLEWARES: () => HTTP_CLIENT_MIDDLEWARES
 });
 module.exports = __toCommonJS(tokens_exports);
+var import_injector = require("../../injector/injector.js");
 var import_token = require("../../injector/token.js");
 const HTTP_CLIENT_MIDDLEWARE = (0, import_token.injectionToken)("HttpClientMiddleware");
+const HTTP_CLIENT_MIDDLEWARES = (0, import_token.injectionToken)("HttpClientMiddlewares");
+import_injector.Injector.register(HTTP_CLIENT_MIDDLEWARES, { useToken: HTTP_CLIENT_MIDDLEWARE, resolveAll: true });

package/injector/inject.d.ts

@@ -17,6 +17,14 @@ export type InjectionContext = {
     injectAsync<T, A>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: InjectOptions): Promise<T>;
     injectAllAsync<T, A>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: InjectOptions): Promise<T[]>;
 };
+export type InjectManyArrayItem<T, A> = [token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: InjectOptions];
+export type InjectManyItem<T, A> = InjectionToken<T, A> | InjectManyArrayItem<T, A>;
+export type InjectManyItemReturnType<T extends InjectManyItem<any, any>> = T extends InjectManyItem<infer U, any> ? U | (T extends (InjectManyArrayItem<any, any> & [any, any, {
+    optional: true;
+}]) ? undefined : never) : never;
+export type InjectManyReturnType<T extends InjectManyItem<any, any>[]> = {
+    [I in keyof T]: InjectManyItemReturnType<T[I]>;
+};
 /**
  * Resolves a token using the {@link Injector} of the current injection context
  *
@@ -27,7 +35,15 @@ export type InjectionContext = {
 export declare function inject<T = unknown, A = unknown>(token: InjectionToken<T, A>, argument: ResolveArgument<T, A>, options: InjectOptions & {
     optional: true;
 }): T | undefined;
-export declare function inject<T = unknown, A = unknown>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: InjectOptions): T;
+export declare function inject<T = unknown, A = unknown>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: InjectOptions & {
+    optional?: false;
+}): T;
+/**
+ * Resolves tokens using the {@link Injector} of the current injection context
+ *
+ * @param token tokens to resolve
+ */
+export declare function injectMany<T extends InjectManyItem<any, any>[]>(...tokens: T): InjectManyReturnType<T>;
 /**
  * Resolves a token using the {@link Injector} of the current injection context
  *
@@ -39,6 +55,12 @@ export declare function injectAsync<T = unknown, A = unknown>(token: InjectionTo
     optional: true;
 }): Promise<T | undefined>;
 export declare function injectAsync<T = unknown, A = unknown>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: InjectOptions): Promise<T>;
+/**
+ * Resolves tokens using the {@link Injector} of the current injection context
+ *
+ * @param token tokens to resolve
+ */
+export declare function injectManyAsync<T extends InjectManyItem<any, any>[]>(...tokens: T): Promise<InjectManyReturnType<T>>;
 /**
  * Resolves a token using the {@link Injector} of the current injection context
  *

package/injector/inject.js

@@ -26,11 +26,15 @@ __export(inject_exports, {
   injectAllAsync: () => injectAllAsync,
   injectArgument: () => injectArgument,
   injectAsync: () => injectAsync,
+  injectMany: () => injectMany,
+  injectManyAsync: () => injectManyAsync,
   isInInjectionContext: () => isInInjectionContext,
   runInInjectionContext: () => runInInjectionContext,
   setCurrentInjectionContext: () => setCurrentInjectionContext
 });
 module.exports = __toCommonJS(inject_exports);
+var import_map = require("../utils/async-iterable-helpers/map.js");
+var import_to_array = require("../utils/async-iterable-helpers/to-array.js");
 var import_type_guards = require("../utils/type-guards.js");
 var import_injector = require("./injector.js");
 let currentInjectionContext = null;
@@ -38,10 +42,18 @@ function inject(token, argument, options) {
   assertInInjectionContext(inject);
   return currentInjectionContext.inject(token, argument, options);
 }
+function injectMany(...tokens) {
+  assertInInjectionContext(inject);
+  return tokens.map((item) => (0, import_type_guards.isArray)(item) ? currentInjectionContext.inject(item[0], item[1], item[2]) : currentInjectionContext.inject(item));
+}
 async function injectAsync(token, argument, options) {
   assertInInjectionContext(inject);
   return currentInjectionContext.injectAsync(token, argument, options);
 }
+async function injectManyAsync(...tokens) {
+  assertInInjectionContext(inject);
+  return (0, import_to_array.toArrayAsync)((0, import_map.mapAsync)(tokens, async (item) => (0, import_type_guards.isArray)(item) ? currentInjectionContext.injectAsync(item[0], item[1], item[2]) : currentInjectionContext.injectAsync(item)));
+}
 function injectAll(token, argument, options) {
   assertInInjectionContext(injectAll);
   return currentInjectionContext.injectAll(token, argument, options);

package/injector/injector.js

@@ -21,13 +21,13 @@ __export(injector_exports, {
   Injector: () => Injector
 });
 module.exports = __toCommonJS(injector_exports);
+var import_cancellation = require("../cancellation/index.js");
 var import_circular_buffer = require("../data-structures/circular-buffer.js");
 var import_multi_key_map = require("../data-structures/multi-key-map.js");
 var import_disposable = require("../disposable/disposable.js");
 var import_deferred_promise = require("../promise/deferred-promise.js");
 var import_registry = require("../reflection/registry.js");
 var import_array = require("../utils/array/array.js");
-var import_cancellation = require("../cancellation/index.js");
 var import_factory_map = require("../utils/factory-map.js");
 var import_forward_ref = require("../utils/object/forward-ref.js");
 var import_object = require("../utils/object/object.js");

package/injector/provider.d.ts

@@ -20,20 +20,28 @@ export type ValueProvider<T = any> = {
 export type TokenProvider<T = any, A = any, D extends Record = Record> = ProviderWithArgument<T, A> & ProviderWithInitializer<T, A, D> & ({
     useToken: InjectionToken<T, A>;
     useTokenProvider?: undefined;
+    resolveAll?: false;
 } | {
     useToken?: undefined;
     useTokenProvider: () => InjectionToken<T, A>;
-}) & {
-    /**
-     * whether to resolve all providers registered for the token
-     */
-    resolveAll?: boolean;
-};
+    resolveAll?: false;
+} | {
+    useToken: InjectionToken<T extends (infer U)[] ? U : T, A>;
+    useTokenProvider?: undefined;
+    resolveAll: true;
+} | {
+    useToken?: undefined;
+    useTokenProvider: () => InjectionToken<T extends (infer U)[] ? U : T, A>;
+    resolveAll: true;
+});
 export type FactoryProvider<T = any, A = unknown, D extends Record = Record> = ProviderWithArgument<T, A> & ProviderWithInitializer<T, A, D> & {
     useFactory: Factory<T, A, D>;
 };
 export declare function classProvider<T, A, D extends Record>(constructor: Constructor<T>, options?: TypedOmit<ClassProvider<T, A, D>, 'useClass'>): ClassProvider<T, A, D>;
 export declare function valueProvider<T>(value: T, options?: TypedOmit<ValueProvider<T>, 'useValue'>): ValueProvider<T>;
+export declare function tokenProvider<T, A, D extends Record>(token: InjectionToken<T, A>, options: TypedOmit<TokenProvider<T, A, D>, 'useToken' | 'useTokenProvider'> & {
+    resolveAll: true;
+}): TokenProvider<T[]>;
 export declare function tokenProvider<T, A, D extends Record>(token: InjectionToken<T, A>, options?: TypedOmit<TokenProvider<T, A, D>, 'useToken' | 'useTokenProvider'>): TokenProvider<T>;
 export declare function factoryProvider<T, A, D extends Record>(factory: Factory<T, A, D>, options?: TypedOmit<FactoryProvider<T, A, D>, 'useFactory'>): FactoryProvider<T, A, D>;
 export declare function isClassProvider<T, A>(value: Provider<T, A>): value is ClassProvider<T, A>;

package/injector/token.d.ts

@@ -1,10 +1,10 @@
 import type { AbstractConstructor } from '../types.js';
 declare const type: unique symbol;
 declare const argument: unique symbol;
+export type SimpleInjectionToken<T> = AbstractConstructor<T>;
 export type ArgumentedInjectionToken<T, A> = SimpleInjectionToken<T> & {
     [argument]: A;
 };
-export type SimpleInjectionToken<T> = AbstractConstructor<T> | object;
 export type InjectionToken<T = any, A = any> = SimpleInjectionToken<T> | ArgumentedInjectionToken<T, A> | ReifyingInjectionToken<T, A>;
 export type InjectionTokenArgument<T extends ArgumentedInjectionToken<any, any> | ReifyingInjectionToken> = T[typeof argument];
 export declare class ReifyingInjectionToken<T = any, A = any> {

package/logger/console/logger.js

@@ -27,6 +27,7 @@ var import_format_error = require("../../utils/format-error.js");
 var import_type_guards = require("../../utils/type-guards.js");
 var import_level = require("../level.js");
 var import_logger = require("../logger.js");
+var import_tokens = require("../tokens.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")
@@ -79,9 +80,9 @@ ConsoleLogger = ConsoleLogger_1 = __decorate([
     provider: {
       useFactory: (argument, context) => {
         if ((0, import_type_guards.isObject)(argument)) {
-          return new ConsoleLogger(argument.level ?? context.resolve(import_level.LogLevel), argument.module, argument.prefix);
+          return new ConsoleLogger(argument.level ?? context.resolve(import_tokens.LOG_LEVEL), argument.module, argument.prefix);
         }
-        return new ConsoleLogger(context.resolve(import_level.LogLevel), argument, void 0);
+        return new ConsoleLogger(context.resolve(import_tokens.LOG_LEVEL), argument, void 0);
       }
     }
   }),

package/logger/index.d.ts

@@ -1,2 +1,3 @@
 export * from './level.js';
 export * from './logger.js';
+export * from './tokens.js';

package/logger/index.js

@@ -17,3 +17,4 @@ var logger_exports = {};
 module.exports = __toCommonJS(logger_exports);
 __reExport(logger_exports, require("./level.js"), module.exports);
 __reExport(logger_exports, require("./logger.js"), module.exports);
+__reExport(logger_exports, require("./tokens.js"), module.exports);

package/logger/tokens.d.ts

@@ -0,0 +1,2 @@
+import type { LogLevel } from './level.js';
+export declare const LOG_LEVEL: import("../injector/token.js").InjectionToken<LogLevel, never>;

package/logger/tokens.js

@@ -0,0 +1,25 @@
+"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 tokens_exports = {};
+__export(tokens_exports, {
+  LOG_LEVEL: () => LOG_LEVEL
+});
+module.exports = __toCommonJS(tokens_exports);
+var import_token = require("../injector/token.js");
+const LOG_LEVEL = (0, import_token.injectionToken)("log level");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.87.3",
+  "version": "0.87.5",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -34,8 +34,8 @@
     "@types/mjml": "4.7",
     "@types/node": "20",
     "@types/nodemailer": "6.4",
-    "@typescript-eslint/eslint-plugin": "6.5",
-    "@typescript-eslint/parser": "6.5",
+    "@typescript-eslint/eslint-plugin": "6.6",
+    "@typescript-eslint/parser": "6.6",
     "concurrently": "8.2",
     "esbuild": "0.19",
     "eslint": "8.48",