@tstdl/base 0.84.6 → 0.84.7

package/browser/utils.d.ts

@@ -1,8 +1,16 @@
+import type { SimplifyObject, Unoptionalize } from '../types.js';
 import type { BrowserType, ElementHandle, LaunchOptions, Locator } from 'playwright';
 import type { NewBrowserContextOptions } from './browser-controller.js';
 import type { NewBrowserOptions } from './browser.service.js';
+declare const browserTypes: {
+    chromium: BrowserType<{}>;
+    firefox: BrowserType<{}>;
+    webkit: BrowserType<{}>;
+};
+export declare function replaceBrowsers(browsers: SimplifyObject<Unoptionalize<Partial<typeof browserTypes>>>): void;
 export declare function getLaunchOptions(options: NewBrowserOptions): LaunchOptions;
 export declare function mergeNewBrowserContextOptions(a: NewBrowserContextOptions | undefined, b?: NewBrowserContextOptions, c?: NewBrowserContextOptions): NewBrowserContextOptions;
-export declare function getBrowserType(type: string | undefined): BrowserType;
+export declare function getBrowserType(type: keyof typeof browserTypes | undefined): BrowserType;
 export declare function isLocator(value: Locator | ElementHandle): value is Locator;
 export declare function isElementHandle(value: Locator | ElementHandle): value is ElementHandle;
+export {};

package/browser/utils.js

@@ -22,13 +22,23 @@ __export(utils_exports, {
   getLaunchOptions: () => getLaunchOptions,
   isElementHandle: () => isElementHandle,
   isLocator: () => isLocator,
-  mergeNewBrowserContextOptions: () => mergeNewBrowserContextOptions
+  mergeNewBrowserContextOptions: () => mergeNewBrowserContextOptions,
+  replaceBrowsers: () => replaceBrowsers
 });
 module.exports = __toCommonJS(utils_exports);
 var import_not_supported_error = require("../error/not-supported.error.js");
 var import_object = require("../utils/object/object.js");
 var import_type_guards = require("../utils/type-guards.js");
 var import_playwright = require("playwright");
+const browserTypes = {
+  chromium: import_playwright.chromium,
+  firefox: import_playwright.firefox,
+  webkit: import_playwright.webkit
+};
+function replaceBrowsers(browsers) {
+  const filtered = (0, import_object.filterUndefinedObjectProperties)(browsers);
+  (0, import_object.copyObjectProperties)(filtered, browserTypes);
+}
 function getLaunchOptions(options) {
   const { windowSize, browserArguments, headless } = options;
   const args = [`--window-size=${windowSize?.width ?? 1e3},${windowSize?.height ?? 1e3}`, ...browserArguments ?? []];
@@ -44,20 +54,9 @@ function mergeNewBrowserContextOptions(a, b, c) {
   };
 }
 function getBrowserType(type) {
-  let browserType;
-  switch (type) {
-    case "chromium":
-    case void 0:
-      browserType = import_playwright.chromium;
-      break;
-    case "firefox":
-      browserType = import_playwright.firefox;
-      break;
-    case "webkit":
-      browserType = import_playwright.webkit;
-      break;
-    default:
-      throw new import_not_supported_error.NotSupportedError(`Browser type ${type} is not supported.`);
+  const browserType = browserTypes[type ?? "chromium"];
+  if ((0, import_type_guards.isUndefined)(browserType)) {
+    throw new import_not_supported_error.NotSupportedError(`Browser type ${type} is not supported.`);
   }
   return browserType;
 }

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

@@ -57,11 +57,14 @@ export declare class HttpClientRequest implements Disposable {
      * automatically maps parameters to `urlParameters`, `query` and `body`
      * depending on whether the `url` has parameters specified, the request `method`
      * and if there is already a `body` or not
+     * @see mapParameters
      * @see mapParametersToUrl
      * @see mapParametersToQuery
      * @see mapParametersToBody
      */
     parameters: UndefinableJsonObject | undefined;
+    /** if false, disable parameters mapping completely */
+    mapParameters: boolean;
     mapParametersToUrl: boolean;
     mapParametersToQuery: boolean;
     mapParametersToBody: boolean;

package/http/client/http-client-request.js

@@ -38,11 +38,14 @@ class HttpClientRequest {
    * automatically maps parameters to `urlParameters`, `query` and `body`
    * depending on whether the `url` has parameters specified, the request `method`
    * and if there is already a `body` or not
+   * @see mapParameters
    * @see mapParametersToUrl
    * @see mapParametersToQuery
    * @see mapParametersToBody
    */
   parameters;
+  /** if false, disable parameters mapping completely */
+  mapParameters;
   mapParametersToUrl;
   mapParametersToQuery;
   mapParametersToBody;
@@ -110,6 +113,7 @@ class HttpClientRequest {
     const requestOptions = (0, import_type_guards.isString)(urlOrObject) ? options : urlOrObject;
     this.headers = new import_http_headers.HttpHeaders(requestOptions.headers);
     this.parameters = requestOptions.parameters;
+    this.mapParameters = requestOptions.mapParameters ?? true;
     this.mapParametersToUrl = requestOptions.mapParametersToUrl ?? true;
     this.mapParametersToQuery = requestOptions.mapParametersToQuery ?? true;
     this.mapParametersToBody = requestOptions.mapParametersToBody ?? true;

package/http/client/http-client.js

@@ -231,6 +231,9 @@ HttpClient = __decorate([
 ], HttpClient);
 function getBuildRequestUrlMiddleware(baseUrl) {
   async function buildUrlParametersMiddleware(request, next) {
+    if (!request.mapParameters) {
+      return next(request);
+    }
     const modifiedRequest = mapParameters(request, baseUrl);
     return next(modifiedRequest);
   }
@@ -267,7 +270,7 @@ async function addRequestHeadersMiddleware(request, next) {
 async function errorMiddleware(request, next) {
   try {
     const response = await next(request);
-    if (request.throwOnNon200 && (response.statusCode < 200 || response.statusCode >= 300)) {
+    if (request.throwOnNon200 && (response.statusCode < 200 || response.statusCode >= 400)) {
       const httpError = await import_http_error.HttpError.create(import_http_error.HttpErrorReason.Non200StatusCode, request, response, `Status code ${response.statusCode}.`);
       throw httpError;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.84.6",
+  "version": "0.84.7",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"

package/types.d.ts

@@ -112,10 +112,10 @@ export type OmitBy<T, V> = Omit<T, {
  * normalize properties of a type that allow `undefined` to make them optional.
  */
 export type Optionalize<T extends object> = OmitBy<T, undefined> & Partial<PickBy<T, undefined>>;
-export type Unoptionalize<T extends object> = Simplify<OmitBy<T, undefined> & {
+export type SimplifiedOptionalize<T extends object> = SimplifyObject<Optionalize<T>>;
+export type Unoptionalize<T extends object> = SimplifyObject<OmitBy<T, undefined> & {
     [P in PropertiesOfType<T, undefined>]: T[P] | undefined;
 }>;
-export type SimplifiedOptionalize<T extends object> = Simplify<Optionalize<T>>;
 export type Merge<T1, T2> = SimplifyObject<Except<T1, Extract<keyof T1, keyof T2>> & T2>;
 export type Simplify<T> = T extends BuiltIn ? T : T extends readonly any[] ? SimplifyArray<T> : T extends Record ? SimplifyObject<T> : T;
 export type SimplifyObject<T extends Record> = {

package/utils/object/object.d.ts

@@ -1,4 +1,5 @@
 import type { FromEntries, ObjectLiteral, PickBy, Record } from '../../types.js';
+import type { IsEqual } from 'type-fest';
 export declare function hasOwnProperty<T extends Record>(obj: T, key: keyof T): boolean;
 /**
  * returns object entries including those with symbols keys (which Object.entries does not)
@@ -18,6 +19,9 @@ export declare function mapObjectValuesAsync<T extends ObjectLiteral, V>(object:
 export declare function filterObject<T extends ObjectLiteral, U extends T[keyof T]>(object: T, predicate: (value: T[keyof T], key: keyof T) => value is U): PickBy<T, U>;
 export declare function filterObject<T extends ObjectLiteral>(object: T, predicate: (value: T[keyof T], key: keyof T) => boolean): Partial<T>;
 export declare function filterObjectAsync<T extends ObjectLiteral>(object: T, predicate: (value: T[keyof T], key: keyof T) => Promise<boolean>): Promise<Partial<T>>;
+export declare function filterUndefinedObjectProperties<T extends ObjectLiteral>(object: T): {
+    [P in keyof T]?: IsEqual<T[P], undefined> extends true ? never : Exclude<T[P], undefined>;
+};
 export declare function copyObjectProperties<T extends ObjectLiteral, U extends T>(source: T, target: U): void;
 export declare function getGetter<T extends ObjectLiteral, U extends keyof T>(obj: T, property: keyof T, bind: boolean): () => T[U];
 export declare function deepObjectEntries(object: ObjectLiteral, keepInnerObjects?: boolean, prefix?: string): [string, any][];

package/utils/object/object.js

@@ -22,6 +22,7 @@ __export(object_exports, {
   deepObjectEntries: () => deepObjectEntries,
   filterObject: () => filterObject,
   filterObjectAsync: () => filterObjectAsync,
+  filterUndefinedObjectProperties: () => filterUndefinedObjectProperties,
   fromEntries: () => fromEntries,
   getGetter: () => getGetter,
   hasOwnProperty: () => hasOwnProperty,
@@ -78,6 +79,9 @@ async function filterObjectAsync(object, predicate) {
   const mappedEntries = await (0, import_to_array.toArrayAsync)((0, import_filter.filterAsync)(entries, async ([key, value]) => predicate(value, key)));
   return Object.fromEntries(mappedEntries);
 }
+function filterUndefinedObjectProperties(object) {
+  return filterObject(object, import_type_guards.isDefined);
+}
 function copyObjectProperties(source, target) {
   for (const key of objectKeys(source)) {
     target[key] = source[key];