@e-mc/types 0.10.5 → 0.11.0

package/lib/logger.d.ts

@@ -1,5 +1,7 @@
 import type { LogStatus } from './squared';
 
+import type { HighResolutionTime } from './node';
+
 import type { LOG_STATE, LOG_TYPE, STATUS_TYPE } from '../index.d';
 
 import type { BackgroundColor as IBackgroundColor, ForegroundColor as IForegroundColor } from 'chalk';
@@ -12,6 +14,7 @@ export interface LogBaseOptions extends LoggerColor, Pick<LogOptions, "queue" |
     sessionId?: string;
     abortable?: boolean;
     titleJustify?: TextAlign;
+    rawOutput?: boolean;
     broadcastId?: BroadcastValue;
     newline?: boolean | number;
 }
@@ -52,6 +55,7 @@ export interface LogMessageOptions extends LogBaseOptions {
     messageUnit?: string;
     messageUnitMinWidth?: number;
     messageUnitIndent?: number | [number, string];
+    messageTextWrap?: boolean | TextWrapStyle;
     progressBar?: boolean;
     alwaysVisible?: boolean;
     titleIndent?: boolean | number;
@@ -101,11 +105,12 @@ export type LogState = LOG_STATE[keyof LOG_STATE];
 export type StatusName = keyof typeof STATUS_TYPE;
 export type LogDate = Date | number;
 export type LogTime = LogDate | HighResolutionTime;
-export type LogValue = string | [string, Null<string>?];
+export type LogValue = string | [string, (string | null)?];
 export type LogComponent = Partial<Pick<LogStatus<StatusType>, "type" | "value" | "timeStamp" | "duration" | "from" | "source">>;
 export type BackgroundColor = typeof IBackgroundColor | HexColor;
 export type ForegroundColor = typeof IForegroundColor | HexColor;
 export type TextAlign = "left" | "center" | "right";
+export type TextWrapStyle = "ellipsis" | "nowrap" | "ellipsis-end" | "nowrap-end" | "none";
 export type ErrorOutMethod = (err: Error, data: LogTypeValue, require?: NodeRequire) => void;
 export type BroadcastOutMethod = (value: string, options: LogMessageOptions, require?: NodeRequire) => void;
-export type BroadcastValue = ArrayOf<string> | { value: ArrayOf<string>; stripAnsi?: boolean };
+export type BroadcastValue = string | string[] | { value: string | string[]; stripAnsi?: boolean };

package/lib/module.d.ts

@@ -2,9 +2,10 @@ import type { ChecksumBase } from './squared';
 
 import type { StreamAction } from './asset';
 
-import type { HashOptions } from 'crypto';
+import type { HashOptions } from 'node:crypto';
+import type { Readable } from 'node:stream';
 
-declare enum NORMALIZE_FLAGS {
+export const enum NORMALIZE_FLAGS {
     NONE = 0,
     RESOLVE = 1,
     ENSURE_DIR = 2,
@@ -12,7 +13,22 @@ declare enum NORMALIZE_FLAGS {
 }
 
 export interface RequireAction {
-    requireExt?: ArrayOf<string> | boolean;
+    requireExt?: string | string[] | boolean;
+}
+
+export interface ThrowsAction {
+    throwsPermission?: boolean;
+    throwsDoesNotExist?: boolean;
+}
+
+export interface ExecAction {
+    uid?: number | string;
+    gid?: number | string;
+}
+
+export interface IncludeAction<T = string[]> {
+    include?: T;
+    exclude?: T;
 }
 
 export interface PermissionOptions {
@@ -20,11 +36,9 @@ export interface PermissionOptions {
     hostPermissionOnly?: boolean;
 }
 
-export interface FileSystemOptions extends PermissionOptions {
+export interface FileSystemOptions extends PermissionOptions, ThrowsAction {
     absolutePath?: boolean;
     ignorePermission?: boolean;
-    throwsPermission?: boolean;
-    throwsDoesNotExist?: boolean;
 }
 
 export interface ReadFileOptions extends FileSystemOptions, StreamBase, RequireAction {
@@ -55,10 +69,6 @@ export interface RemoveDirOptions extends FileSystemOptions {
 export type MoveFileOptions = CopyFileOptions;
 export type CreateDirOptions = FileSystemOptions;
 
-export interface GetFunctionsOptions extends ParseFunctionOptions {
-    outFailed?: string[];
-}
-
 export interface ParseFunctionOptions extends RequireAction {
     absolute?: boolean;
     sync?: boolean;
@@ -66,22 +76,13 @@ export interface ParseFunctionOptions extends RequireAction {
     context?: unknown;
 }
 
-export interface CloneObjectOptions<T = unknown> {
-    target?: T;
-    deep?: boolean;
-    deepIgnore?: WeakSet<object>;
-    typedArray?: boolean;
-    mergeArray?: MergeArrayMethod;
-    mergeDepth?: number;
-    symbol?: boolean;
-    inherited?: boolean;
-    nonenumerable?: boolean;
-    preserve?: boolean;
-}
-
-export interface CheckSemVerOptions extends MinMax {
+export interface CheckSemVerOptions {
+    min?: number;
+    max?: number;
+    equals?: string;
+    includes?: boolean;
     startDir?: string;
-    unstable?: boolean;
+    unstable: boolean;
 }
 
 export interface CopyDirOptions {
@@ -102,7 +103,7 @@ export interface CopyDirResult {
 }
 
 export interface GlobDirOptions {
-    exclude?: ArrayOf<string>;
+    exclude?: string | string[];
     recursive?: boolean | number;
     matchBase?: boolean;
     dot?: boolean;
@@ -122,12 +123,9 @@ export interface ReadBufferOptions extends StreamBase {
     cache?: boolean;
 }
 
-export interface AsHashOptions extends HashOptions, ChecksumBase {
-    /** @deprecated */
-    minLength?: number;
-}
+export interface AsHashOptions extends HashOptions, ChecksumBase {}
 
-export interface GetTempDirOptions {
+export interface TempDirOptions {
     pathname?: string;
     filename?: string;
     moduleDir?: boolean;
@@ -136,18 +134,7 @@ export interface GetTempDirOptions {
     increment?: number;
 }
 
-export interface ExecAction {
-    uid?: NumString;
-    gid?: NumString;
-}
-
-export interface IncludeAction<T = string[]> {
-    include?: T;
-    exclude?: T;
-}
-
-export type NormalizeFlags = typeof NORMALIZE_FLAGS[keyof typeof NORMALIZE_FLAGS];
 export type ReadTextOptions = ReadBufferOptions;
-export type ReadFileCallback<T extends Bufferable = Bufferable> = (err: Null<NodeJS.ErrnoException>, data?: T) => void;
+export type ReadFileCallback<T extends Bufferable = Bufferable> = (err: NodeJS.ErrnoException | null, data?: T) => void;
 export type ProtocolType = "http" | "https" | "http/s" | "ftp" | "sftp" | "s/ftp" | "torrent" | "unc" | "file";
-export type MergeArrayMethod = "concat" | "concat-pre" | "includes" | "unshift" | "push" | "flat" | "join" | "slice" | "reverse" | ["flat", number] | ["join", string] | ["slice", number, number?];
+export type FileTypeFormat = Bufferable | Uint8Array | ArrayBuffer | Readable;

package/lib/node.d.ts

@@ -1,10 +1,10 @@
 import type { RequestData as IRequestData } from './squared';
 
 import type { ExternalAsset } from './asset';
-import type { HostInitConfig } from './core';
+import type { HostInitConfig, HostInitLog } from './core';
 import type { DownloadModule, ErrorModule, LoggerModule, MemoryModule, NodeModule, PermissionModule, ProcessModule, RequestModule, TempModule } from './settings';
 
-export interface RequestData<T extends ExternalAsset = ExternalAsset> extends Readonly<Omit<IRequestData, "log">>, Readonly<HostInitConfig> {
+export interface RequestData<T extends ExternalAsset = ExternalAsset, U extends HostInitLog = HostInitLog> extends Readonly<Omit<IRequestData, "log">>, Readonly<HostInitConfig<U>> {
     readonly assets?: T[];
 }
 
@@ -19,4 +19,10 @@ export interface Settings {
     request?: RequestModule;
     error?: ErrorModule;
     logger?: LoggerModule;
-}
+}
+
+export interface ErrorCode extends Error {
+    code?: unknown;
+}
+
+export type HighResolutionTime = bigint | [number, number];

package/lib/object.d.ts

@@ -1,5 +1,3 @@
-/* eslint @typescript-eslint/no-redeclare: "off" */
-
 interface Point {
     x: number;
     y: number;
@@ -29,4 +27,4 @@ interface MinMax<T = number> {
     max?: T;
 }
 
-type HighResolutionTime = TupleOf<number>;
+type HighResolutionTime = bigint | [number, number];

package/lib/request.d.ts

@@ -1,8 +1,11 @@
+import type { IRequest } from './index';
 import type { BinaryAction } from './asset';
-import type { HttpProtocolVersion, InternetProtocolVersion } from './http';
+import type { HttpProtocolVersion, HttpRequestClient, InternetProtocolVersion } from './http';
+import type { IncludeAction } from './module';
+import type { HttpHostSettings, RequestModule } from './settings';
 
-import type { IncomingHttpHeaders, OutgoingHttpHeaders } from 'http';
-import type { Readable, Writable } from 'stream';
+import type { IncomingHttpHeaders, OutgoingHttpHeaders } from 'node:http';
+import type { Readable, Writable } from 'node:stream';
 
 interface KeepAliveAction {
     keepAlive?: boolean;
@@ -21,7 +24,7 @@ interface ProtocolAction {
 export interface IHttpHost {
     localhost: boolean;
     hasProtocol(version: HttpProtocolVersion): Promise<number>;
-    upgrade(version: HttpProtocolVersion, altSvc: Undef<string>): void;
+    upgrade(version: HttpProtocolVersion, altSvc: string | undefined): void;
     success(version: HttpProtocolVersion, status?: boolean): number;
     failed(version: HttpProtocolVersion, status?: boolean): number;
     error(version: HttpProtocolVersion, status?: boolean): number;
@@ -39,44 +42,108 @@ export interface IHttpHost {
     get hostname(): string;
     get port(): string;
     get origin(): string;
+    get streamSize(): number;
 }
 
 export interface HttpHostConstructor {
     normalizeOrigin(value: string): string;
     formatBasicAuth(url: URL): string;
-    getBasicAuth(url: URL): Undef<OutgoingHttpHeaders>;
-    defineLocalHost(value: string[]): void;
-    defineProtocolNegotiation(value: ObjectMap<string[]>): void;
+    getBasicAuth(url: URL): OutgoingHttpHeaders | undefined;
+    defineLocalHost(values: string[]): void;
+    defineProtocolNegotiation(data: ObjectMap<string[]>): void;
+    defineHostConfig(settings: HttpHostSettings): void;
     readonly prototype: IHttpHost;
     new(url: URL, httpVersion?: HttpProtocolVersion): IHttpHost;
 }
 
+export interface IHttpAdapter<T extends OpenOptions = OpenOptions> {
+    instance: IRequest;
+    state: ControllerState;
+    uri: string | URL;
+    contentLength: number;
+    retries: number;
+    redirects: number;
+    closed: boolean;
+    aborted: boolean;
+    timeout: NodeJS.Timeout | null;
+    dataTime: bigint | null;
+    delayTime: number | bigint | undefined;
+    opts: HostConfig & T;
+    client: HttpRequestClient;
+    resolve: (value: unknown) => void;
+    reject: (reason?: any) => void;
+    readonly startTime: bigint;
+    start(): Promise<object | Bufferable | null>;
+    init(): void;
+    setOpts(uri?: string | URL): void;
+    setWriteStream(): void;
+    retryDownload(downgrade: boolean, message: string): void;
+    acceptResponse(headers: IncomingHttpHeaders): void;
+    updateProgress(dataLength: number, contentLength: number): void;
+    redirectResponse(statusCode: number, location?: string): void;
+    endResponse(result: unknown, dataLength: number, logging?: boolean): void;
+    abortResponse(): void;
+    errorResponse(err: unknown): void;
+    retryResponse(statusCode: number, retryAfter?: string): void;
+    isRetry(value: number): boolean;
+    retryTimeout(): void;
+    terminate(err: unknown): void;
+    sendWarning(message: string): void;
+    formatStatus(value: number | string, hint?: string): string;
+    close(retry?: boolean): void;
+    cleanup(): void;
+    set abortController(value);
+    get abortController(): AbortController | null;
+    set outStream(value);
+    get outStream(): Writable | null;
+    get destroyed(): boolean;
+    get host(): IHttpHost;
+    get httpVersion(): HttpProtocolVersion;
+    get pipeTo(): string | Writable | undefined;
+    get silent(): boolean;
+    get retryLimit(): number;
+    get retryWait(): number;
+    get retryAfter(): number;
+    get redirectLimit(): number;
+}
+
+export interface HttpAdapterConstructor<T extends OpenOptions = OpenOptions> {
+    isUnsupported(value: number): boolean;
+    isDowngrade(err: unknown): boolean;
+    wasAborted(err: unknown): boolean;
+    isConnectionError(err: unknown): boolean;
+    defineHostConfig(settings: RequestModule): void;
+    readonly prototype: IHttpAdapter<T>;
+    new(instance: IRequest, state: ControllerState, uri: string | URL, options: T): IHttpAdapter<T>;
+}
+
 export interface OpenOptions extends KeepAliveAction, SilentAction {
     host?: IHttpHost;
     url?: URL;
+    base?: boolean;
     socketPath?: string;
     httpVersion?: HttpProtocolVersion;
     method?: HttpMethod | Lowercase<HttpMethod>;
     search?: StringMap;
-    /** @deprecated followRedirect */
-    follow_redirect?: boolean;
     followRedirect?: boolean;
+    expectContinue?: boolean;
+    expectTimeout?: number;
     encoding?: BufferEncoding;
-    maxBufferSize?: NumString;
+    maxBufferSize?: number | string;
     format?: BufferFormat | { out?: BufferFormat; parser?: PlainObject };
     headers?: OutgoingHttpHeaders | Headers;
     signal?: AbortSignal;
     timeout?: number;
     pipeTo?: string | Writable;
     postData?: unknown;
-    connected?: (headers: IncomingHttpHeaders) => Void<boolean>;
+    connected?: ((headers: IncomingHttpHeaders) => boolean | void);
     statusMessage?: string;
-    progressId?: NumString;
+    progressId?: number | string;
     outFormat?: { out: BufferFormat; parser?: PlainObject };
-    outFilename?: Null<string>;
-    outHeaders?: Null<IncomingHttpHeaders>;
-    outStream?: Writable;
-    outAbort?: AbortController;
+    outFilename?: string | null;
+    outHeaders?: IncomingHttpHeaders | null;
+    outStream?: Writable | null;
+    outAbort?: AbortController | null;
 }
 
 export interface PutOptions extends OpenOptions {
@@ -85,7 +152,7 @@ export interface PutOptions extends OpenOptions {
 }
 
 export interface PostOptions extends PutOptions {
-    formData?: ArrayOf<FormDataPart>;
+    formData?: FormDataPart | FormDataPart[];
 }
 
 export interface FormDataPart {
@@ -107,10 +174,8 @@ export interface HostConfig extends OpenOptions {
     url: URL;
 }
 
-export interface ProxySettings extends KeepAliveAction {
+export interface ProxySettings extends KeepAliveAction, IncludeAction {
     host: URL;
-    exclude?: string[];
-    include?: string[];
 }
 
 export interface RequestInit extends ProtocolAction {
@@ -134,10 +199,17 @@ export interface ApplyOptions extends ProtocolAction, PlainObject {
     keepAlive?: boolean;
 }
 
+export interface ControllerState {
+    readonly verbose: boolean;
+    readonly log: boolean;
+    readonly singleton: boolean;
+    readonly config: Required<ClientConfig>;
+}
+
 export type HttpMethod = "GET" | "POST" | "PUT" | "HEAD" | "DELETE";
 export type BufferFormat = "json" | "yaml" | "json5" | "xml" | "toml";
 export type ReadExpectType = "always" | "string" | "none";
-export type DataEncodedResult<T extends { encoding?: BufferEncoding }> = T extends { encoding: BufferEncoding } ? string : Null<Bufferable>;
-export type DataObjectResult<T extends { format?: unknown; encoding?: BufferEncoding }> = T extends { format: string | PlainObject } ? Null<object> : DataEncodedResult<T>;
-export type StatusOnCallback = (code: number, headers: IncomingHttpHeaders, url?: URL) => Void<boolean>;
-export type HeadersOnCallback = (headers: IncomingHttpHeaders, url?: URL) => Void<boolean>;
+export type DataEncodedResult<T extends { encoding?: BufferEncoding }> = T extends { encoding: BufferEncoding } ? string : Bufferable | null;
+export type DataObjectResult<T extends { format?: unknown; encoding?: BufferEncoding }> = T extends { format: string | PlainObject } ? object | null : DataEncodedResult<T>;
+export type StatusOnCallback = (code: number, headers: IncomingHttpHeaders, url?: URL) => boolean | void;
+export type HeadersOnCallback = (headers: IncomingHttpHeaders, url?: URL) => boolean | void;