@e-mc/types 0.0.1

package/lib/logger.d.ts

@@ -0,0 +1,124 @@
+import type { LogStatus } from './squared';
+
+import type { LOG_TYPE, STATUS_TYPE } from '../index.d';
+
+// @ts-ignore
+import type { BackgroundColor as IBackgroundColor, ForegroundColor as IForegroundColor } from 'chalk';
+
+type HexColor = `#${string}`;
+
+export interface LogBaseOptions extends LoggerColor, Pick<LogOptions, "queue" | "timeStamp"> {
+    type?: LogType;
+    statusType?: StatusType;
+    sessionId?: string;
+    abortable?: boolean;
+    titleJustify?: TextAlign;
+    broadcastId?: BroadcastValue;
+    newline?: boolean | number;
+}
+
+export interface LoggerColor {
+    titleColor?: ForegroundColor;
+    titleBgColor?: BackgroundColor;
+    titleBold?: boolean;
+    valueColor?: ForegroundColor;
+    valueBgColor?: BackgroundColor;
+    valueBold?: boolean;
+    hintColor?: ForegroundColor;
+    hintBgColor?: BackgroundColor;
+    hintBold?: boolean;
+    messageColor?: ForegroundColor;
+    messageBgColor?: BackgroundColor;
+    messageBold?: boolean;
+}
+
+export interface LoggerFormat<T = NumString> {
+    width?: T;
+    color?: ForegroundColor;
+    bg_color?: BackgroundColor;
+    bg_alt_color?: BackgroundColor;
+    bold?: boolean;
+    justify?: TextAlign;
+    unit?: string;
+}
+
+export interface LoggerStatus<T = boolean> {
+    fatal?: T;
+    error?: T;
+    warn?: T;
+    info?: T;
+    debug?: T;
+    trace?: T;
+}
+
+export interface LogOptions extends Partial<Pick<LogStatus<StatusType>, "duration" | "from" | "source">> {
+    queue?: boolean;
+    timeStamp?: LogDate;
+}
+
+export interface LogMessageOptions extends LogBaseOptions {
+    failed?: boolean;
+    useColor?: boolean;
+    messageWidth?: number;
+    messageUnit?: string;
+    messageUnitMinWidth?: number;
+    messageUnitIndent?: number | [number, string];
+    progressBar?: boolean;
+    alwaysVisible?: boolean;
+    titleIndent?: boolean | number;
+}
+
+export interface LogFailOptions extends LogBaseOptions {
+    exec?: ExecCommand;
+    code?: string;
+    fatal?: boolean;
+    passThrough?: boolean;
+    startTime?: LogTime;
+}
+
+export interface LogProcessOptions extends LogMessageOptions {
+    bypassLog?: boolean;
+    meterIncrement?: number;
+    delayTime?: number | HighResolutionTime;
+}
+
+export interface LogTimeElapsedOptions extends LogMessageOptions {
+    showCpu?: boolean;
+}
+
+export interface LogTypeValue {
+    type: LogType;
+    value: LogValue;
+    timeStamp: number;
+    sessionId?: string;
+}
+
+export interface LogArguments {
+    type?: LogType;
+    value?: LogValue;
+    title?: string;
+    message?: unknown;
+}
+
+export interface ExecCommand {
+    command: string;
+    args?: string[];
+    warn?: string[];
+}
+
+export type { LOG_TYPE, STATUS_TYPE };
+export type LogType = LOG_TYPE[keyof LOG_TYPE];
+export type StatusType = STATUS_TYPE[keyof STATUS_TYPE];
+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 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 ErrorOutMethod = (err: Error, data: LogTypeValue, require?: NodeRequire) => void;
+export type BroadcastOutMethod = (value: string, options: LogMessageOptions, require?: NodeRequire) => void;
+export type BroadcastValue = StringOfArray | { value: StringOfArray; stripAnsi?: boolean };
+export type ModuleWriteFailMethod = (value: LogValue, message?: unknown, options?: LogFailOptions | LogType) => void;
+export type ModuleFormatMessageMethod = (type: LogType, title: string, value: LogValue, message?: unknown, options?: LogMessageOptions) => void;

package/lib/module.d.ts

@@ -0,0 +1,115 @@
+import type { BinaryToTextEncoding, HashOptions } from 'crypto';
+
+declare enum NORMALIZE_FLAGS {
+    NONE = 0,
+    RESOLVE = 1,
+    ENSURE_DIR = 2,
+    POSIX = 4
+}
+
+export interface RequireAction {
+    requireExt?: StringOfArray | boolean;
+}
+
+export interface PermissionOptions {
+    ownPermissionOnly?: boolean;
+    hostPermissionOnly?: boolean;
+}
+
+export interface FileSystemOptions extends PermissionOptions {
+    absolutePath?: boolean;
+    ignorePermission?: boolean;
+    throwsPermission?: boolean;
+    throwsDoesNotExist?: boolean;
+}
+
+export interface ReadFileOptions extends FileSystemOptions, RequireAction {
+    cache?: boolean;
+    encoding?: BufferEncoding;
+}
+
+export interface WriteFileOptions extends FileSystemOptions {
+    overwrite?: boolean;
+    encoding?: BufferEncoding;
+}
+
+export interface DeleteFileOptions extends FileSystemOptions {
+    emptyDir?: boolean;
+}
+
+export interface CopyFileOptions extends FileSystemOptions {
+    overwrite?: boolean;
+    createDir?: boolean;
+    outSrc?: string;
+}
+
+export interface RemoveDirOptions extends FileSystemOptions {
+    emptyDir?: boolean;
+    recursive?: boolean;
+}
+
+export type MoveFileOptions = CopyFileOptions;
+export type CreateDirOptions = FileSystemOptions;
+
+export interface GetFunctionsOptions extends ParseFunctionOptions {
+    outFailed?: string[];
+}
+
+export interface ParseFunctionOptions extends RequireAction {
+    absolute?: boolean;
+    sync?: boolean;
+    external?: boolean;
+    context?: unknown;
+}
+
+export interface CloneObjectOptions<T = unknown> {
+    target?: T;
+    deep?: boolean;
+    deepIgnore?: WeakSet<object>;
+    typedArray?: boolean;
+    symbol?: boolean;
+    inherited?: boolean;
+    nonenumerable?: boolean;
+    preserve?: boolean;
+}
+
+export interface CheckSemVerOptions extends MinMax {
+    startDir?: string;
+    unstable: boolean;
+}
+
+export interface CopyDirOptions {
+    move?: boolean;
+    recursive?: boolean | number;
+    symFile?: boolean;
+    symDir?: boolean;
+    ignoreFile?: RegExp;
+    ignoreDir?: RegExp;
+    silent?: boolean;
+    overwrite?: boolean;
+}
+
+export interface CopyDirResult {
+    success: string[];
+    failed: string[];
+    ignored: string[];
+}
+
+export interface AsHashOptions extends HashOptions {
+    algorithm?: string;
+    digest?: BinaryToTextEncoding;
+    minLength?: number;
+}
+
+export interface GetTempDirOptions {
+    pathname?: string;
+    filename?: string;
+    moduleDir?: boolean;
+    uuidDir?: boolean;
+    createDir?: boolean;
+    increment?: number;
+}
+
+export type NormalizeFlags = typeof NORMALIZE_FLAGS[keyof typeof NORMALIZE_FLAGS];
+export type ReadFileCallback<T> = (err: Null<NodeJS.ErrnoException>, data?: T) => void;
+export type ProtocolType = "http" | "https" | "http/s" | "ftp" | "sftp" | "s/ftp" | "torrent" | "unc";

package/lib/node.d.ts

@@ -0,0 +1,24 @@
+import type { RequestData as IRequestData } from './squared';
+
+import type { ExternalAsset } from './asset';
+import type { HostInitConfig } from './core';
+import type { DownloadModule, ErrorModule, LoggerModule, MemoryModule, NodeModule, PermissionModule, ProcessModule, RequestModule, TempModule } from './settings';
+
+type BoolString = boolean | string;
+
+export interface RequestData<T extends ExternalAsset = ExternalAsset> extends Readonly<Omit<IRequestData, "log">>, Readonly<HostInitConfig> {
+    readonly assets?: T[];
+}
+
+export interface Settings {
+    temp_dir?: string;
+    temp?: TempModule;
+    node?: NodeModule;
+    process?: ProcessModule;
+    permission?: PermissionModule;
+    memory?: MemoryModule;
+    download?: DownloadModule;
+    request?: RequestModule;
+    error?: ErrorModule;
+    logger?: LoggerModule;
+}

package/lib/object.d.ts

@@ -0,0 +1,30 @@
+interface Point {
+    x: number;
+    y: number;
+}
+
+interface Dimension {
+    width: number;
+    height: number;
+}
+
+interface KeyValue<T, U> {
+    key: T;
+    value: U;
+}
+
+interface ErrorCode extends Error {
+    code?: unknown;
+}
+
+interface AuthValue {
+    username?: string;
+    password?: string;
+}
+
+interface MinMax<T = number> {
+    min?: T;
+    max?: T;
+}
+
+type HighResolutionTime = TupleOf<number>;

package/lib/request.d.ts

@@ -0,0 +1,130 @@
+import type { BinaryAction } from './asset';
+import type { HttpProtocolVersion, InternetProtocolVersion } from './http';
+
+import type { Readable, Writable } from 'stream';
+import type { IncomingHttpHeaders, OutgoingHttpHeaders } from 'http';
+
+interface KeepAliveAction {
+    keepAlive?: boolean;
+    agentTimeout?: number;
+}
+
+interface SilentAction {
+    silent?: boolean;
+}
+
+interface ProtocolAction {
+    httpVersion?: HttpProtocolVersion;
+    ipVersion?: InternetProtocolVersion;
+}
+
+export interface IHttpHost {
+    localhost: boolean;
+    hasProtocol(version: HttpProtocolVersion): Promise<number>;
+    upgrade(version: HttpProtocolVersion, altSvc: Undef<string>): void;
+    success(version: HttpProtocolVersion, status?: boolean): number;
+    failed(version: HttpProtocolVersion, status?: boolean): number;
+    error(version: HttpProtocolVersion, status?: boolean): number;
+    didAltSvc(version: HttpProtocolVersion): boolean;
+    nextAltSvc(): boolean;
+    closeAltSvc(error?: boolean): boolean;
+    clearAltSvc(version?: HttpProtocolVersion): void;
+    flagAltSvc(version: HttpProtocolVersion, value: number): void;
+    reset(): void;
+    v2(): boolean;
+    set version(value);
+    get version(): HttpProtocolVersion;
+    get protocol(): string;
+    get secure(): boolean;
+    get hostname(): string;
+    get port(): string;
+    get origin(): string;
+}
+
+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;
+    readonly prototype: IHttpHost;
+    new(url: URL, httpVersion?: HttpProtocolVersion): IHttpHost;
+}
+
+export interface OpenOptions extends KeepAliveAction, SilentAction {
+    host?: IHttpHost;
+    url?: URL;
+    socketPath?: string;
+    httpVersion?: HttpProtocolVersion;
+    method?: "GET" | "POST" | "HEAD";
+    encoding?: BufferEncoding;
+    format?: BufferFormat | { out?: BufferFormat; parser?: PlainObject };
+    headers?: OutgoingHttpHeaders;
+    timeout?: number;
+    pipeTo?: string | Writable;
+    postData?: unknown;
+    connected?: (headers: IncomingHttpHeaders) => Void<boolean>;
+    statusMessage?: string;
+    silent?: boolean;
+    outFormat?: { out: BufferFormat; parser?: PlainObject };
+    outFilename?: Null<string>;
+    outHeaders?: Null<IncomingHttpHeaders>;
+    outStream?: Writable;
+    outAbort?: AbortController;
+}
+
+export interface PostOptions extends OpenOptions {
+    contentType?: string;
+    formData?: ArrayOf<FormDataPart>;
+    dataEncoding?: BufferEncoding;
+}
+
+export interface FormDataPart {
+    name?: string;
+    data?: Buffer | Readable | string;
+    value?: unknown;
+    contentType?: string;
+    filename?: string;
+}
+
+export interface Aria2Options extends BinaryAction, SilentAction {
+    pathname?: string;
+    headers?: OutgoingHttpHeaders;
+}
+
+export interface HostConfig extends OpenOptions {
+    host: IHttpHost;
+    url: URL;
+}
+
+export interface ProxySettings extends KeepAliveAction {
+    host: URL;
+    exclude?: string[];
+    include?: string[];
+}
+
+export interface RequestInit extends ProtocolAction {
+    headers?: unknown;
+    requestTimeout?: number;
+}
+
+export interface ClientConfig {
+    timeout?: number;
+    connectTimeout?: number;
+    redirectLimit?: number;
+    retryWait?: number;
+    retryAfter?: number;
+    retryLimit?: number;
+}
+
+export interface ApplyOptions extends ProtocolAction, PlainObject {
+    client?: ClientConfig;
+    readExpect?: ReadExpectType;
+    acceptEncoding?: boolean;
+    keepAlive?: boolean;
+}
+
+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<BufferContent>;
+export type DataObjectResult<T extends { format?: unknown; encoding?: BufferEncoding }> = T extends { format: string | PlainObject } ? Null<object> : DataEncodedResult<T>;