clientnode 4.0.1440 → 4.0.1442

package/dist/type.d.ts

@@ -0,0 +1,230 @@
+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 FunctionTestPromiseTuple<FunctionType extends AnyFunction> = [
+    ThenParameter<ReturnType<FunctionType>>,
+    ...Parameters<FunctionType>
+];
+export type FunctionTestPromiseRejectionTuple<FunctionType extends AnyFunction> = [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 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

@@ -0,0 +1,44 @@
+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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clientnode",
-  "version": "4.0.1440",
+  "version": "4.0.1442",
   "description": "Handy utilities for any JavaScript environments.",
   "keywords": [
     "client",
@@ -127,7 +127,7 @@
     "yarn": ">=4"
   },
   "resolutions": {
-    "weboptimizer/clientnode": "4.0.1435",
+    "weboptimizer/clientnode": "4.0.1440",
     "colors": "1.4.0",
     "globals@npm:^14.0.0": "patch:globals@npm%3A11.12.0#~/.yarn/patches/globals-npm-11.12.0-1fa7f41a6c.patch",
     "globals@npm:^11.1.0": "patch:globals@npm%3A11.12.0#~/.yarn/patches/globals-npm-11.12.0-1fa7f41a6c.patch",