@e-mc/types 0.11.2 → 0.11.4

package/README.md

@@ -9,7 +9,7 @@
 
 ## Interface
 
-* [View Source](https://www.unpkg.com/@e-mc/types@0.11.2/index.d.ts)
+* [View Source](https://www.unpkg.com/@e-mc/types@0.11.4/index.d.ts)
 
 ```typescript
 import type { LogArguments } from "./lib/logger";
@@ -198,10 +198,10 @@ const IMPORT_MAP: Record<string, string | undefined>;
 
 ## References
 
-- https://www.unpkg.com/@e-mc/types@0.11.2/index.d.ts
-- https://www.unpkg.com/@e-mc/types@0.11.2/lib/logger.d.ts
-- https://www.unpkg.com/@e-mc/types@0.11.2/lib/module.d.ts
-- https://www.unpkg.com/@e-mc/types@0.11.2/lib/node.d.ts
+- https://www.unpkg.com/@e-mc/types@0.11.4/index.d.ts
+- https://www.unpkg.com/@e-mc/types@0.11.4/lib/logger.d.ts
+- https://www.unpkg.com/@e-mc/types@0.11.4/lib/module.d.ts
+- https://www.unpkg.com/@e-mc/types@0.11.4/lib/node.d.ts
 
 * https://developer.mozilla.org/en-US/docs/Web/API/DOMException
 * https://www.npmjs.com/package/@types/bytes

package/constant.d.ts

@@ -1,5 +1,5 @@
 export const enum INTERNAL {
-    VERSION = '0.11.2',
+    VERSION = '0.11.4',
     TEMP_DIR = 'tmp',
     CJS = '__cjs__'
 }

package/index.js

@@ -284,10 +284,10 @@ function parseStringDefault(value) {
             const match = REGEXP_NATIVE.exec(value.trimEnd());
             if (match) {
                 try {
-                    const text = match[2].trim();
+                    let text = match[2].trim();
                     switch (match[1]) {
                         case 'Date':
-                            return new Date(trimQuote(text));
+                            return (text = trimQuote(text)) ? new Date(text) : new Date();
                         case 'URL':
                         case 'RegExp': {
                             const pattern = /^("[^"]+"|'[^']+'|[^\s,]+)(?:\s*,\s*("[^"]+"|'[^']+'|\S+))?$/.exec(text);
@@ -792,7 +792,7 @@ function alignSize(value, kb = 0, factor = 0) {
     }
     if (kb > 0) {
         kb = Math.ceil(kb) * 1024;
-        return Math.ceil(result / kb) * kb;
+        return Math.ceil(Math.max(result, 1) / kb) * kb;
     }
     return result;
 }
@@ -1088,7 +1088,7 @@ async function importESM(name, isDefault, fromPath) {
     if (fromPath && path.isAbsolute(name)) {
         name = (0, node_url_1.pathToFileURL)(name).toString();
     }
-    const result = import(name);
+    const result = Function(`return import("${name}")`)();
     if (isDefault) {
         const out = await result;
         if (isObject(out) && 'default' in out) {

package/lib/compat-v4.d.ts

@@ -0,0 +1,121 @@
+import type { CloudConstructor, FileManagerConstructor, ICloud, IFileManager, IHost, IModule, ModuleConstructor, WatchConstructor } from './index';
+
+import type { CloneObjectOptions } from '../index.d';
+import type { ExternalAsset } from './asset';
+import type { CacheOptions } from './core';
+import type { QueryResult } from './db';
+import type { ITransformSeries, OutV3, TransformSeriesConstructor } from './document';
+import type { IHttpMemoryCache } from './filemanager';
+import type { HttpAgentSettings, HttpProtocolVersion, HttpRequestClient, InternetProtocolVersion } from './http';
+import type { ParseFunctionOptions } from './module';
+import type { LogFailOptions, LogType, LogValue } from './logger';
+import type { HostConfig, OpenOptions, ProxySettings } from './request';
+import type { DbCoerceSettings, DnsLookupSettings, HttpMemorySettings, HttpSettings } from './settings';
+
+import type { OutgoingHttpHeaders } from 'http';
+import type { LookupFunction } from 'net';
+import type { Readable, Writable } from 'stream';
+
+type CpuUsage = NodeJS.CpuUsage;
+
+export interface GetFunctionsOptions extends ParseFunctionOptions {
+    outFailed?: string[];
+}
+
+export interface IModuleLibV4 {
+    isString(value: unknown): value is string;
+    isObject<T = object>(value: unknown): value is T;
+    isPlainObject<T = PlainObject>(value: unknown): value is T;
+    escapePattern(value: unknown, lookBehind?: boolean): string;
+    generateUUID(format?: string, dictionary?: string): string;
+    validateUUID(value: unknown): boolean;
+    cloneObject<T, U = unknown>(data: T, options?: boolean | WeakSet<object> | CloneObjectOptions<U>): T;
+    coerceObject<T = unknown>(data: T, parseString?: FunctionType<unknown, string> | boolean, cache?: boolean): T;
+    asFunction<T = unknown, U = FunctionType<Promise<T> | T>>(value: unknown, sync?: boolean): Null<U>;
+    isFileHTTP(value: string | URL): boolean;
+    isFileUNC(value: string | URL): boolean;
+    isPathUNC(value: string | URL): boolean;
+    toTimeMs(hrtime: HighResolutionTime, format?: boolean): number | string;
+    renameExt(value: string, ext: string, when?: string): string;
+    existsSafe(value: string, isFile?: boolean): boolean;
+    readFileSafe(value: string, encoding: BufferEncoding | "buffer", cache?: boolean): Null<Bufferable>;
+    getFunctions<T extends FunctionType>(values: unknown[], absolute?: boolean | GetFunctionsOptions, sync?: boolean, outFailed?: string[]): T[];
+    formatSize(value: number | string, options?: PlainObject): number | string;
+    hasSameStat(src: string, dest: string, keepEmpty?: boolean): boolean;
+    hasSize(value: string, keepEmpty?: boolean): boolean;
+    getSize(value: string, diskUsed?: boolean): number;
+    byteLength(value: Bufferable, encoding?: BufferEncoding): number;
+    cleanupStream(target: Readable | Writable, pathname?: string): void;
+    allSettled<U>(values: readonly (U | PromiseLike<U>)[], rejected?: LogValue, options?: LogFailOptions | LogType): Promise<PromiseSettledResult<U>[]>;
+}
+
+export interface IModuleCompatV4<T extends IHost = IHost> extends IModule<T> {
+    set startCPU(value);
+    get startCPU(): Null<CpuUsage>;
+}
+
+export interface ModuleCompatV4Constructor extends ModuleConstructor, IModuleLibV4 {
+    readonly prototype: IModuleCompatV4;
+    new(...args: unknown[]): IModuleCompatV4;
+}
+
+export interface IFileManagerCompatV4<T extends ExternalAsset = ExternalAsset> extends IFileManager<T> {
+    archiving: boolean;
+    cacheHttpRequest: boolean | FirstOf<string>;
+    cacheHttpRequestBuffer: IHttpMemoryCache<T>;
+    fetchTimeout: number;
+    httpProxy: Null<ProxySettings>;
+    acceptEncoding: boolean;
+    keepAliveTimeout: number;
+    addDns(hostname: string, address: string, family?: number | string): void;
+    lookupDns(hostname: string): LookupFunction;
+    getHttpProxy(uri: string, localhost?: boolean): Null<ProxySettings>;
+    getHttpHeaders(uri: string): Undef<OutgoingHttpHeaders>;
+    createHttpRequest(uri: string | URL, options?: OpenOptions): HostConfig;
+    getHttpClient(uri: string | URL, options: OpenOptions): HttpRequestClient;
+    set httpVersion(value);
+    get httpVersion(): Null<HttpProtocolVersion>;
+    set ipVersion(value);
+    get ipVersion(): InternetProtocolVersion;
+}
+
+export interface FileManagerCompatV4Constructor<T extends ExternalAsset = ExternalAsset> extends FileManagerConstructor<T> {
+    fromHttpStatusCode(value: number | string): string;
+    resetHttpHost(version?: HttpProtocolVersion): void;
+    defineHttpBuffer(options: HttpMemorySettings): void;
+    defineHttpSettings(options: HttpSettings): void;
+    defineHttpAgent(options: HttpAgentSettings): void;
+    defineDnsLookup(options: DnsLookupSettings, clear?: boolean): void;
+    clearDnsLookup(): void;
+    getAria2Path(): string;
+    clearHttpBuffer(percent?: number, limit?: number): void;
+    readonly prototype: IFileManagerCompatV4<T>;
+    new(...args: unknown[]): IFileManagerCompatV4<T>;
+}
+
+export interface ICloudCompatV4<T extends IHost = IHost> extends ICloud<T> {
+    getDatabaseResult(service: string, credential: unknown, queryString: string, options?: CacheOptions | boolean | string): Undef<QueryResult>;
+    setDatabaseResult(service: string, credential: unknown, queryString: string, result: unknown, options?: CacheOptions | string): QueryResult;
+    hasDatabaseCache(service: string, sessionKey?: string): boolean;
+    hasDatabaseCoerce(service: string, component: keyof DbCoerceSettings, credential?: unknown): boolean;
+}
+
+export interface CloudCompatV4Constructor extends CloudConstructor {
+    readonly prototype: ICloudCompatV4;
+    new(...args: unknown[]): ICloudCompatV4;
+}
+
+export interface WatchCompatV4Constructor<T extends IFileManager<U>, U extends ExternalAsset = ExternalAsset> extends WatchConstructor<T, U> {
+    readCACert(value: string, cache?: boolean): string;
+    readTLSKey(value: string, cache?: boolean): string;
+    readTLSCert(value: string, cache?: boolean): string;
+    isCert(value: string): boolean;
+    parseExpires(value: number | string, start?: number): number;
+}
+
+export interface ITransformSeriesCompatV4<T = AnyObject, U = T> extends ITransformSeries<T, U>, PropertyAction<OutV3, "out"> {}
+
+export interface TransformSeriesCompatV4Constructor extends TransformSeriesConstructor {
+    readonly prototype: ITransformSeriesCompatV4;
+    new(...args: unknown[]): ITransformSeriesCompatV4;
+}

package/lib/index.d.ts

@@ -106,6 +106,7 @@ declare namespace functions {
     }
 
     interface ImageConstructor<T extends IHost = IHost, U extends ImageModule = ImageModule> extends ModuleConstructor {
+        /** @deprecated */
         readonly REGEXP_SIZERANGE: RegExp;
         transform<V extends TransformOptions>(file: string, command: string, options?: V): Promise<V extends { tempFile: true } ? string : Buffer | null>;
         clamp(value: unknown, min?: number, max?: number): number;
@@ -265,9 +266,7 @@ declare namespace functions {
 
     interface DocumentConstructor<T extends IFileManager<U>, U extends ExternalAsset = ExternalAsset, V extends ClientModule = DocumentModule, W extends DocumentComponent = DocumentComponent, X extends DocumentComponentOption = DocumentComponentOption, Y extends ICloud = ICloud<T>> extends ModuleConstructor {
         finalize(this: T, instance: IDocument<T, U, V, W, X, Y>): Promise<unknown>;
-        /** @deprecated */
         createSourceMap(code: string, remove: boolean): SourceMap;
-        /** @deprecated */
         createSourceMap(code: string, uri?: string, remove?: boolean): SourceMap;
         writeSourceMap(uri: string, data: SourceCode, options?: SourceMapOptions): string | undefined;
         updateGradle(source: string, namespaces: string[], value: string, upgrade: boolean): string;
@@ -308,7 +307,7 @@ declare namespace functions {
         createServer(port: number, secure?: SecureOptions | null, active?: boolean): ws.Server | null;
         shutdown(): void;
         setTimeout(value: number | string): void;
-        checkTimeout(client: ws): boolean;
+        checkTimeout(client: ws | ws.WebSocket): boolean;
         isConnectionError(err: unknown): boolean;
         readonly prototype: IWatch<T, U, V, W>;
         new(module?: V): IWatch<T, U, V, W>;
@@ -795,13 +794,19 @@ declare namespace functions {
         getMemUsage(format: true): string;
         getMemUsage(format?: boolean): number;
         formatCpuMem(start: CpuUsage, all?: boolean): string;
+        /** @deprecated */
         getPackageVersion(name: string | [string, string], startDir: string, baseDir?: string): string;
+        /** @deprecated */
         getPackageVersion(name: string | [string, string], unstable?: boolean, startDir?: string, baseDir?: string): string;
         checkSemVer(name: string | [string, string], options: CheckSemVerOptions): boolean;
+        /** @deprecated */
         checkSemVer(name: string | [string, string], min: number | string, max?: number | string, unstable?: boolean, startDir?: string): boolean;
         checkSemVer(name: string | [string, string], min: number | string, max: number | string, options?: Omit<CheckSemVerOptions, "min" | "max" | "equals">): boolean;
+        /** @deprecated */
         sanitizeCmd(value: string): string;
+        /** @deprecated */
         sanitizeArgs(value: string, doubleQuote?: boolean): string;
+        /** @deprecated */
         sanitizeArgs(values: string[], doubleQuote?: boolean): string[];
         purgeMemory(percent: number, limit: number, parent?: boolean): Promise<number>;
         purgeMemory(percent?: number, limit?: number | boolean, parent?: unknown): Promise<number>;

package/lib/task.d.ts

@@ -1,10 +1,10 @@
-export interface Command<T = unknown> extends PlainObject {
-    task: string;
-    origDir: string;
-    data: T;
-}
-
-export interface SpawnResult {
-    added?: string[];
-    deleted?: string[];
+export interface Command<T = unknown> extends PlainObject {
+    task: string;
+    origDir: string;
+    data: T;
+}
+
+export interface SpawnResult {
+    added?: string[];
+    deleted?: string[];
 }

package/lib/watch.d.ts

@@ -58,8 +58,8 @@ export interface IFileGroup<T extends ExternalAsset = ExternalAsset> extends IAb
 
 export interface FileGroupConstructor<T extends ExternalAsset = ExternalAsset> {
     CONNECTION_TIMEOUT: number;
-    CLIENT_SESSION: Map<ws, number>;
-    checkTimeout(client: ws): boolean;
+    CLIENT_SESSION: Map<typeof ws, number>;
+    checkTimeout(client: ws | ws.WebSocket): boolean;
     cloneAsset(asset: T): T;
     readonly prototype: IFileGroup<T>;
     new(uri: string, assets: T[], abortable: boolean): IFileGroup<T>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@e-mc/types",
-  "version": "0.11.2",
+  "version": "0.11.4",
   "description": "Type definitions for E-mc.",
   "main": "index.js",
   "types": "index.d.ts",
@@ -24,6 +24,6 @@
     "chalk": "4.1.2"
   },
   "devDependencies": {
-    "typescript": "5.7.2"
+    "typescript": "5.7.3"
   }
 }