@tstdl/base 0.86.0-beta2 → 0.86.0-beta3

package/browser/utils.js

@@ -1,88 +1,127 @@
-import { objectKeys } from '../utils/object/object.js';
-import { isDefined, isNull, isString, isUndefined } from '../utils/type-guards.js';
-const pageLoggerMap = new WeakMap();
-export function getLaunchOptions(options) {
-    const { windowSize, browserArguments, headless } = options;
-    const args = [`--window-size=${windowSize?.width ?? 1000},${windowSize?.height ?? 1000}`, ...(browserArguments ?? [])];
-    if (options.headless == 'new') {
-        args.push('--headless=new');
-    }
-    return {
-        ignoreDefaultArgs: (options.headless == 'new') ? ['--headless'] : undefined,
-        headless: headless != false,
-        args,
-        proxy: options.proxy
-    };
+"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 utils_exports = {};
+__export(utils_exports, {
+  assertLocator: () => assertLocator,
+  assertLocatorPass: () => assertLocatorPass,
+  attachLogger: () => attachLogger,
+  getLaunchOptions: () => getLaunchOptions,
+  isBrowserContext: () => isBrowserContext,
+  isElementHandle: () => isElementHandle,
+  isFrame: () => isFrame,
+  isLocator: () => isLocator,
+  isPage: () => isPage,
+  mergeNewBrowserContextOptions: () => mergeNewBrowserContextOptions
+});
+module.exports = __toCommonJS(utils_exports);
+var import_object = require("../utils/object/object.js");
+var import_type_guards = require("../utils/type-guards.js");
+const pageLoggerMap = /* @__PURE__ */ new WeakMap();
+function getLaunchOptions(options) {
+  const { windowSize, browserArguments, headless } = options;
+  const args = [`--window-size=${windowSize?.width ?? 1e3},${windowSize?.height ?? 1e3}`, ...browserArguments ?? []];
+  if (options.headless == "new") {
+    args.push("--headless=new");
+  }
+  return {
+    ignoreDefaultArgs: options.headless == "new" ? ["--headless"] : void 0,
+    headless: headless != false,
+    args,
+    proxy: options.proxy
+  };
 }
-export function mergeNewBrowserContextOptions(a, b, c) {
-    const mergedExtraHttpHeaders = { ...a?.extraHttpHeaders, ...b?.extraHttpHeaders, ...c?.extraHttpHeaders };
-    return {
-        ...a,
-        ...b,
-        ...c,
-        extraHttpHeaders: (objectKeys(mergedExtraHttpHeaders).length > 0) ? mergedExtraHttpHeaders : undefined
-    };
+function mergeNewBrowserContextOptions(a, b, c) {
+  const mergedExtraHttpHeaders = { ...a?.extraHttpHeaders, ...b?.extraHttpHeaders, ...c?.extraHttpHeaders };
+  return {
+    ...a,
+    ...b,
+    ...c,
+    extraHttpHeaders: (0, import_object.objectKeys)(mergedExtraHttpHeaders).length > 0 ? mergedExtraHttpHeaders : void 0
+  };
 }
 function getPageLogger(page, baseLogger) {
-    let pageLogger = pageLoggerMap.get(page);
-    if (isUndefined(pageLogger)) {
-        pageLogger = baseLogger.subModule(crypto.randomUUID().slice(-12));
-        pageLoggerMap.set(page, pageLogger);
-    }
-    return pageLogger;
+  let pageLogger = pageLoggerMap.get(page);
+  if ((0, import_type_guards.isUndefined)(pageLogger)) {
+    pageLogger = baseLogger.subModule(crypto.randomUUID().slice(-12));
+    pageLoggerMap.set(page, pageLogger);
+  }
+  return pageLogger;
 }
-export function attachLogger(loggable, logger) {
-    if (isPage(loggable)) {
-        loggable.on('close', () => pageLoggerMap.delete(loggable));
-        loggable.on('pageerror', (error) => logger.error(error));
+function attachLogger(loggable, logger) {
+  if (isPage(loggable)) {
+    loggable.on("close", () => pageLoggerMap.delete(loggable));
+    loggable.on("pageerror", (error) => logger.error(error));
+  }
+  loggable.on("request", (request) => getPageLogger(request.frame().page(), logger).verbose(`Request to ${request.url()}`));
+  loggable.on("requestfailed", (request) => getPageLogger(request.frame().page(), logger).verbose(`Request to ${request.url()} failed: ${request.failure()?.errorText}`));
+  loggable.on("console", (consoleMessage) => {
+    const page = consoleMessage.page();
+    const pageLogger = (0, import_type_guards.isNull)(page) ? logger : getPageLogger(page, logger);
+    const rawUrl = consoleMessage.page()?.url();
+    const parsedUrl = (0, import_type_guards.isString)(rawUrl) && rawUrl.length > 0 ? new URL(rawUrl) : rawUrl;
+    const url = (0, import_type_guards.isString)(parsedUrl) ? parsedUrl : `${parsedUrl?.protocol.startsWith("http") == true ? "" : parsedUrl?.protocol}${parsedUrl?.host}${parsedUrl?.pathname}`;
+    const location = consoleMessage.location();
+    const rawLocationText = location.lineNumber == 0 ? location.url : `${location.url}:${location.lineNumber}:${location.columnNumber}`;
+    const locationText = rawLocationText.length == 0 ? void 0 : rawLocationText;
+    const additions = Object.entries({ location: locationText }).filter(([_, value]) => (0, import_type_guards.isDefined)(value)).map(([key, value]) => `${key}: ${value}`).join(", ");
+    const message = `${url}: ${consoleMessage.text()}${additions.length > 0 ? ` (${additions})` : ""}`;
+    switch (consoleMessage.type()) {
+      case "debug":
+        pageLogger.debug(message);
+        break;
+      case "error":
+        pageLogger.error(message);
+        break;
+      case "warning":
+        pageLogger.warn(message);
+        break;
+      case "trace":
+        pageLogger.trace(message);
+        break;
+      case "clear":
+        break;
+      case "info":
+      default:
+        pageLogger.info(message);
+        break;
     }
-    loggable.on('request', (request) => getPageLogger(request.frame().page(), logger).verbose(`Request to ${request.url()}`));
-    loggable.on('requestfailed', (request) => getPageLogger(request.frame().page(), logger).verbose(`Request to ${request.url()} failed: ${request.failure()?.errorText}`));
-    loggable.on('console', (consoleMessage) => {
-        const page = consoleMessage.page();
-        const pageLogger = isNull(page) ? logger : getPageLogger(page, logger);
-        const rawUrl = consoleMessage.page()?.url();
-        const parsedUrl = (isString(rawUrl) && (rawUrl.length > 0)) ? new URL(rawUrl) : rawUrl;
-        const url = isString(parsedUrl) ? parsedUrl : `${(parsedUrl?.protocol.startsWith('http') == true) ? '' : parsedUrl?.protocol}${parsedUrl?.host}${parsedUrl?.pathname}`;
-        const location = consoleMessage.location();
-        const rawLocationText = (location.lineNumber == 0) ? location.url : `${location.url}:${location.lineNumber}:${location.columnNumber}`;
-        const locationText = rawLocationText.length == 0 ? undefined : rawLocationText;
-        const additions = Object.entries({ location: locationText }).filter(([_, value]) => isDefined(value)).map(([key, value]) => `${key}: ${value}`).join(', ');
-        const message = `${url}: ${consoleMessage.text()}${(additions.length > 0) ? ` (${additions})` : ''}`;
-        switch (consoleMessage.type()) {
-            case 'debug':
-                pageLogger.debug(message);
-                break;
-            case 'error':
-                pageLogger.error(message);
-                break;
-            case 'warning':
-                pageLogger.warn(message);
-                break;
-            case 'trace':
-                pageLogger.trace(message);
-                break;
-            case 'clear':
-                break;
-            case 'info':
-            default:
-                pageLogger.info(message);
-                break;
-        }
-    });
+  });
+}
+function isLocator(locatorOrHandle) {
+  return locatorOrHandle.constructor.name == "Locator";
+}
+function assertLocator(locatorOrHandle, message = "Locator instead of ElementHandle required") {
+  (0, import_type_guards.assert)(isLocator(locatorOrHandle), message);
 }
-export function isLocator(locatorOrHandle) {
-    return locatorOrHandle.constructor.name == 'Locator';
+function assertLocatorPass(locatorOrHandle, message = "Locator instead of ElementHandle required") {
+  assertLocator(locatorOrHandle, message);
+  return locatorOrHandle;
 }
-export function isElementHandle(locatorOrHandle) {
-    return locatorOrHandle.constructor.name == 'ElementHandle';
+function isElementHandle(locatorOrHandle) {
+  return locatorOrHandle.constructor.name == "ElementHandle";
 }
-export function isPage(pageOrFrameOrContext) {
-    return pageOrFrameOrContext.constructor.name == 'Page';
+function isPage(pageOrFrameOrContext) {
+  return pageOrFrameOrContext.constructor.name == "Page";
 }
-export function isFrame(pageOrFrameOrContext) {
-    return pageOrFrameOrContext.constructor.name == 'Frame';
+function isFrame(pageOrFrameOrContext) {
+  return pageOrFrameOrContext.constructor.name == "Frame";
 }
-export function isBrowserContext(pageOrFrameOrContext) {
-    return pageOrFrameOrContext.constructor.name == 'BrowserContext';
+function isBrowserContext(pageOrFrameOrContext) {
+  return pageOrFrameOrContext.constructor.name == "BrowserContext";
 }

package/collections/awaitable/awaitable-list.js

@@ -1,100 +1,123 @@
-import { firstValueFrom, Subject } from 'rxjs';
-export class AwaitableList {
-    _added;
-    _removed;
-    _cleared;
-    backingArray;
-    get added$() {
-        return this._added.asObservable();
-    }
-    get removed$() {
-        return this._removed.asObservable();
-    }
-    get cleared$() {
-        return this._cleared.asObservable();
-    }
-    get $added() {
-        return firstValueFrom(this._added);
-    }
-    get $removed() {
-        return firstValueFrom(this._removed);
-    }
-    get $cleared() {
-        return firstValueFrom(this._cleared);
-    }
-    get size() {
-        return this.backingArray.length;
-    }
-    constructor() {
-        this.backingArray = [];
-        this._added = new Subject();
-        this._removed = new Subject();
-        this._cleared = new Subject();
-    }
-    get(index) {
-        if (index >= this.size || index < 0) {
-            throw new Error('Index out of bounds.');
-        }
-        return this.backingArray[index];
-    }
-    set(index, value) {
-        if (index >= this.size || index < 0) {
-            throw new Error('Index out of bounds.');
-        }
-        const oldValue = this.backingArray[index];
-        this.backingArray[index] = value;
-        this._removed.next(oldValue);
-        this._added.next(value);
-    }
-    append(...items) {
-        const result = this.backingArray.push(...items);
-        this._added.next(items);
-        return result;
-    }
-    prepend(...items) {
-        const result = this.backingArray.unshift(...items);
-        this._added.next(items);
-        return result;
-    }
-    insert(index, ...items) {
-        if (index >= this.size || index < 0) {
-            throw new Error('Index out of bounds.');
-        }
-        this.backingArray.splice(index, 0, ...items);
-        this._added.next(items);
-    }
-    remove(index, count = 1) {
-        if (index >= this.size || index < 0) {
-            throw new Error('Index out of bounds.');
-        }
-        if ((index + count) > this.size) {
-            throw new Error('Count out of bounds.');
-        }
-        const removedItems = this.backingArray.splice(index, count);
-        this._removed.next(removedItems);
-        return removedItems;
-    }
-    pop() {
-        if (this.size == 0) {
-            throw new Error('List contains no items.');
-        }
-        const result = this.backingArray.pop();
-        this._removed.next(result);
-        return result;
-    }
-    shift() {
-        if (this.size == 0) {
-            throw new Error('List contains no items.');
-        }
-        const result = this.backingArray.shift();
-        this._removed.next(result);
-        return result;
-    }
-    clear() {
-        this.backingArray = [];
-        this._cleared.next();
-    }
-    *[Symbol.iterator]() {
-        yield* this.backingArray[Symbol.iterator]();
-    }
+"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 awaitable_list_exports = {};
+__export(awaitable_list_exports, {
+  AwaitableList: () => AwaitableList
+});
+module.exports = __toCommonJS(awaitable_list_exports);
+var import_rxjs = require("rxjs");
+class AwaitableList {
+  _added;
+  _removed;
+  _cleared;
+  backingArray;
+  get added$() {
+    return this._added.asObservable();
+  }
+  get removed$() {
+    return this._removed.asObservable();
+  }
+  get cleared$() {
+    return this._cleared.asObservable();
+  }
+  get $added() {
+    return (0, import_rxjs.firstValueFrom)(this._added);
+  }
+  get $removed() {
+    return (0, import_rxjs.firstValueFrom)(this._removed);
+  }
+  get $cleared() {
+    return (0, import_rxjs.firstValueFrom)(this._cleared);
+  }
+  get size() {
+    return this.backingArray.length;
+  }
+  constructor() {
+    this.backingArray = [];
+    this._added = new import_rxjs.Subject();
+    this._removed = new import_rxjs.Subject();
+    this._cleared = new import_rxjs.Subject();
+  }
+  get(index) {
+    if (index >= this.size || index < 0) {
+      throw new Error("Index out of bounds.");
+    }
+    return this.backingArray[index];
+  }
+  set(index, value) {
+    if (index >= this.size || index < 0) {
+      throw new Error("Index out of bounds.");
+    }
+    const oldValue = this.backingArray[index];
+    this.backingArray[index] = value;
+    this._removed.next(oldValue);
+    this._added.next(value);
+  }
+  append(...items) {
+    const result = this.backingArray.push(...items);
+    this._added.next(items);
+    return result;
+  }
+  prepend(...items) {
+    const result = this.backingArray.unshift(...items);
+    this._added.next(items);
+    return result;
+  }
+  insert(index, ...items) {
+    if (index >= this.size || index < 0) {
+      throw new Error("Index out of bounds.");
+    }
+    this.backingArray.splice(index, 0, ...items);
+    this._added.next(items);
+  }
+  remove(index, count = 1) {
+    if (index >= this.size || index < 0) {
+      throw new Error("Index out of bounds.");
+    }
+    if (index + count > this.size) {
+      throw new Error("Count out of bounds.");
+    }
+    const removedItems = this.backingArray.splice(index, count);
+    this._removed.next(removedItems);
+    return removedItems;
+  }
+  pop() {
+    if (this.size == 0) {
+      throw new Error("List contains no items.");
+    }
+    const result = this.backingArray.pop();
+    this._removed.next(result);
+    return result;
+  }
+  shift() {
+    if (this.size == 0) {
+      throw new Error("List contains no items.");
+    }
+    const result = this.backingArray.shift();
+    this._removed.next(result);
+    return result;
+  }
+  clear() {
+    this.backingArray = [];
+    this._cleared.next();
+  }
+  *[Symbol.iterator]() {
+    yield* this.backingArray[Symbol.iterator]();
+  }
 }

package/collections/awaitable/awaitable-map.js

@@ -1,94 +1,117 @@
-import { DeferredPromise } from '../../promise/deferred-promise.js';
-import { differenceMaps, intersectMaps, unionMaps } from '../../utils/map.js';
-export class AwaitableMap {
-    backingMap;
-    _setted;
-    _cleared;
-    _deleted;
-    [Symbol.toStringTag];
-    get setted() {
-        return this._setted;
-    }
-    get cleared() {
-        return this._cleared;
-    }
-    get deleted() {
-        return this._deleted;
-    }
-    get size() {
-        return this.backingMap.size;
-    }
-    constructor(backingMap = new Map()) {
-        this.backingMap = backingMap;
-        this[Symbol.toStringTag] = 'AwaitableMap';
-        this._setted = new DeferredPromise();
-        this._cleared = new DeferredPromise();
-        this._deleted = new DeferredPromise();
-    }
-    static from(map, clone = true) {
-        if (!clone) {
-            return new AwaitableMap(map);
-        }
-        return AwaitableMap.fromIterable(map);
-    }
-    static fromIterable(map) {
-        const awaitableMap = new AwaitableMap();
-        for (const [key, value] of map) {
-            awaitableMap.set(key, value);
-        }
-        return awaitableMap;
-    }
-    [Symbol.iterator]() {
-        return this.backingMap.entries();
-    }
-    entries() {
-        return this.backingMap.entries();
-    }
-    keys() {
-        return this.backingMap.keys();
-    }
-    values() {
-        return this.backingMap.values();
-    }
-    clear() {
-        this.backingMap.clear();
-        this._cleared.resolve();
-        this._cleared.reset();
-    }
-    delete(key) {
-        const success = this.backingMap.delete(key);
-        if (success) {
-            this._deleted.resolve(key);
-            this._deleted.reset();
-        }
-        return success;
-    }
-    forEach(callback, thisArg) {
-        const boundCallback = callback.bind(thisArg);
-        this.backingMap.forEach((value, key) => boundCallback(value, key, this));
-    }
-    get(key) {
-        return this.backingMap.get(key);
-    }
-    has(key) {
-        return this.backingMap.has(key);
-    }
-    set(key, value) {
-        this.backingMap.set(key, value);
-        this._setted.resolve([key, value]);
-        this._setted.reset();
-        return this;
-    }
-    intersect(...maps) {
-        const intersection = intersectMaps(this.backingMap, ...maps);
-        return AwaitableMap.fromIterable(intersection);
-    }
-    difference(...maps) {
-        const difference = differenceMaps(this.backingMap, ...maps);
-        return AwaitableMap.fromIterable(difference);
-    }
-    union(...maps) {
-        const union = unionMaps(this.backingMap, ...maps);
-        return AwaitableMap.from(union, false);
-    }
+"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 awaitable_map_exports = {};
+__export(awaitable_map_exports, {
+  AwaitableMap: () => AwaitableMap
+});
+module.exports = __toCommonJS(awaitable_map_exports);
+var import_deferred_promise = require("../../promise/deferred-promise.js");
+var import_map = require("../../utils/map.js");
+class AwaitableMap {
+  backingMap;
+  _setted;
+  _cleared;
+  _deleted;
+  [Symbol.toStringTag];
+  get setted() {
+    return this._setted;
+  }
+  get cleared() {
+    return this._cleared;
+  }
+  get deleted() {
+    return this._deleted;
+  }
+  get size() {
+    return this.backingMap.size;
+  }
+  constructor(backingMap = /* @__PURE__ */ new Map()) {
+    this.backingMap = backingMap;
+    this[Symbol.toStringTag] = "AwaitableMap";
+    this._setted = new import_deferred_promise.DeferredPromise();
+    this._cleared = new import_deferred_promise.DeferredPromise();
+    this._deleted = new import_deferred_promise.DeferredPromise();
+  }
+  static from(map, clone = true) {
+    if (!clone) {
+      return new AwaitableMap(map);
+    }
+    return AwaitableMap.fromIterable(map);
+  }
+  static fromIterable(map) {
+    const awaitableMap = new AwaitableMap();
+    for (const [key, value] of map) {
+      awaitableMap.set(key, value);
+    }
+    return awaitableMap;
+  }
+  [Symbol.iterator]() {
+    return this.backingMap.entries();
+  }
+  entries() {
+    return this.backingMap.entries();
+  }
+  keys() {
+    return this.backingMap.keys();
+  }
+  values() {
+    return this.backingMap.values();
+  }
+  clear() {
+    this.backingMap.clear();
+    this._cleared.resolve();
+    this._cleared.reset();
+  }
+  delete(key) {
+    const success = this.backingMap.delete(key);
+    if (success) {
+      this._deleted.resolve(key);
+      this._deleted.reset();
+    }
+    return success;
+  }
+  forEach(callback, thisArg) {
+    const boundCallback = callback.bind(thisArg);
+    this.backingMap.forEach((value, key) => boundCallback(value, key, this));
+  }
+  get(key) {
+    return this.backingMap.get(key);
+  }
+  has(key) {
+    return this.backingMap.has(key);
+  }
+  set(key, value) {
+    this.backingMap.set(key, value);
+    this._setted.resolve([key, value]);
+    this._setted.reset();
+    return this;
+  }
+  intersect(...maps) {
+    const intersection = (0, import_map.intersectMaps)(this.backingMap, ...maps);
+    return AwaitableMap.fromIterable(intersection);
+  }
+  difference(...maps) {
+    const difference = (0, import_map.differenceMaps)(this.backingMap, ...maps);
+    return AwaitableMap.fromIterable(difference);
+  }
+  union(...maps) {
+    const union = (0, import_map.unionMaps)(this.backingMap, ...maps);
+    return AwaitableMap.from(union, false);
+  }
 }