@tstdl/base 0.84.21 → 0.84.23

package/browser/document-controller.d.ts

@@ -1,5 +1,6 @@
-import type { ElementHandle, Frame, Page } from 'playwright';
+import type { ElementHandle, Frame, FrameLocator, Page } from 'playwright';
 import type { Delay } from './element-controller.js';
+import { ElementController } 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';
@@ -11,16 +12,16 @@ export type DocumentControllerForwardOptions = {
     pageControllerOptions: PageControllerOptions;
     frameControllerOptions: FrameControllerOptions;
 };
-export declare class DocumentController extends LocatorController {
+export declare class DocumentController<T extends Page | Frame = Page | Frame> extends LocatorController<T> {
     protected readonly forwardOptions: DocumentControllerForwardOptions;
     /** @deprecated should be avoided */
-    readonly document: Page | Frame;
-    constructor(document: Page | Frame, options: DocumentControllerOptions, forwardOptions: DocumentControllerForwardOptions);
+    readonly document: T;
+    constructor(document: T, 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>;
-    locateInFrame(frameSelector: string): LocatorController;
+    waitForElement(selector: string, options?: Parameters<Page['waitForSelector']>[1]): Promise<ElementController<ElementHandle<SVGElement | HTMLElement>>>;
+    locateInFrame(frameSelector: string): LocatorController<FrameLocator>;
     waitForFrame(selector: string, options?: Parameters<Page['waitForSelector']>[1]): Promise<FrameController>;
 }

package/browser/document-controller.js

@@ -32,6 +32,7 @@ __export(document_controller_exports, {
 });
 module.exports = __toCommonJS(document_controller_exports);
 var import_type_guards = require("../utils/type-guards.js");
+var import_element_controller = require("./element-controller.js");
 var import_locator_controller = require("./locator-controller.js");
 class DocumentController extends import_locator_controller.LocatorController {
   forwardOptions;
@@ -59,7 +60,7 @@ class DocumentController extends import_locator_controller.LocatorController {
     if ((0, import_type_guards.isNull)(element)) {
       throw new Error("Element not found.");
     }
-    return element;
+    return new import_element_controller.ElementController(element, this.elementControllerOptions);
   }
   locateInFrame(frameSelector) {
     const locator = this.document.frameLocator(frameSelector);
@@ -67,7 +68,7 @@ class DocumentController extends import_locator_controller.LocatorController {
   }
   async waitForFrame(selector, options) {
     const element = await this.waitForElement(selector, options);
-    const frame = await element.contentFrame();
+    const frame = await element.locatorOrHandle.contentFrame();
     if ((0, import_type_guards.isNull)(frame)) {
       throw new Error("Element is not a frame.");
     }

package/browser/element-controller.d.ts

@@ -16,10 +16,10 @@ export type ElementControllerOptions = {
     typeDelay?: Delay;
 };
 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;
+export declare class ElementController<T extends Locator | ElementHandle = Locator | ElementHandle> {
+    readonly locatorOrHandle: T;
     readonly options: ElementControllerOptions;
-    constructor(locatorOrHandle: Locator | ElementHandle, options?: ElementControllerOptions);
+    constructor(locatorOrHandle: T, 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>;

package/browser/frame-controller.d.ts

@@ -7,7 +7,7 @@ export type FrameControllerOptions = DocumentControllerOptions;
 export type FrameControllerForwardOptions = {
     pageControllerOptions: PageControllerOptions;
 };
-export declare class FrameController extends DocumentController {
+export declare class FrameController extends DocumentController<Frame> {
     private readonly frameControllerForwardOptions;
     /** @deprecated should be avoided */
     readonly frame: Frame;

package/browser/locator-controller.d.ts

@@ -2,15 +2,15 @@ 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 {
+export declare class LocatorController<T extends Page | Frame | Locator | FrameLocator = Page | Frame | Locator | FrameLocator> {
     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;
+    readonly locatable: T;
+    constructor(locatable: T, elementControllerOptions: ElementControllerOptions);
+    getBySelector(selector: string, options?: SimplifyObject<Pick<NonUndefinable<Parameters<Page['locator']>[1]>, 'hasText' | 'hasNotText'>>): ElementController<Locator>;
+    getByRole(role: Parameters<Page['getByRole']>[0], options?: Parameters<Page['getByRole']>[1]): ElementController<Locator>;
+    getByLabel(text: Parameters<Page['getByLabel']>[0], options?: Parameters<Page['getByLabel']>[1]): ElementController<Locator>;
+    getByAltText(text: Parameters<Page['getByAltText']>[0], options?: Parameters<Page['getByAltText']>[1]): ElementController<Locator>;
+    getByPlaceholder(text: Parameters<Page['getByPlaceholder']>[0], options?: Parameters<Page['getByPlaceholder']>[1]): ElementController<Locator>;
+    getByText(text: Parameters<Page['getByText']>[0], options?: Parameters<Page['getByText']>[1]): ElementController<Locator>;
+    getByTitle(text: Parameters<Page['getByTitle']>[0], options?: Parameters<Page['getByTitle']>[1]): ElementController<Locator>;
 }

package/browser/page-controller.d.ts

@@ -10,7 +10,7 @@ import type { Abortable } from './types.js';
 export type PageControllerOptions = DocumentControllerOptions & {
     defaultFrameControllerOptions?: FrameControllerOptions;
 };
-export declare class PageController extends DocumentController implements AsyncDisposable {
+export declare class PageController extends DocumentController<Page> implements AsyncDisposable {
     /** @deprecated should be avoided */
     readonly page: Page;
     readonly options: PageControllerOptions;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.84.21",
+  "version": "0.84.23",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -29,7 +29,7 @@
     "@types/chroma-js": "2.4",
     "@types/koa__router": "12.0",
     "@types/luxon": "3.3",
-    "@types/minio": "7.0",
+    "@types/minio": "7.1",
     "@types/mjml": "4.7",
     "@types/node": "20",
     "@types/nodemailer": "6.4",
@@ -45,7 +45,7 @@
     "typescript": "5.0"
   },
   "peerDependencies": {
-    "@elastic/elasticsearch": "^8.7",
+    "@elastic/elasticsearch": "^8.8",
     "@koa/router": "^12.0",
     "@tstdl/angular": "^0.84",
     "@zxcvbn-ts/core": "^3.0",

package/signals/implementation/api.d.ts

@@ -25,9 +25,9 @@ export interface Signal<T> {
     [SIGNAL]?: unknown;
 }
 /**
- * Checks if the given `value` function is a reactive `Signal`.
+ * Checks if the given `value` is a reactive `Signal`.
  */
-export declare function isSignal(value: Function): value is Signal<unknown>;
+export declare function isSignal(value: unknown): value is Signal<unknown>;
 /**
  * Converts `fn` into a marked signal function (where `isSignal(fn)` will be `true`).
  *

package/signals/implementation/api.js

@@ -32,7 +32,7 @@ module.exports = __toCommonJS(api_exports);
  */
 const SIGNAL = Symbol("SIGNAL");
 function isSignal(value) {
-  return value[SIGNAL] !== void 0;
+  return typeof value == "function" && value[SIGNAL] !== void 0;
 }
 function createSignalFromFunction(node, fn, extraApi = {}) {
   fn[SIGNAL] = node;

package/text/localization.service.d.ts

@@ -27,7 +27,16 @@ export type ProxyLocalizationKey<Parameters = void> = PropertyName & {
     [parametersSymbol]?: Parameters;
 };
 export type LocalizationKey<Parameters = void> = string | ProxyLocalizationKey<Parameters>;
-export type LocalizationData<Parameters = any> = LocalizationKey | LocalizationDataObject<Parameters> | {
+export type EnumLocalizationKey<T extends Enumeration = Enumeration, Parameters = void> = Parameters extends void ? {
+    enum: T;
+    value?: EnumerationValue<T>;
+    parameters?: void;
+} : {
+    enum: T;
+    value?: EnumerationValue<T>;
+    parameters: Parameters;
+};
+export type LocalizationData<Parameters = any, E extends Enumeration = any> = LocalizationKey | EnumLocalizationKey<E, Parameters> | LocalizationDataObject<Parameters> | {
     key: LocalizationKey;
     parameters?: void;
 };
@@ -40,6 +49,8 @@ export type ProxyLocalizationKeys<T extends LocalizationTemplate> = {
 };
 export declare function getProxyLocalizationKey<Parameters = void>(key: string): ProxyLocalizationKey<Parameters>;
 export declare function isProxyLocalizationKey(value: any): value is ProxyLocalizationKey;
+export declare function isEnumLocalizationKey(key: any): key is EnumLocalizationKey;
+export declare function isLocalizationDataObject(value: LocalizationData): value is LocalizationDataObject<any>;
 /** helper function to ensure type safety */
 export declare function localizationData<T>(data: LocalizationData<T>): LocalizationData<T>;
 /**
@@ -65,9 +76,9 @@ export declare class LocalizationService {
     getLanguage(languageCode: string): Language;
     setLanguage(languageOrCode: Language | string): void;
     setLocalization(localization: Localization): void;
-    tryGetItem<Parameters>(key: LocalizationKey<Parameters> | LocalizationData<Parameters>): LocalizeItem | undefined;
+    tryGetItem<Parameters>(keyOrData: LocalizationKey<Parameters> | LocalizationData<Parameters>): LocalizeItem | undefined;
     hasKey<Parameters>(key: LocalizationKey<Parameters> | LocalizationData<Parameters>): boolean;
-    localize<Parameters>(keyOrData: LocalizationKey<Parameters> | LocalizationData<Parameters>): string;
+    localize<Parameters = void>(keyOrData: LocalizationKey<Parameters> | LocalizationData<Parameters>): string;
     localizeEnum<T extends Enumeration>(enumeration: T, value?: EnumerationValue<T>, parameters?: unknown): string;
     localize$<Parameters>(data: LocalizationData<Parameters>): Observable<string>;
     localizeEnum$<T extends Enumeration>(enumeration: T, value?: EnumerationValue<T>, parameters?: unknown): Observable<string>;

package/text/localization.service.js

@@ -23,6 +23,8 @@ __export(localization_service_exports, {
   enumerationLocalization: () => enumerationLocalization,
   getLocalizationKeys: () => getLocalizationKeys,
   getProxyLocalizationKey: () => getProxyLocalizationKey,
+  isEnumLocalizationKey: () => isEnumLocalizationKey,
+  isLocalizationDataObject: () => isLocalizationDataObject,
   isLocalizeItem: () => isLocalizeItem,
   isProxyLocalizationKey: () => isProxyLocalizationKey,
   localizationData: () => localizationData
@@ -62,6 +64,12 @@ function getProxyLocalizationKey(key) {
 function isProxyLocalizationKey(value) {
   return (0, import_property_name.isPropertyName)(value);
 }
+function isEnumLocalizationKey(key) {
+  return (0, import_type_guards.isObject)(key) && (0, import_object.hasOwnProperty)(key, "enum");
+}
+function isLocalizationDataObject(value) {
+  return (0, import_type_guards.isObject)(value) && (0, import_object.hasOwnProperty)(value, "key");
+}
 function localizationData(data) {
   return data;
 }
@@ -131,11 +139,15 @@ let LocalizationService = class LocalizationService2 {
   setLocalization(localization) {
     this.setLanguage(localization.language);
   }
-  tryGetItem(key) {
+  tryGetItem(keyOrData) {
     if ((0, import_type_guards.isUndefined)(this.activeLanguage)) {
       return void 0;
     }
-    const actualKey = getStringKey(key);
+    if (isEnumLocalizationKey(keyOrData)) {
+      const enumEntry = this.localizations.get(this.activeLanguage.code)?.enums.get(keyOrData.enum);
+      return (0, import_type_guards.isDefined)(keyOrData.value) ? enumEntry?.values[keyOrData.value] : enumEntry?.name;
+    }
+    const actualKey = getStringKey(keyOrData);
     return this.localizations.get(this.activeLanguage.code)?.keys.get(actualKey);
   }
   hasKey(key) {
@@ -144,6 +156,9 @@ let LocalizationService = class LocalizationService2 {
   }
   // eslint-disable-next-line max-statements
   localize(keyOrData) {
+    if (isEnumLocalizationKey(keyOrData)) {
+      return this.localizeEnum(keyOrData.enum, keyOrData.value, keyOrData.parameters);
+    }
     const key = getStringKey(keyOrData);
     const parameters = (0, import_type_guards.isString)(keyOrData) || isProxyLocalizationKey(keyOrData) ? {} : keyOrData.parameters;
     const templateOrFunction = (0, import_type_guards.isDefined)(this.activeLanguage) ? this.localizations.get(this.activeLanguage.code)?.keys.get(key) : void 0;