clientnode 4.0.1491 → 4.0.1492

package/dist/type.d.ts

@@ -1,248 +0,0 @@
-import type { Matchers } from 'expect';
-import type { Dirent as DirectoryEntry, Stats as FileStats } from 'fs';
-import type { Level } from './Logger';
-import type { TEST_DEFINED_SYMBOL, TEST_THROW_SYMBOL, TEST_UNDEFINED_SYMBOL } from './test-helper';
-export type AnyFunction = (...parameters: Array<any>) => any;
-export type Unpacked<T> = T extends Array<infer U> ? U : T extends (...parameters: Array<unknown>) => infer U ? U : T extends Promise<infer U> ? U : T;
-export type FirstParameter<FunctionType extends AnyFunction> = Parameters<FunctionType>[0];
-export type SecondParameter<FunctionType extends AnyFunction> = Parameters<FunctionType>[1];
-export type ThirdParameter<FunctionType extends AnyFunction> = Parameters<FunctionType>[2];
-export type ParametersExceptFirst<FunctionType> = FunctionType extends (parameter: any, ...additionalParameters: infer AdditionalParameters) => any ? AdditionalParameters : [
-];
-export type FunctionTestTuple<FunctionType extends AnyFunction> = [
-    ReturnType<FunctionType>,
-    ...Parameters<FunctionType>
-];
-export type FunctionTestAgainstResolvedPromiseTuple<FunctionType extends AnyFunction> = [Promise<ReturnType<FunctionType>>, ...Parameters<FunctionType>];
-export type FunctionTestPromiseTuple<FunctionType extends AnyFunction> = [
-    ThenParameter<ReturnType<FunctionType>>,
-    ...Parameters<FunctionType>
-];
-export type FunctionTestPromiseAgainstResolvedPromiseTuple<FunctionType extends AnyFunction> = [
-    Promise<ThenParameter<ReturnType<FunctionType>>>,
-    ...Parameters<FunctionType>
-];
-export type FunctionTestPromiseRejectionTuple<FunctionType extends AnyFunction> = [Error, ...Parameters<FunctionType>];
-export type FunctionTestPromiseRejectionAgainstResolvedPromiseTuple<FunctionType extends AnyFunction> = [Promise<Error>, ...Parameters<FunctionType>];
-export type TestSymbol = (typeof TEST_DEFINED_SYMBOL | typeof TEST_THROW_SYMBOL | typeof TEST_UNDEFINED_SYMBOL);
-export type ThenParameter<Type> = Type extends PromiseLike<infer U> ? U : Type;
-export type ThenParameterRecursive<Type> = Type extends PromiseLike<infer U> ? ThenParameterRecursive<U> : Type;
-export type ValueOf<Type> = Type[keyof Type];
-export type RecursiveNonNullable<Type> = {
-    [Property in keyof Type]: Type[Property] extends Array<infer OtherType> ? Array<RecursiveNonNullable<OtherType>> : Type[Property] extends AnyFunction ? NonNullable<Type[Property]> : Type[Property] extends Mapping<unknown> ? RecursiveNonNullable<Type[Property]> : NonNullable<Type[Property]>;
-};
-export type RecursivePartial<Type> = Partial<Type> | {
-    [Property in keyof Type]?: Type[Property] extends Array<infer OtherType> ? Array<RecursivePartial<OtherType>> : Type[Property] extends AnyFunction ? Partial<Type[Property]> : Type[Property] extends Mapping<unknown> ? RecursivePartial<Type[Property]> : Partial<Type[Property]>;
-};
-export type FileTraverseResult = false | null | Promise<false | null | undefined> | undefined;
-export type TestMatchers<T extends Promise<void> | void> = Matchers<T> & {
-    not: Matchers<T>;
-};
-export type ImportFunction = (id: string) => Promise<ReturnType<typeof require>>;
-export type HTMLItem = Comment | HTMLElement | Text;
-export type Primitive = boolean | null | number | string | undefined;
-export type Mapping<V = string, K extends string = string> = Record<K, V>;
-export type PlainObject<V = Primitive, K extends string = string> = {
-    [key in K]: Array<PlainObject<V, K> | V> | PlainObject<V, K> | V;
-};
-export interface ProxyHandler<T = unknown> {
-    deleteProperty: (target: T, key: string | symbol) => boolean;
-    get: (target: T, key: string | symbol) => unknown;
-    has: (target: T, key: string | symbol) => boolean;
-    set: (target: T, key: string | symbol, value: unknown) => boolean;
-}
-export type ProxyType<T = unknown> = T & {
-    __revoke__?: () => void;
-    __target__: T;
-};
-export interface CookieOptions {
-    domain: string;
-    httpOnly: boolean;
-    minimal: boolean;
-    numberOfDaysUntilExpiration: number;
-    path: string;
-    sameSite: 'Lax' | 'None' | 'Strict' | '';
-    secure: boolean;
-}
-export interface KnownWindowEventMap extends WindowEventMap {
-    DOMMouseScroll: Event;
-    mousewheel: Event;
-}
-export type KnownEventName = keyof KnownWindowEventMap;
-export type UnknownFunction = (...parameters: Array<unknown>) => unknown;
-export type ArrayTransformer<T = unknown, R = unknown, P = unknown> = (data: Array<T>, ...additionalParameter: Array<P>) => Array<R>;
-export type SynchronousProcedureFunction = (...parameters: Array<unknown>) => void;
-export type AsynchronousProcedureFunction = (...parameters: Array<unknown>) => Promise<void>;
-export type ProcedureFunction = AsynchronousProcedureFunction | SynchronousProcedureFunction;
-export type GetterFunction = (keyOrValue: unknown, key: string | symbol, target: unknown) => unknown;
-export type SetterFunction = (key: string | symbol, value: unknown, target: unknown) => unknown;
-export interface CheckReachabilityOptions {
-    abortController: AbortController;
-    expectedIntermediateStatusCodes: Array<number> | number;
-    options: RequestInit;
-    pollIntervallInSeconds: number;
-    statusCodes: Array<number> | number;
-    timeoutInSeconds: number;
-    wait: boolean;
-}
-export interface CompareOptions {
-    compareBlobs: boolean;
-    deep: number;
-    exceptionPrefixes: Array<string>;
-    ignoreFunctions: boolean;
-    properties: Array<string> | null;
-    returnReasonIfNotEqual: boolean;
-}
-export type Encoding = 'ascii' | 'base64' | 'base64url' | 'binary' | 'hex' | 'latin1' | 'ucs2' | 'ucs-2' | 'utf8' | 'utf16le' | 'utf-8';
-export interface File {
-    directoryPath: string;
-    directoryEntry: DirectoryEntry | null;
-    error: Error | null;
-    name: string;
-    path: string;
-    stats: FileStats | null;
-}
-export interface ProcessError extends Error {
-    parameters: Array<unknown>;
-    returnCode: number;
-}
-export type QueryParameters = Array<Array<string> | string> & Mapping<Array<string> | string>;
-export interface TimeoutPromise extends Promise<boolean> {
-    clear: () => void;
-    timeoutID: NodeJS.Timeout;
-}
-export type ObjectMask = Array<string> | boolean | {
-    [key: string]: ObjectMask;
-};
-export type NormalizedObjectMask = boolean | Mapping<ObjectMask>;
-export interface ObjectMaskConfiguration {
-    exclude?: ObjectMask;
-    include?: ObjectMask;
-}
-export interface ExpressionOptions {
-    async: boolean;
-    execute: boolean;
-    removeGlobalScope: boolean;
-    binding: unknown;
-}
-export interface CompileExpressionOptions<N extends Array<string> = Array<string>> extends ExpressionOptions {
-    scope: Mapping<unknown> | N | N[number] | string;
-}
-export interface EvaluateExpressionOptions<S extends object = object> extends ExpressionOptions {
-    scope: S;
-}
-export interface EvaluateObject {
-    __evaluate__: string;
-}
-export interface ExecuteObject {
-    __execute__: string;
-}
-export type Evaluateable = EvaluateObject | ExecuteObject;
-export type EvaluatedObject<Type extends object> = {
-    [Property in keyof Type]: (Type[Property] extends Evaluateable ? unknown : Type[Property] extends object ? EvaluatedObject<Type[Property]> : Type[Property]);
-};
-export type RecursiveEvaluateable<Type> = Evaluateable | {
-    [Property in keyof Type]: (Evaluateable | (Type[Property] extends Array<infer OtherType> ? Array<RecursiveEvaluateable<OtherType>> : Type[Property] extends Mapping<unknown> ? RecursiveEvaluateable<Type[Property]> : Evaluateable | Type[Property]));
-};
-export interface AsyncEvaluateObject {
-    __await_evaluate__: string;
-}
-export interface AsyncExecuteObject {
-    __await_execute__: string;
-}
-export type AsyncEvaluateable = AsyncEvaluateObject | AsyncExecuteObject;
-export type AsyncEvaluatedObject<Type extends object> = {
-    [Property in keyof Type]: (Type[Property] extends AsyncEvaluateable ? unknown : Type[Property] extends object ? AsyncEvaluatedObject<Type[Property]> : Type[Property]);
-};
-export type RecursiveAsyncEvaluateable<Type> = AsyncEvaluateable | {
-    [Property in keyof Type]: (AsyncEvaluateable | (Type[Property] extends Array<infer OtherType> ? Array<RecursiveAsyncEvaluateable<OtherType>> : Type[Property] extends Mapping<unknown> ? RecursiveAsyncEvaluateable<Type[Property]> : AsyncEvaluateable | Type[Property]));
-};
-export interface PaginateOptions {
-    boundaryCount: number;
-    disabled: boolean;
-    hideNextButton: boolean;
-    hidePrevButton: boolean;
-    page: number;
-    pageSize?: null | number;
-    showFirstButton: boolean;
-    showLastButton: boolean;
-    siblingCount: number;
-    total: number;
-}
-export interface Page {
-    disabled: boolean;
-    page?: number;
-    selected: boolean;
-    type: PageType;
-}
-export type PageType = 'end-ellipsis' | 'first' | 'last' | 'next' | 'page' | 'previous' | 'start-ellipsis';
-export interface Offset {
-    left: number;
-    top: number;
-}
-export interface Position extends Offset {
-    bottom: number;
-    right: number;
-}
-export type ProcessHandler = (returnCode: unknown, ...parameters: Array<unknown>) => void;
-export interface ProcessCloseReason {
-    parameters: Array<unknown>;
-    reason: unknown;
-}
-export type ProcessCloseCallback = (reason: ProcessCloseReason) => void;
-export type ProcessErrorCallback = (reason: ProcessError) => void;
-export type RelativePosition = 'above' | 'below' | 'in' | 'left' | 'right';
-export type TemplateFunction<Type = string> = (...parameters: Array<unknown>) => Type;
-export interface CompilationResult<T = string, N extends Array<string> = Array<string>> {
-    error: null | string;
-    globalNames: Array<string>;
-    globalNamesUndefinedList: Array<undefined>;
-    originalScopeNames: N;
-    scopeNameMapping: Record<N[number], string>;
-    scopeNames: Array<string>;
-    templateFunction: TemplateFunction<T>;
-}
-export interface NegativeEvaluationResult {
-    compileError: null | string;
-    error: string;
-    result: undefined;
-    runtimeError: null | string;
-}
-export interface PositiveEvaluationResult<Type = string> {
-    compileError: null;
-    error: null;
-    result: Type;
-    runtimeError: null;
-}
-export type EvaluationResult<Type = string> = PositiveEvaluationResult<Type> | NegativeEvaluationResult;
-export type LockCallbackFunction<Type> = (description?: string) => Promise<Type> | Type;
-export interface StringMarkOptions {
-    marker: ((foundWord: string, markedTarget: Array<unknown>) => unknown) | string;
-    normalizer: (value: unknown) => string;
-    skipTagDelimitedParts: null | [string, string];
-}
-export interface InterruptableScrollToOptions {
-    targetDomNode: HTMLElement;
-    containerDomNode: HTMLElement | Window;
-    durationInMilliseconds: number;
-    interruptOnManualScroll: boolean;
-    offset: {
-        top: number;
-        left: number;
-    };
-}
-export interface GivenInterruptableScrollToOptions extends Partial<ScrollToOptions> {
-    targetDomNode?: Node | null;
-    containerDomNode?: Node | null | Window;
-    offset?: Partial<InterruptableScrollToOptions['offset']>;
-}
-export interface LoggerOptions {
-    level: Level;
-    name: string;
-}
-export interface EvaluateDynamicDataOptions {
-    scope: Mapping<unknown>;
-    selfReferenceName: string;
-    expressionIndicatorKey: string;
-    executionIndicatorKey: string;
-}

package/dist/utility.d.ts

@@ -1,44 +0,0 @@
-import type { TimeoutPromise } from './type';
-/**
- * Prevents event functions from triggering too often by defining a minimal
- * span between each function call. Additional arguments given to this function
- * will be forwarded to the given event function call.
- * @param callback - The function to call debounced.
- * @param thresholdInMilliseconds - The minimum time span between each
- * function call.
- * @param additionalArguments - Additional arguments to forward to given
- * function.
- * @returns Returns the wrapped method.
- */
-export declare const trailingThrottle: <T = unknown>(callback: (...parameters: Array<unknown>) => T, thresholdInMilliseconds?: number, ...additionalArguments: Array<unknown>) => (...parameters: Array<unknown>) => void;
-/**
- * Prevents event functions from triggering too close after each trigger by
- * defining a minimal span between each function call. Additional arguments
- * given to this function will be forwarded to the given event function call.
- * @param callback - The function to call debounced.
- * @param thresholdInMilliseconds - The minimum time span between each
- * function call.
- * @param additionalArguments - Additional arguments to forward to given
- * function.
- * @returns Returns the wrapped method.
- */
-export declare const debounce: <T = unknown>(callback: (...parameters: Array<unknown>) => T, thresholdInMilliseconds?: number, ...additionalArguments: Array<unknown>) => ((...parameters: Array<unknown>) => Promise<T>);
-/**
- * Triggers given callback after given duration. Supports unlimited
- * duration length and returns a promise which will be resolved after given
- * duration has been passed.
- * @param parameters - Observes the first three existing parameters. If one
- * is a number it will be interpreted as delay in milliseconds until given
- * callback will be triggered. If one is of type function it will be used
- * as callback and if one is of type boolean it will indicate if returning
- * promise should be rejected or resolved if given internally created
- * timeout should be canceled. Additional parameters will be forwarded to
- * given callback.
- * @returns A promise resolving after given delay or being rejected if
- * value "true" is within one of the first three parameters. The promise
- * holds a boolean indicating whether timeout has been canceled or
- * resolved.
- */
-export declare const timeout: (...parameters: Array<unknown>) => TimeoutPromise;
-export declare const preventDefault: (event: Event) => void;
-export declare const stopPropagation: (event: Event) => void;