@tstdl/base 0.84.2 → 0.84.3

package/browser/page-controller.d.ts

@@ -1,4 +1,4 @@
-import type { Page } from 'playwright';
+import type { ElementHandle, Page } from 'playwright';
 import type { AsyncDisposable } from '../disposable/disposable.js';
 import { disposeAsync } from '../disposable/disposable.js';
 import type { NonUndefinable, SimplifyObject } from '../types.js';
@@ -24,6 +24,9 @@ export declare class PageController implements AsyncDisposable {
     waitForClose(): 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>;
+    waitForFrame(selector: string, options: Parameters<Page['waitForSelector']>[1]): Promise<PageController>;
+    getFrame(selector: Parameters<Page['frame']>[0]): PageController;
     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;

package/browser/page-controller.js

@@ -67,6 +67,28 @@ class PageController {
   async waitForUrl(...args) {
     await this.page.waitForURL(...args);
   }
+  async waitForElement(selector, options) {
+    const element = await this.page.waitForSelector(selector, options);
+    if ((0, import_type_guards.isNull)(element)) {
+      throw new Error("Element not found.");
+    }
+    return element;
+  }
+  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 new PageController(frame.page(), this.options);
+  }
+  getFrame(selector) {
+    const frame = this.page.frame(selector);
+    if ((0, import_type_guards.isNull)(frame)) {
+      throw new Error("Frame not found.");
+    }
+    return new PageController(frame.page(), this.options);
+  }
   getBySelector(selector, options) {
     const locator = this.page.locator(selector, options);
     return new import_element_controller.ElementController(locator, this, this.elementControllerOptions);

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.3",
   "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)) {