@tstdl/base 0.84.2 → 0.84.4

package/.eslintrc.json

@@ -24,10 +24,6 @@
   },
   "plugins": ["@typescript-eslint"],
   "rules": {
-    /** angular */
-    "@angular-eslint/template/eqeqeq": "off",
-    "@angular-eslint/no-host-metadata-property": ["error", { "allowStatic": true }],
-
     /** typescript */
     "@typescript-eslint/brace-style": ["error", "stroustrup", { "allowSingleLine": true }],
     "@typescript-eslint/consistent-type-definitions": "off",

package/browser/document-controller.d.ts

@@ -0,0 +1,26 @@
+import type { ElementHandle, Frame, Page } from 'playwright';
+import type { Delay } from './element-controller.js';
+import type { FrameController, FrameControllerOptions } from './frame-controller.js';
+import { LocatorController } from './locator-controller.js';
+import type { PageControllerOptions } from './page-controller.js';
+export type DocumentControllerOptions = {
+    defaultActionDelay?: Delay;
+    defaultTypeDelay?: Delay;
+};
+export type DocumentControllerForwardOptions = {
+    pageControllerOptions: PageControllerOptions;
+    frameControllerOptions: FrameControllerOptions;
+};
+export declare class DocumentController extends LocatorController {
+    protected readonly forwardOptions: DocumentControllerForwardOptions;
+    /** @deprecated should be avoided */
+    readonly document: Page | Frame;
+    constructor(document: Page | Frame, options: DocumentControllerOptions, forwardOptions: DocumentControllerForwardOptions);
+    setContent(...args: Parameters<Page['setContent']>): Promise<void>;
+    navigate(...args: Parameters<Page['goto']>): Promise<void>;
+    waitForLoadState(...args: Parameters<Page['waitForLoadState']>): Promise<void>;
+    waitForUrl(...args: Parameters<Page['waitForURL']>): Promise<void>;
+    waitForElement(selector: string, options?: Parameters<Page['waitForSelector']>[1]): Promise<ElementHandle>;
+    getInFrame(frameSelector: string): LocatorController;
+    waitForFrame(selector: string, options?: Parameters<Page['waitForSelector']>[1]): Promise<FrameController>;
+}

package/browser/document-controller.js

@@ -0,0 +1,88 @@
+"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 __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 __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 document_controller_exports = {};
+__export(document_controller_exports, {
+  DocumentController: () => DocumentController
+});
+module.exports = __toCommonJS(document_controller_exports);
+var import_type_guards = require("../utils/type-guards.js");
+var import_locator_controller = require("./locator-controller.js");
+class DocumentController extends import_locator_controller.LocatorController {
+  forwardOptions;
+  /** @deprecated should be avoided */
+  document;
+  constructor(document, options, forwardOptions) {
+    super(document, { actionDelay: options.defaultActionDelay, typeDelay: options.defaultTypeDelay });
+    this.document = document;
+    this.forwardOptions = forwardOptions;
+  }
+  async setContent(...args) {
+    await this.document.setContent(...args);
+  }
+  async navigate(...args) {
+    await this.document.goto(...args);
+  }
+  async waitForLoadState(...args) {
+    await this.document.waitForLoadState(...args);
+  }
+  async waitForUrl(...args) {
+    await this.document.waitForURL(...args);
+  }
+  async waitForElement(selector, options) {
+    const element = await this.document.waitForSelector(selector, options);
+    if ((0, import_type_guards.isNull)(element)) {
+      throw new Error("Element not found.");
+    }
+    return element;
+  }
+  getInFrame(frameSelector) {
+    const locator = this.document.frameLocator(frameSelector);
+    return new import_locator_controller.LocatorController(locator, this.elementControllerOptions);
+  }
+  async waitForFrame(selector, options) {
+    const element = await this.waitForElement(selector, options);
+    const frame = await element.contentFrame();
+    if ((0, import_type_guards.isNull)(frame)) {
+      throw new Error("Element is not a frame.");
+    }
+    return newFrameController(frame, this.forwardOptions.frameControllerOptions, { pageControllerOptions: this.forwardOptions.pageControllerOptions });
+  }
+}
+let frameControllerConstructor;
+async function newFrameController(...args) {
+  if ((0, import_type_guards.isUndefined)(frameControllerConstructor)) {
+    frameControllerConstructor = importFrameController();
+    void frameControllerConstructor.then((constructor) => frameControllerConstructor = constructor);
+  }
+  return new (await frameControllerConstructor)(...args);
+}
+async function importFrameController() {
+  const module2 = await import("./frame-controller.js");
+  return module2.FrameController;
+}

package/browser/element-controller.d.ts

@@ -1,7 +1,6 @@
+import type { ElementHandle, Locator } from 'playwright';
 import type { Merge, NonUndefinable, TypedOmit } from '../types.js';
 import type { ValueOrProvider } from '../utils/value-or-provider.js';
-import type { ElementHandle, Locator } from 'playwright';
-import { PageController } from './page-controller.js';
 export type Delay = ValueOrProvider<number>;
 export type ActionDelayOptions = {
     actionDelay?: Delay;
@@ -19,19 +18,14 @@ export type ElementControllerOptions = {
 type LocatorOptions<K extends keyof Locator, I extends keyof Parameters<Locator[K]>> = NonUndefinable<Parameters<Locator[K]>[I]>;
 export declare class ElementController {
     readonly locatorOrHandle: Locator | ElementHandle;
-    readonly pageController: PageController;
     readonly options: ElementControllerOptions;
-    constructor(locatorOrHandle: Locator | ElementHandle, pageController: PageController, options?: ElementControllerOptions);
+    constructor(locatorOrHandle: Locator | ElementHandle, options?: ElementControllerOptions);
     waitFor(options?: Parameters<Locator['waitFor']>[0]): Promise<void>;
     fill(text: string, options?: Merge<LocatorOptions<'fill', 1>, ActionDelayOptions>): Promise<void>;
     type(text: string, options?: Merge<TypedOmit<LocatorOptions<'type', 1>, 'delay'>, ActionDelayOptions & TypeDelayOptions>): Promise<void>;
     selectOption(value: string | string[], options?: Merge<LocatorOptions<'selectOption', 1>, ActionDelayOptions>): Promise<void>;
     click(options?: Merge<TypedOmit<LocatorOptions<'click', 0>, 'delay'>, ActionDelayOptions & ClickDelayOptions>): Promise<void>;
     getValue(options?: LocatorOptions<'inputValue', 0>): Promise<string>;
-    /**
-     * Get PageController for element. Element must be a frame.
-     */
-    getPage(options?: LocatorOptions<'elementHandle', 0>): Promise<PageController>;
     private prepareAction;
 }
 export {};

package/browser/element-controller.js

@@ -24,15 +24,11 @@ module.exports = __toCommonJS(element_controller_exports);
 var import_timing = require("../utils/timing.js");
 var import_type_guards = require("../utils/type-guards.js");
 var import_value_or_provider = require("../utils/value-or-provider.js");
-var import_page_controller = require("./page-controller.js");
-var import_utils = require("./utils.js");
 class ElementController {
   locatorOrHandle;
-  pageController;
   options;
-  constructor(locatorOrHandle, pageController, options = {}) {
+  constructor(locatorOrHandle, options = {}) {
     this.locatorOrHandle = locatorOrHandle;
-    this.pageController = pageController;
     this.options = options;
   }
   async waitFor(options) {
@@ -67,18 +63,6 @@ class ElementController {
   async getValue(options) {
     return this.locatorOrHandle.inputValue(options);
   }
-  /**
-   * Get PageController for element. Element must be a frame.
-   */
-  async getPage(options) {
-    const handle = (0, import_utils.isLocator)(this.locatorOrHandle) ? await this.locatorOrHandle.elementHandle(options) : this.locatorOrHandle;
-    if ((0, import_type_guards.isNull)(handle)) {
-      throw new Error("Could not get element handle.");
-    }
-    const frame = await this.locatorOrHandle.contentFrame();
-    (0, import_type_guards.assertNotNull)(frame, "Could not get content frame for element handle.");
-    return new import_page_controller.PageController(frame.page(), this.pageController.options);
-  }
   async prepareAction(options) {
     await delay(options?.actionDelay ?? this.options.actionDelay);
   }

package/browser/frame-controller.d.ts

@@ -0,0 +1,23 @@
+import type { Frame, Page } from 'playwright';
+import type { DocumentControllerOptions } from './document-controller.js';
+import { DocumentController } from './document-controller.js';
+import type { PageControllerOptions } from './page-controller.js';
+import { PageController } from './page-controller.js';
+export type FrameControllerOptions = DocumentControllerOptions;
+export type FrameControllerForwardOptions = {
+    pageControllerOptions: PageControllerOptions;
+};
+export declare class FrameController extends DocumentController {
+    private readonly frameControllerForwardOptions;
+    /** @deprecated should be avoided */
+    readonly frame: Frame;
+    readonly options: FrameControllerOptions;
+    constructor(frame: Frame, options: FrameControllerOptions, forwardOptions: FrameControllerForwardOptions);
+    /** Get the page containing this frame */
+    getPage(): PageController;
+    /**
+     * @param frameSelector frame name, url or url predicate
+     * @returns
+     */
+    getFrame(frameSelector: Parameters<Page['frame']>[0]): FrameController;
+}

package/browser/frame-controller.js

@@ -0,0 +1,52 @@
+"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 frame_controller_exports = {};
+__export(frame_controller_exports, {
+  FrameController: () => FrameController
+});
+module.exports = __toCommonJS(frame_controller_exports);
+var import_type_guards = require("../utils/type-guards.js");
+var import_document_controller = require("./document-controller.js");
+var import_page_controller = require("./page-controller.js");
+class FrameController extends import_document_controller.DocumentController {
+  frameControllerForwardOptions;
+  /** @deprecated should be avoided */
+  frame;
+  options;
+  constructor(frame, options, forwardOptions) {
+    super(frame, options, { frameControllerOptions: options, pageControllerOptions: forwardOptions.pageControllerOptions });
+    this.options = options;
+    this.frameControllerForwardOptions = forwardOptions;
+  }
+  /** Get the page containing this frame */
+  getPage() {
+    return new import_page_controller.PageController(this.frame.page(), this.frameControllerForwardOptions.pageControllerOptions);
+  }
+  /**
+   * @param frameSelector frame name, url or url predicate
+   * @returns
+   */
+  getFrame(frameSelector) {
+    const frame = this.frame.page().frame(frameSelector);
+    if ((0, import_type_guards.isNull)(frame)) {
+      throw new Error("Frame not found.");
+    }
+    return new FrameController(frame, this.options, this.frameControllerForwardOptions);
+  }
+}

package/browser/index.d.ts

@@ -1,6 +1,9 @@
 export * from './browser-context-controller.js';
 export * from './browser-controller.js';
 export * from './browser.service.js';
+export * from './document-controller.js';
 export * from './element-controller.js';
+export * from './frame-controller.js';
+export * from './locator-controller.js';
 export * from './page-controller.js';
 export * from './types.js';

package/browser/index.js

@@ -18,6 +18,9 @@ module.exports = __toCommonJS(browser_exports);
 __reExport(browser_exports, require("./browser-context-controller.js"), module.exports);
 __reExport(browser_exports, require("./browser-controller.js"), module.exports);
 __reExport(browser_exports, require("./browser.service.js"), module.exports);
+__reExport(browser_exports, require("./document-controller.js"), module.exports);
 __reExport(browser_exports, require("./element-controller.js"), module.exports);
+__reExport(browser_exports, require("./frame-controller.js"), module.exports);
+__reExport(browser_exports, require("./locator-controller.js"), module.exports);
 __reExport(browser_exports, require("./page-controller.js"), module.exports);
 __reExport(browser_exports, require("./types.js"), module.exports);

package/browser/locator-controller.d.ts

@@ -0,0 +1,16 @@
+import type { Frame, FrameLocator, Locator, Page } from 'playwright';
+import type { NonUndefinable, SimplifyObject } from '../types.js';
+import type { ElementControllerOptions } from './element-controller.js';
+import { ElementController } from './element-controller.js';
+export declare class LocatorController {
+    protected readonly elementControllerOptions: ElementControllerOptions;
+    readonly locatable: Page | Frame | Locator | FrameLocator;
+    constructor(locatable: Page | Frame | Locator | FrameLocator, elementControllerOptions: ElementControllerOptions);
+    getBySelector(selector: string, options?: SimplifyObject<Pick<NonUndefinable<Parameters<Page['locator']>[1]>, 'hasText' | 'hasNotText'>>): ElementController;
+    getByRole(role: Parameters<Page['getByRole']>[0], options?: Parameters<Page['getByRole']>[1]): ElementController;
+    getByLabel(text: Parameters<Page['getByLabel']>[0], options?: Parameters<Page['getByLabel']>[1]): ElementController;
+    getByAltText(text: Parameters<Page['getByAltText']>[0], options?: Parameters<Page['getByAltText']>[1]): ElementController;
+    getByPlaceholder(text: Parameters<Page['getByPlaceholder']>[0], options?: Parameters<Page['getByPlaceholder']>[1]): ElementController;
+    getByText(text: Parameters<Page['getByText']>[0], options?: Parameters<Page['getByText']>[1]): ElementController;
+    getByTitle(text: Parameters<Page['getByTitle']>[0], options?: Parameters<Page['getByTitle']>[1]): ElementController;
+}

package/browser/locator-controller.js

@@ -0,0 +1,60 @@
+"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 locator_controller_exports = {};
+__export(locator_controller_exports, {
+  LocatorController: () => LocatorController
+});
+module.exports = __toCommonJS(locator_controller_exports);
+var import_element_controller = require("./element-controller.js");
+class LocatorController {
+  elementControllerOptions;
+  locatable;
+  constructor(locatable, elementControllerOptions) {
+    this.locatable = locatable;
+    this.elementControllerOptions = elementControllerOptions;
+  }
+  getBySelector(selector, options) {
+    const locator = this.locatable.locator(selector, options);
+    return new import_element_controller.ElementController(locator, this.elementControllerOptions);
+  }
+  getByRole(role, options) {
+    const locator = this.locatable.getByRole(role, options);
+    return new import_element_controller.ElementController(locator, this.elementControllerOptions);
+  }
+  getByLabel(text, options) {
+    const locator = this.locatable.getByLabel(text, options);
+    return new import_element_controller.ElementController(locator, this.elementControllerOptions);
+  }
+  getByAltText(text, options) {
+    const locator = this.locatable.getByAltText(text, options);
+    return new import_element_controller.ElementController(locator, this.elementControllerOptions);
+  }
+  getByPlaceholder(text, options) {
+    const locator = this.locatable.getByPlaceholder(text, options);
+    return new import_element_controller.ElementController(locator, this.elementControllerOptions);
+  }
+  getByText(text, options) {
+    const locator = this.locatable.getByText(text, options);
+    return new import_element_controller.ElementController(locator, this.elementControllerOptions);
+  }
+  getByTitle(text, options) {
+    const locator = this.locatable.getByTitle(text, options);
+    return new import_element_controller.ElementController(locator, this.elementControllerOptions);
+  }
+}

package/browser/page-controller.d.ts

@@ -1,36 +1,29 @@
 import type { Page } from 'playwright';
 import type { AsyncDisposable } from '../disposable/disposable.js';
 import { disposeAsync } from '../disposable/disposable.js';
-import type { NonUndefinable, SimplifyObject } from '../types.js';
-import type { Delay } from './element-controller.js';
-import { ElementController } from './element-controller.js';
+import type { DocumentControllerOptions } from './document-controller.js';
+import { DocumentController } from './document-controller.js';
+import type { FrameControllerOptions } from './frame-controller.js';
+import { FrameController } from './frame-controller.js';
 import type { PdfRenderOptions } from './pdf-options.js';
 import type { Abortable } from './types.js';
-export type PageControllerOptions = {
-    defaultActionDelay?: Delay;
-    defaultTypeDelay?: Delay;
+export type PageControllerOptions = DocumentControllerOptions & {
+    defaultFrameControllerOptions?: FrameControllerOptions;
 };
-export declare class PageController implements AsyncDisposable {
-    private readonly elementControllerOptions;
+export declare class PageController extends DocumentController implements AsyncDisposable {
     /** @deprecated should be avoided */
     readonly page: Page;
     readonly options: PageControllerOptions;
     constructor(page: Page, options?: PageControllerOptions);
     [disposeAsync](): Promise<void>;
     close(): Promise<void>;
-    setContent(...args: Parameters<Page['setContent']>): Promise<void>;
     setExtraHttpHeaders(headers: Record<string, string>): Promise<void>;
-    navigate(...args: Parameters<Page['goto']>): Promise<void>;
     waitForClose(): Promise<void>;
-    waitForLoadState(...args: Parameters<Page['waitForLoadState']>): Promise<void>;
-    waitForUrl(...args: Parameters<Page['waitForURL']>): Promise<void>;
-    getBySelector(selector: string, options?: SimplifyObject<Pick<NonUndefinable<Parameters<Page['locator']>[1]>, 'hasText' | 'hasNotText'>>): ElementController;
-    getByRole(role: Parameters<Page['getByRole']>[0], options?: Parameters<Page['getByRole']>[1]): ElementController;
-    getByLabel(text: Parameters<Page['getByLabel']>[0], options?: Parameters<Page['getByLabel']>[1]): ElementController;
-    getByAltText(text: Parameters<Page['getByAltText']>[0], options?: Parameters<Page['getByAltText']>[1]): ElementController;
-    getByPlaceholder(text: Parameters<Page['getByPlaceholder']>[0], options?: Parameters<Page['getByPlaceholder']>[1]): ElementController;
-    getByText(text: Parameters<Page['getByText']>[0], options?: Parameters<Page['getByText']>[1]): ElementController;
-    getByTitle(text: Parameters<Page['getByTitle']>[0], options?: Parameters<Page['getByTitle']>[1]): ElementController;
+    /**
+     * @param frameSelector frame name, url or url predicate
+     * @returns
+     */
+    getFrame(frameSelector: Parameters<Page['frame']>[0]): FrameController;
     renderPdf(options?: PdfRenderOptions & Abortable): Promise<Uint8Array>;
     renderPdfStream(options?: PdfRenderOptions & Abortable): ReadableStream<Uint8Array>;
 }

package/browser/page-controller.js

@@ -26,16 +26,16 @@ var import_readable_stream_from_promise = require("../utils/stream/readable-stre
 var import_timing = require("../utils/timing.js");
 var import_type_guards = require("../utils/type-guards.js");
 var import_units = require("../utils/units.js");
-var import_element_controller = require("./element-controller.js");
-class PageController {
-  elementControllerOptions;
+var import_document_controller = require("./document-controller.js");
+var import_frame_controller = require("./frame-controller.js");
+class PageController extends import_document_controller.DocumentController {
   /** @deprecated should be avoided */
   page;
   options;
   constructor(page, options = {}) {
+    super(page, options, { pageControllerOptions: options, frameControllerOptions: options.defaultFrameControllerOptions ?? options });
     this.page = page;
     this.options = options;
-    this.elementControllerOptions = { actionDelay: this.options.defaultActionDelay, typeDelay: this.options.defaultTypeDelay };
   }
   async [import_disposable.disposeAsync]() {
     await this.close();
@@ -43,15 +43,9 @@ class PageController {
   async close() {
     await this.page.close();
   }
-  async setContent(...args) {
-    await this.page.setContent(...args);
-  }
   async setExtraHttpHeaders(headers) {
     await this.page.setExtraHTTPHeaders(headers);
   }
-  async navigate(...args) {
-    await this.page.goto(...args);
-  }
   async waitForClose() {
     return new Promise((resolve) => {
       if (this.page.isClosed()) {
@@ -61,39 +55,16 @@ class PageController {
       this.page.once("close", () => resolve());
     });
   }
-  async waitForLoadState(...args) {
-    await this.page.waitForLoadState(...args);
-  }
-  async waitForUrl(...args) {
-    await this.page.waitForURL(...args);
-  }
-  getBySelector(selector, options) {
-    const locator = this.page.locator(selector, options);
-    return new import_element_controller.ElementController(locator, this, this.elementControllerOptions);
-  }
-  getByRole(role, options) {
-    const locator = this.page.getByRole(role, options);
-    return new import_element_controller.ElementController(locator, this, this.elementControllerOptions);
-  }
-  getByLabel(text, options) {
-    const locator = this.page.getByLabel(text, options);
-    return new import_element_controller.ElementController(locator, this, this.elementControllerOptions);
-  }
-  getByAltText(text, options) {
-    const locator = this.page.getByAltText(text, options);
-    return new import_element_controller.ElementController(locator, this, this.elementControllerOptions);
-  }
-  getByPlaceholder(text, options) {
-    const locator = this.page.getByPlaceholder(text, options);
-    return new import_element_controller.ElementController(locator, this, this.elementControllerOptions);
-  }
-  getByText(text, options) {
-    const locator = this.page.getByText(text, options);
-    return new import_element_controller.ElementController(locator, this, this.elementControllerOptions);
-  }
-  getByTitle(text, options) {
-    const locator = this.page.getByTitle(text, options);
-    return new import_element_controller.ElementController(locator, this, this.elementControllerOptions);
+  /**
+   * @param frameSelector frame name, url or url predicate
+   * @returns
+   */
+  getFrame(frameSelector) {
+    const frame = this.page.frame(frameSelector);
+    if ((0, import_type_guards.isNull)(frame)) {
+      throw new Error("Frame not found.");
+    }
+    return new import_frame_controller.FrameController(frame, this.options, this.forwardOptions);
   }
   async renderPdf(options = {}) {
     const createPdfOptions = convertPdfOptions(options);

package/core.d.ts

@@ -4,9 +4,12 @@ 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 disposer: AsyncDisposer;
+export declare function isDevMode(): boolean;
+export declare function enableProductionMode(): void;
 export declare function connect(name: string, connectFunction: (() => Promise<any>), logger: Logger, maxTries?: number): Promise<void>;
 export declare function disposeInstances(): Promise<void>;
 export type CoreConfiguration = {
+    production?: boolean;
     logger?: InjectionToken<Logger, LoggerArgument>;
     logLevel?: LogLevel;
     coreLogPrefix?: string;

package/core.js

@@ -22,7 +22,9 @@ __export(core_exports, {
   configureTstdl: () => configureTstdl,
   connect: () => connect,
   disposeInstances: () => disposeInstances,
-  disposer: () => disposer
+  disposer: () => disposer,
+  enableProductionMode: () => enableProductionMode,
+  isDevMode: () => isDevMode
 });
 module.exports = __toCommonJS(core_exports);
 var import_container = require("./container/index.js");
@@ -33,6 +35,13 @@ var import_timing = require("./utils/timing.js");
 var import_type_guards = require("./utils/type-guards.js");
 const CORE_LOGGER = (0, import_container.injectionToken)("core logger");
 const disposer = new import_async_disposer.AsyncDisposer();
+let _isDevMode = true;
+function isDevMode() {
+  return _isDevMode;
+}
+function enableProductionMode() {
+  _isDevMode = false;
+}
 async function connect(name, connectFunction, logger, maxTries = 5) {
   let triesLeft = maxTries;
   let success = false;
@@ -57,6 +66,9 @@ async function disposeInstances() {
 }
 let coreLogPrefix;
 function configureTstdl(config = {}) {
+  if (config.production == true) {
+    enableProductionMode();
+  }
   import_container.container.register(import_logger2.Logger, { useToken: config.logger ?? import_logger.ConsoleLogger });
   import_container.container.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)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.84.2",
+  "version": "0.84.4",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -23,7 +23,7 @@
     "luxon": "^3.3",
     "reflect-metadata": "^0.1",
     "rxjs": "^7.8",
-    "type-fest": "^3.9"
+    "type-fest": "^3.10"
   },
   "devDependencies": {
     "@types/chroma-js": "2.4",
@@ -31,13 +31,13 @@
     "@types/luxon": "3.3",
     "@types/minio": "7.0",
     "@types/mjml": "4.7",
-    "@types/node": "18",
+    "@types/node": "20",
     "@types/nodemailer": "6.4",
     "@typescript-eslint/eslint-plugin": "5.59",
     "@typescript-eslint/parser": "5.59",
     "concurrently": "8.0",
     "esbuild": "0.17",
-    "eslint": "8.39",
+    "eslint": "8.40",
     "eslint-import-resolver-typescript": "3.5",
     "eslint-plugin-import": "2.27",
     "tsc-alias": "1.8",
@@ -58,7 +58,7 @@
     "koa": "^2.14",
     "minio": "^7.1",
     "mjml": "^4.14",
-    "mongodb": "^5.3",
+    "mongodb": "^5.4",
     "nodemailer": "^6.9",
     "playwright": "^1.33",
     "preact": "^10.13",

package/schema/coercers/uint8-array.coercer.js

@@ -32,7 +32,7 @@ class Uint8ArrayCoercer extends import_types.SchemaValueCoercer {
   sourceType = Array;
   targetType = Uint8Array;
   coerce(value, path, { options }) {
-    const testResult = (0, import_schema.testWithFastError)(byteNumberArraySchema, value, options, path);
+    const testResult = (0, import_schema.testSchema)(byteNumberArraySchema, value, options, path);
     if (!testResult.valid) {
       return { success: false, error: import_schema_error.SchemaError.couldNotCoerce(Uint8Array, Array, path, { inner: testResult.error, fast: options.fastErrors }) };
     }

package/schema/schema.d.ts

@@ -11,4 +11,5 @@ export declare const Schema: {
     function<T_3 extends readonly SchemaTestable<any>[], R extends SchemaTestable<any>, F extends (...args: TupleSchemaOutput<T_3>) => SchemaOutput<R>>(argumentSchemas: T_3, returnSchema: R, handler: F): F;
     asyncFunction<T_4 extends readonly SchemaTestable<any>[], R_1 extends SchemaTestable<any>, F_1 extends (...args: TupleSchemaOutput<T_4>) => Promise<SchemaOutput<R_1>>>(argumentSchemas: T_4, returnSchema: R_1, handler: F_1): F_1;
 };
-export declare function testWithFastError<T>(schema: Schema<T>, value: unknown, options?: SchemaTestOptions, path?: JsonPath): SchemaTestResult<T>;
+export declare function testSchema<T>(schema: Schema<T>, value: unknown, options?: SchemaTestOptions, path?: JsonPath): SchemaTestResult<T>;
+export declare function getExpectString(schema: SchemaTestable): string;

package/schema/schema.error.js

@@ -24,6 +24,7 @@ module.exports = __toCommonJS(schema_error_exports);
 var import_custom_error = require("../error/custom.error.js");
 var import_array = require("../utils/array/array.js");
 var import_type_guards = require("../utils/type-guards.js");
+var import_schema = require("./schema.js");
 var import_utils = require("./utils/index.js");
 class SchemaError extends import_custom_error.CustomError {
   static errorName = "SchemaError";
@@ -42,9 +43,9 @@ class SchemaError extends import_custom_error.CustomError {
   }
   // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
   static expectedButGot(expected, got, path, options) {
-    const expectedNames = (0, import_array.toArray)(expected).map((exp) => (0, import_type_guards.isString)(exp) ? exp : (0, import_utils.getValueTypeName)(exp));
+    const expectedNames = (0, import_array.toArray)(expected).map((exp) => (0, import_type_guards.isString)(exp) ? exp : (0, import_schema.getExpectString)(exp));
     const gotName = (0, import_type_guards.isString)(got) ? got : (0, import_utils.getValueTypeName)(got);
-    const expectedString = expectedNames.length == 1 ? expectedNames[0] : `[${expectedNames.join(", ")}]`;
+    const expectedString = expectedNames.length == 1 ? expectedNames[0] : `(${expectedNames.join(" | ")})`;
     const customMessage = (0, import_type_guards.isDefined)(options.customMessage) ? `: ${options.customMessage}` : ".";
     const message = `Expected ${expectedString} but got ${gotName}${customMessage}`;
     return new SchemaError(message, { path, ...options });

package/schema/schema.js

@@ -19,7 +19,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var schema_exports = {};
 __export(schema_exports, {
   Schema: () => Schema,
-  testWithFastError: () => testWithFastError
+  getExpectString: () => getExpectString,
+  testSchema: () => testSchema
 });
 module.exports = __toCommonJS(schema_exports);
 var import_json_path = require("../json-path/index.js");
@@ -54,14 +55,14 @@ const Schema = {
   test(schemaOrValueType, value, options, path = import_json_path.JsonPath.ROOT) {
     const normalizedOptions = { fastErrors: true, ...options };
     const schema = (0, import_types.schemaTestableToSchema)(schemaOrValueType);
-    const result = testWithFastError(schema, value, normalizedOptions, path);
+    const result = testSchema(schema, value, normalizedOptions, path);
     if (result.valid) {
       return result;
     }
-    if (options?.fastErrors == false) {
-      return result;
+    if ((0, import_type_guards.isUndefined)(result.error.stack)) {
+      result.error.stack = new Error().stack;
     }
-    return { valid: false, error: new import_schema_error.SchemaError(result.error.message, { ...result.error }) };
+    return result;
   },
   validate(schemaOrValueType, value, options) {
     const schema = (0, import_types.schemaTestableToSchema)(schemaOrValueType);
@@ -107,7 +108,7 @@ function getFunctionParametersSchema(argumentSchemas) {
   argumentSchemas.forEach((arg, index) => schema.properties[index] = arg);
   return schema;
 }
-function testWithFastError(schema, value, options, path = import_json_path.JsonPath.ROOT) {
+function testSchema(schema, value, options, path = import_json_path.JsonPath.ROOT) {
   initialize();
   if ((0, import_types.isValueSchema)(schema)) {
     return testValue(schema, value, options, path);
@@ -122,9 +123,7 @@ function testWithFastError(schema, value, options, path = import_json_path.JsonP
 }
 function testType(schema, value, options = {}, path = import_json_path.JsonPath.ROOT) {
   const resolvedValueType = (0, import_types.resolveValueType)(schema.type);
-  if (resolvedValueType == "any") {
-    return { valid: true, value };
-  } else if ((0, import_type_guards.isFunction)(resolvedValueType)) {
+  if ((0, import_type_guards.isFunction)(resolvedValueType)) {
     if (value instanceof resolvedValueType || (0, import_utils.getValueType)(value) == resolvedValueType) {
       return { valid: true, value };
     }
@@ -132,7 +131,7 @@ function testType(schema, value, options = {}, path = import_json_path.JsonPath.
     if ((0, import_type_guards.isNotNull)(objectSchema)) {
       return testObject(objectSchema, value, options, path);
     }
-  } else if (resolvedValueType == "null" && (0, import_type_guards.isNull)(value) || resolvedValueType == "undefined" && (0, import_type_guards.isUndefined)(value) || resolvedValueType == "any") {
+  } else if (resolvedValueType == "any" || resolvedValueType == "null" && (0, import_type_guards.isNull)(value) || resolvedValueType == "undefined" && (0, import_type_guards.isUndefined)(value)) {
     return { valid: true, value };
   }
   return { valid: false, error: import_schema_error.SchemaError.expectedButGot(resolvedValueType, (0, import_utils.getValueType)(value), path, { fast: options.fastErrors }) };
@@ -151,7 +150,7 @@ function testObject(objectSchema, value, options = {}, path = import_json_path.J
     return { valid: false, error: new import_schema_error.SchemaError("Unknown property", { path: path.add(unknownValuePropertyKeys[0]), fast: options.fastErrors }) };
   }
   for (const key of schemaPropertyKeys) {
-    const propertyResult = testWithFastError(schema.properties[key], value[key], options, path.add(key));
+    const propertyResult = testSchema(schema.properties[key], value[key], options, path.add(key));
     if (!propertyResult.valid) {
       return propertyResult;
     }
@@ -161,12 +160,12 @@ function testObject(objectSchema, value, options = {}, path = import_json_path.J
     for (const key of unknownValuePropertyKeys) {
       const propertyPath = path.add(key);
       if ((0, import_type_guards.isDefined)(schema.unknownPropertiesKey)) {
-        const keyResult = testWithFastError(schema.unknownPropertiesKey, key, options);
+        const keyResult = testSchema(schema.unknownPropertiesKey, key, options);
         if (!keyResult.valid && !mask) {
           return { valid: false, error: new import_schema_error.SchemaError("Invalid property key.", { path: propertyPath, inner: keyResult.error, fast: options.fastErrors }) };
         }
       }
-      const propertyResult = testWithFastError(schema.unknownProperties, value[key], options, path.add(key));
+      const propertyResult = testSchema(schema.unknownProperties, value[key], options, path.add(key));
       if (!propertyResult.valid && !mask) {
         return propertyResult;
       }
@@ -275,7 +274,7 @@ function testValue(schema, value, options = {}, path = import_json_path.JsonPath
 function isValidValue(validSchemas, value, options, path) {
   const errorResults = [];
   for (const schema of validSchemas) {
-    const result = testWithFastError(schema, value, options, path);
+    const result = testSchema(schema, value, options, path);
     if (result.valid) {
       return result;
     }
@@ -287,15 +286,16 @@ function isValidValue(validSchemas, value, options, path) {
   const errors = errorResults.map((result) => result.error);
   const expectStrings = [];
   for (const schema of validSchemas) {
-    getExpectString(schema);
+    expectStrings.push(getExpectString(schema));
   }
-  const expectString = expectStrings.join("\n");
+  const expectString = expectStrings.length > 1 ? `(${expectStrings.join(" | ")})` : expectStrings[0];
   return { valid: false, error: import_schema_error.SchemaError.expectedButGot(expectString, (0, import_utils.getValueType)(value), path, { inner: errors, fast: options.fastErrors }) };
 }
 function getExpectString(schema) {
   const expectedNames = (0, import_utils.getSchemaTypeNames)(schema);
-  const expectedTypeString = expectedNames.length == 1 ? expectedNames[0] : `[${expectedNames.join(", ")}]`;
+  const arraySuffix = (0, import_types.isValueSchema)(schema) && schema.array == true ? "[]" : "";
+  const expectedTypeString = expectedNames.length == 1 ? `${expectedNames[0]}${arraySuffix}` : `(${expectedNames.join(" | ")})${arraySuffix}`;
   const expects = (0, import_types.isValueSchema)(schema) ? (0, import_array.toArray)(schema.valueConstraints ?? []).map((constraint) => constraint.expects) : [];
-  const expectsString = expects.length > 0 ? ` (${expects.join(", ")})` : "";
+  const expectsString = expects.length > 0 ? `[${expects.join(", ")}]` : "";
   return `${expectedTypeString}${expectsString}`;
 }

package/schema/utils/value-type.js

@@ -28,6 +28,7 @@ module.exports = __toCommonJS(value_type_exports);
 var import_array = require("../../utils/array/array.js");
 var import_type_guards = require("../../utils/type-guards.js");
 var import_types = require("../types/types.js");
+const lowercaseTypesSet = /* @__PURE__ */ new Set([...import_types.primitiveConstructorSet, Object, Array]);
 function getValueType(value) {
   if ((0, import_type_guards.isUndefined)(value)) {
     return "undefined";
@@ -47,10 +48,10 @@ function includesValueType(valueType, valueTypes) {
 }
 function getValueTypeName(valueType) {
   const resolvedValueType = (0, import_types.resolveValueType)(valueType);
-  return (0, import_type_guards.isString)(resolvedValueType) ? resolvedValueType : resolvedValueType.name;
+  return (0, import_type_guards.isString)(resolvedValueType) ? resolvedValueType : lowercaseTypesSet.has(resolvedValueType) ? resolvedValueType.name.toLowerCase() : resolvedValueType.name;
 }
 function getSchemaTypeNames(schema) {
-  return getSchemaValueTypes(schema).map((valueType) => (0, import_type_guards.isString)(valueType) ? valueType : valueType.name);
+  return getSchemaValueTypes(schema).map(getValueTypeName);
 }
 function getSchemaValueTypes(schema) {
   if ((0, import_types.isTypeSchema)(schema)) {