@tstdl/base 0.84.24 → 0.84.26

package/application/application.js

@@ -53,7 +53,10 @@ var __param = function(paramIndex, decorator) {
 };
 var Application_1;
 (0, import_process_shutdown.initializeSignals)();
-let Application = Application_1 = class Application2 {
+let Application = class Application2 {
+  static {
+    Application_1 = this;
+  }
   static _instance;
   static get instance() {
     if ((0, import_type_guards.isUndefined)(this._instance)) {

package/browser/browser-context-controller.d.ts

@@ -28,5 +28,6 @@ export declare class BrowserContextController implements AsyncDisposable, Inject
     getState(): Promise<BrowserContextState>;
     setExtraHttpHeaders(headers: Record<string, string | undefined>): Promise<void>;
     newPage(options?: NewPageOptions): Promise<PageController>;
+    waitForNoPages(): Promise<void>;
     waitForClose(): Promise<void>;
 }

package/browser/browser-context-controller.js

@@ -73,6 +73,19 @@ let BrowserContextController = class BrowserContextController2 {
     }
     return controller;
   }
+  async waitForNoPages() {
+    while (true) {
+      const pages = this.context.pages();
+      if (pages.length == 0) {
+        break;
+      }
+      for (const page of pages) {
+        if (!page.isClosed()) {
+          await new Promise((resolve) => page.once("close", () => resolve()));
+        }
+      }
+    }
+  }
   async waitForClose() {
     return new Promise((resolve) => this.context.once("close", () => resolve()));
   }

package/browser/element-controller.d.ts

@@ -20,7 +20,27 @@ export declare class ElementController<T extends Locator | ElementHandle = Locat
     readonly locatorOrHandle: T;
     readonly options: ElementControllerOptions;
     constructor(locatorOrHandle: T, options?: ElementControllerOptions);
-    waitFor(options?: Parameters<Locator['waitFor']>[0]): Promise<void>;
+    /**
+     * Wait for element state
+     * @param state some states may only be usable for either locator or handle
+     * @param options options
+     */
+    waitFor(state?: Parameters<ElementHandle['waitForElementState']>[0] | NonNullable<LocatorOptions<'waitFor', '0'>['state']>, options?: Parameters<ElementHandle['waitForElementState']>[1]): Promise<void>;
+    /**
+     * Check if element exists
+     * @param options.state which state is required in order to be deemed existing
+     * @param options.timeout how long to wait for the element before being deemed not existing (default: 250ms)
+     */
+    exists(options?: {
+        state?: 'visible' | 'attached';
+        timeout?: number;
+    }): Promise<boolean>;
+    isVisible(): Promise<boolean>;
+    isHidden(): Promise<boolean>;
+    isEnabled(): Promise<boolean>;
+    isDisabled(): Promise<boolean>;
+    isChecked(): Promise<boolean>;
+    isEditable(): Promise<boolean>;
     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>;

package/browser/element-controller.js

@@ -24,6 +24,7 @@ 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_utils = require("./utils.js");
 class ElementController {
   locatorOrHandle;
   options;
@@ -31,8 +32,47 @@ class ElementController {
     this.locatorOrHandle = locatorOrHandle;
     this.options = options;
   }
-  async waitFor(options) {
-    return this.locatorOrHandle.waitFor(options);
+  /**
+   * Wait for element state
+   * @param state some states may only be usable for either locator or handle
+   * @param options options
+   */
+  async waitFor(state = "visible", options) {
+    if ((0, import_utils.isLocator)(this.locatorOrHandle)) {
+      return this.locatorOrHandle.waitFor({ state, ...options });
+    }
+    return this.locatorOrHandle.waitForElementState(state, options);
+  }
+  /**
+   * Check if element exists
+   * @param options.state which state is required in order to be deemed existing
+   * @param options.timeout how long to wait for the element before being deemed not existing (default: 250ms)
+   */
+  async exists(options) {
+    try {
+      await this.waitFor(options?.state ?? "visible", { timeout: options?.timeout ?? 250 });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async isVisible() {
+    return this.locatorOrHandle.isVisible();
+  }
+  async isHidden() {
+    return this.locatorOrHandle.isHidden();
+  }
+  async isEnabled() {
+    return this.locatorOrHandle.isEnabled();
+  }
+  async isDisabled() {
+    return this.locatorOrHandle.isDisabled();
+  }
+  async isChecked() {
+    return this.locatorOrHandle.isChecked();
+  }
+  async isEditable() {
+    return this.locatorOrHandle.isEditable();
   }
   async fill(text, options) {
     await this.prepareAction(options);

package/browser/utils.d.ts

@@ -1,5 +1,7 @@
-import type { LaunchOptions } from 'playwright';
+import type { ElementHandle, LaunchOptions, Locator } from 'playwright';
 import type { NewBrowserContextOptions } from './browser-controller.js';
 import type { NewBrowserOptions } from './browser.service.js';
 export declare function getLaunchOptions(options: NewBrowserOptions): LaunchOptions;
 export declare function mergeNewBrowserContextOptions(a: NewBrowserContextOptions | undefined, b?: NewBrowserContextOptions, c?: NewBrowserContextOptions): NewBrowserContextOptions;
+export declare function isLocator(locatorOrHandle: Locator | ElementHandle): locatorOrHandle is Locator;
+export declare function isElementHandle(locatorOrHandle: Locator | ElementHandle): locatorOrHandle is Locator;

package/browser/utils.js

@@ -19,6 +19,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var utils_exports = {};
 __export(utils_exports, {
   getLaunchOptions: () => getLaunchOptions,
+  isElementHandle: () => isElementHandle,
+  isLocator: () => isLocator,
   mergeNewBrowserContextOptions: () => mergeNewBrowserContextOptions
 });
 module.exports = __toCommonJS(utils_exports);
@@ -45,3 +47,9 @@ function mergeNewBrowserContextOptions(a, b, c) {
     extraHttpHeaders: (0, import_object.objectKeys)(mergedExtraHttpHeaders).length > 0 ? mergedExtraHttpHeaders : void 0
   };
 }
+function isLocator(locatorOrHandle) {
+  return (0, import_object.hasOwnProperty)(locatorOrHandle, "count");
+}
+function isElementHandle(locatorOrHandle) {
+  return (0, import_object.hasOwnProperty)(locatorOrHandle, "asElement");
+}

package/examples/mail/templates/hello-name.d.ts

@@ -1,2 +1,5 @@
-declare const template: import("../../../mail/index.js").MailTemplate<object>;
+type HelloMailContext = {
+    name: string;
+};
+declare const template: import("../../../mail/index.js").MailTemplate<HelloMailContext>;
 export default template;

package/examples/mail/templates/hello-name.js

@@ -31,6 +31,6 @@ function HelloMail({ name }) {
 const template = (0, import_mail.mailTemplate)("hello-name", {
   subject: (0, import_string_template_resolver.stringTemplateField)({ renderer: "handlebars", template: "Hello {{ name }} in subject!" }),
   html: (0, import_jsx_template_resolver.jsxTemplateField)({ renderer: "mjml-jsx", template: HelloMail }),
-  text: (0, import_string_template_resolver.stringTemplateField)({ renderer: "handlebars", template: "Hello {{ name }} in text!" })
+  text: (0, import_string_template_resolver.stringTemplateField)({ renderer: "string", template: ({ name }) => `Hello ${name} in text!` })
 });
 var hello_name_default = template;

package/examples/template/templates/hello-jsx.d.ts

@@ -1,2 +1,2 @@
-export declare const template: import("../../../templates/template.model.js").Template<import("../../../types.js").Record<string, boolean>, any, import("../../../types.js").Record>;
+export declare const template: import("../../../templates/template.model.js").Template<import("../../../types.js").Record<string, boolean>, any, any>;
 export default template;

package/examples/template/templates/hello-name.d.ts

@@ -1,2 +1,2 @@
-declare const template: import("../../../templates/template.model.js").Template<import("../../../types.js").Record<string, boolean>, any, import("../../../types.js").Record>;
+declare const template: import("../../../templates/template.model.js").Template<import("../../../types.js").Record<string, boolean>, any, any>;
 export default template;

package/http/server/node/node-http-server.d.ts

@@ -1,10 +1,10 @@
 /// <reference types="node" resolution-mode="require"/>
+import * as Http from 'node:http';
 import type { AfterResolve } from '../../../container/index.js';
 import { afterResolve } from '../../../container/index.js';
 import type { AsyncDisposable } from '../../../disposable/index.js';
 import { disposeAsync } from '../../../disposable/index.js';
 import { Logger } from '../../../logger/index.js';
-import * as Http from 'node:http';
 import type { HttpServerRequestContext } from '../http-server.js';
 import { HttpServer } from '../http-server.js';
 export type NodeHttpServerContext = {

package/http/server/node/node-http-server.js

@@ -31,6 +31,7 @@ __export(node_http_server_exports, {
   NodeHttpServer: () => NodeHttpServer
 });
 module.exports = __toCommonJS(node_http_server_exports);
+var Http = __toESM(require("node:http"), 1);
 var import_container = require("../../../container/index.js");
 var import_core = require("../../../core.js");
 var import_disposable = require("../../../disposable/index.js");
@@ -44,7 +45,6 @@ var import_readable_stream_adapter = require("../../../utils/stream/readable-str
 var import_timer = require("../../../utils/timer.js");
 var import_timing = require("../../../utils/timing.js");
 var import_type_guards = require("../../../utils/type-guards.js");
-var Http = __toESM(require("node:http"), 1);
 var import_rxjs = require("rxjs");
 var import_http_server_request = require("../http-server-request.js");
 var import_http_server = require("../http-server.js");

package/mail/models/mail-template.model.d.ts

@@ -1,11 +1,14 @@
 import type { Template, TemplateField } from '../../templates/template.model.js';
-export type MailTemplate<Context extends object = any> = Template<{
+import type { Record } from '../../types.js';
+export type MailTemplate<Context extends Record = any> = Template<{
     subject: false;
     html: false;
     text: false;
 }, undefined, Context>;
-export declare function mailTemplate<Context extends object>(name: string, fields: {
-    subject?: TemplateField;
-    html?: TemplateField;
-    text?: TemplateField;
-}): MailTemplate<Context>;
+type MailTemplateFields<Context extends Record> = {
+    subject?: TemplateField<string, string, any, Context>;
+    html?: TemplateField<string, string, any, Context>;
+    text?: TemplateField<string, string, any, Context>;
+};
+export declare function mailTemplate<Context extends Record>(name: string, fields: MailTemplateFields<Context>): MailTemplate<Context>;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.84.24",
+  "version": "0.84.26",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -35,14 +35,14 @@
     "@types/nodemailer": "6.4",
     "@typescript-eslint/eslint-plugin": "5.59",
     "@typescript-eslint/parser": "5.59",
-    "concurrently": "8.1",
-    "esbuild": "0.17",
-    "eslint": "8.41",
+    "concurrently": "8.2",
+    "esbuild": "0.18",
+    "eslint": "8.42",
     "eslint-import-resolver-typescript": "3.5",
     "eslint-plugin-import": "2.27",
     "tsc-alias": "1.8",
     "typedoc": "0.24",
-    "typescript": "5.0"
+    "typescript": "5.1"
   },
   "peerDependencies": {
     "@elastic/elasticsearch": "^8.8",
@@ -58,13 +58,13 @@
     "koa": "^2.14",
     "minio": "^7.1",
     "mjml": "^4.14",
-    "mongodb": "^5.5",
+    "mongodb": "^5.6",
     "nodemailer": "^6.9",
-    "playwright": "^1.34",
+    "playwright": "^1.35",
     "preact": "^10.15",
-    "preact-render-to-string": "^6.0",
+    "preact-render-to-string": "^6.1",
     "undici": "^5.22",
-    "urlpattern-polyfill": "^8.0"
+    "urlpattern-polyfill": "^9.0"
   },
   "peerDependenciesMeta": {
     "@tstdl/angular": {

package/templates/resolvers/jsx.template-resolver.d.ts

@@ -1,15 +1,15 @@
-import type { TypedOmit } from '../../types.js';
+import type { Record, TypedOmit } from '../../types.js';
 import type { ComponentClass, FunctionComponent } from 'preact';
 import { TemplateField } from '../template.model.js';
 import type { TemplateRenderer, TemplateRendererOptions, TemplateRendererString } from '../template.renderer.js';
 import { TemplateResolver } from '../template.resolver.js';
-export type JsxTemplate = FunctionComponent<any> | ComponentClass<any, any>;
-export declare class JsxTemplateField<Renderer extends string = string, Options = any> extends TemplateField<'string', Renderer, Options> {
-    template: JsxTemplate;
+export type JsxTemplate<Context extends Record = any> = FunctionComponent<Context> | ComponentClass<Context, any>;
+export declare class JsxTemplateField<Renderer extends string = string, Options = any, Context extends Record = any> extends TemplateField<'string', Renderer, Options, Context> {
+    template: JsxTemplate<Context>;
 }
 export declare class JsxTemplateResolver extends TemplateResolver<JsxTemplateField, JsxTemplate> {
     constructor();
     canHandle(resolver: string): boolean;
     resolve(field: JsxTemplateField): JsxTemplate;
 }
-export declare function jsxTemplateField<Renderer extends TemplateRenderer>(field: TypedOmit<JsxTemplateField<Renderer[TemplateRendererString], Renderer[TemplateRendererOptions]>, 'resolver'>): JsxTemplateField<Renderer[TemplateRendererString], Renderer[TemplateRendererOptions]>;
+export declare function jsxTemplateField<Renderer extends TemplateRenderer, Context extends Record = any>(field: TypedOmit<JsxTemplateField<Renderer[TemplateRendererString], Renderer[TemplateRendererOptions], Context>, 'resolver'>): JsxTemplateField<Renderer[TemplateRendererString], Renderer[TemplateRendererOptions], Context>;

package/templates/resolvers/string.template-resolver.d.ts

@@ -2,13 +2,13 @@ import type { Record, TypedOmit } from '../../types.js';
 import { TemplateField } from '../template.model.js';
 import type { TemplateRenderer, TemplateRendererOptions, TemplateRendererString } from '../template.renderer.js';
 import { TemplateResolver } from '../template.resolver.js';
-export type StringTemplate = string | ((context: Record) => string | Promise<string>);
-export declare class StringTemplateField<Renderer extends string = string, Options = any> extends TemplateField<'string', Renderer, Options> {
-    template: StringTemplate;
+export type StringTemplate<Context extends Record = any> = string | ((context: Context) => string | Promise<string>);
+export declare class StringTemplateField<Renderer extends string = string, Options = any, Context extends Record = any> extends TemplateField<'string', Renderer, Options, Context> {
+    template: StringTemplate<Context>;
 }
 export declare class StringTemplateResolver extends TemplateResolver<StringTemplateField> {
     constructor();
     canHandle(resolver: string): boolean;
-    resolve(field: StringTemplateField): StringTemplate;
+    resolve(field: StringTemplateField): StringTemplate<Record>;
 }
-export declare function stringTemplateField<Renderer extends TemplateRenderer>(field: TypedOmit<StringTemplateField<Renderer[TemplateRendererString], Renderer[TemplateRendererOptions]>, 'resolver'>): StringTemplateField<Renderer[TemplateRendererString], Renderer[TemplateRendererOptions]>;
+export declare function stringTemplateField<Renderer extends TemplateRenderer, Context extends Record = any>(field: TypedOmit<StringTemplateField<Renderer[TemplateRendererString], Renderer[TemplateRendererOptions], Context>, 'resolver'>): StringTemplateField<Renderer[TemplateRendererString], Renderer[TemplateRendererOptions], Context>;

package/templates/template.model.d.ts

@@ -1,21 +1,23 @@
 import type { PickBy, Record, SimplifyObject } from '../types.js';
-export type TemplateContext<T extends Template> = T[typeof templateContext];
-export declare const templateContext: unique symbol;
-export declare class TemplateField<Resolver extends string = string, Renderer extends string = string, Options = any> {
+export type TemplateContext<T extends Template> = Parameters<NonNullable<T[typeof templateContext]>>[0];
+declare const templateContext: unique symbol;
+export declare class TemplateField<Resolver extends string = string, Renderer extends string = string, Options = any, Context extends Record = any> {
+    readonly [templateContext]?: (context: Context) => void;
     resolver: Resolver;
     renderer: Renderer;
     options?: Options;
 }
-export type TemplateFields<Fields extends Record<string, boolean>, Resolver extends string = string, Renderer extends string = string, Options = any> = SimplifyObject<{
-    [P in keyof PickBy<Fields, true>]: TemplateField<Resolver, Renderer, Options>;
+export type TemplateFields<Fields extends Record<string, boolean>, Resolver extends string = string, Renderer extends string = string, Options = any, Context extends Record = any> = SimplifyObject<{
+    [P in keyof PickBy<Fields, true>]: TemplateField<Resolver, Renderer, Options, Context>;
 } & {
-    [P in keyof PickBy<Fields, false>]?: TemplateField<Resolver, Renderer, Options>;
+    [P in keyof PickBy<Fields, false>]?: TemplateField<Resolver, Renderer, Options, Context>;
 }>;
-export declare abstract class Template<Fields extends Record<string, boolean> = Record<string, boolean>, TemplateOptions = any, Context extends Record = Record> {
-    readonly [templateContext]?: Context;
+export declare abstract class Template<Fields extends Record<string, boolean> = Record<string, boolean>, TemplateOptions = any, Context extends Record = any> {
+    readonly [templateContext]?: (context: Context) => void;
     /** name of template */
     name: string;
-    fields: TemplateFields<Fields>;
+    fields: TemplateFields<Fields, string, string, any, Context>;
     options?: TemplateOptions;
 }
 export declare function simpleTemplate(name: string, template: TemplateField): Template;
+export {};

package/templates/template.model.js

@@ -20,8 +20,7 @@ var template_model_exports = {};
 __export(template_model_exports, {
   Template: () => Template,
   TemplateField: () => TemplateField,
-  simpleTemplate: () => simpleTemplate,
-  templateContext: () => templateContext
+  simpleTemplate: () => simpleTemplate
 });
 module.exports = __toCommonJS(template_model_exports);
 var import_schema = require("../schema/index.js");
@@ -39,7 +38,6 @@ var __metadata = function(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
     return Reflect.metadata(k, v);
 };
-const templateContext = Symbol("templateData");
 let TemplateField = class TemplateField2 {
   resolver;
   renderer;

package/templates/tokens.d.ts

@@ -1,4 +1,4 @@
 import type { TemplateRenderer } from './template.renderer.js';
 import type { TemplateResolver } from './template.resolver.js';
 export declare const TEMPLATE_RENDERERS: import("../container/index.js").InjectionToken<TemplateRenderer<string, any>[], any>;
-export declare const TEMPLATE_RESOLVERS: import("../container/index.js").InjectionToken<TemplateResolver<import("./template.model.js").TemplateField<string, string, any>, unknown>[], any>;
+export declare const TEMPLATE_RESOLVERS: import("../container/index.js").InjectionToken<TemplateResolver<import("./template.model.js").TemplateField<string, string, any, any>, unknown>[], any>;

package/utils/iterable-helpers/assert.d.ts

@@ -1,2 +1,2 @@
 import type { Predicate, TypePredicate } from './types.js';
-export declare function assert<T, TPredicate extends T = T>(iterable: Iterable<T>, predicate: Predicate<T> | TypePredicate<T, TPredicate>): IterableIterator<TPredicate>;
+export declare function assert<T, TPredicate extends T = T>(iterable: Iterable<T>, predicate: TypePredicate<T, TPredicate> | Predicate<T>): IterableIterator<TPredicate>;