@e-mc/types 0.9.4 → 0.9.6

package/README.md

@@ -9,7 +9,7 @@
 
 ## Interface
 
-* [View Source](https://www.unpkg.com/@e-mc/types@0.9.4/index.d.ts)
+* [View Source](https://www.unpkg.com/@e-mc/types@0.9.6/index.d.ts)
 
 ```typescript
 import type { LogArguments } from "./lib/logger";
@@ -194,8 +194,8 @@ const IMPORT_MAP: Record<string, string | undefined>;
 
 ## References
 
-- https://www.unpkg.com/@e-mc/types@0.9.4/lib/logger.d.ts
-- https://www.unpkg.com/@e-mc/types@0.9.4/lib/module.d.ts
+- https://www.unpkg.com/@e-mc/types@0.9.6/lib/logger.d.ts
+- https://www.unpkg.com/@e-mc/types@0.9.6/lib/module.d.ts
 
 * https://nodejs.org/api/perf_hooks.html
 * https://www.npmjs.com/package/@types/bytes

package/constant.d.ts

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

package/index.d.ts

@@ -311,7 +311,7 @@ declare namespace types {
     function getEncoding(value: unknown, fallback?: BufferEncoding): BufferEncoding;
     function encryptUTF8(algorithm: CipherGCMTypes, key: BinaryLike, iv: BinaryLike, data: string, encoding?: Encoding): Undef<string>;
     function decryptUTF8(algorithm: CipherGCMTypes, key: BinaryLike, iv: BinaryLike, data: string, encoding?: Encoding): Undef<string>;
-    /* @deprecated - crypto.randomUUID */
+    /** @deprecated crypto.randomUUID */
     function generateUUID(): string;
     function incrementUUID(restart?: boolean): string;
     function validateUUID(value: unknown): boolean;

package/index.js

@@ -145,6 +145,63 @@ function recurseObject(data, parseString, completed, cache) {
     }
     return data;
 }
+function mergedArray(target, attr, data, type) {
+    const prop = target[attr];
+    if (type && Array.isArray(prop) && Array.isArray(data)) {
+        let arg1, arg2;
+        if (Array.isArray(type)) {
+            [type, arg1, arg2] = type;
+        }
+        switch (type) {
+            case 'concat':
+                target[attr] = prop.concat(data);
+                break;
+            case 'concat-pre':
+                target[attr] = data.concat(prop);
+                break;
+            case 'push':
+            case 'unshift':
+            case 'includes':
+                for (let i = 0, length = data.length; i < length; ++i) {
+                    if (type !== 'includes' || !prop.includes(data[i])) {
+                        prop[type](data[i]);
+                    }
+                }
+                break;
+            case 'flat':
+                target[attr] = data.flat(arg1);
+            case 'join':
+                target[attr] = data.join(arg1);
+                break;
+            case 'slice':
+                target[attr] = data.slice(arg1, arg2);
+                break;
+            case 'reverse':
+                target[attr] = data.slice(0).reverse();
+                break;
+            default:
+                return false;
+        }
+        return true;
+    }
+    return false;
+}
+function getProperties(obj, inherited, nonenumerable, symbol) {
+    let attrs;
+    if (inherited === false) {
+        attrs = nonenumerable ? Object.getOwnPropertyNames(obj) : Object.keys(obj);
+    }
+    else {
+        attrs = [];
+        for (const attr in obj) {
+            attrs.push(attr);
+        }
+        if (nonenumerable) {
+            attrs = Array.from(new Set(attrs.concat(Object.getOwnPropertyNames(obj))));
+        }
+    }
+    return symbol ? attrs.concat(Object.getOwnPropertySymbols(obj)) : attrs;
+}
 const convertScrypt = (key, iv, data) => crypto.scryptSync(key, iv, Math.ceil(data.length / 16) * 16);
 const isFunction = (value) => typeof value === 'function';
 var LOG_TYPE;
@@ -653,7 +710,7 @@ function cascadeObject(data, query, fallback) {
 }
 exports.cascadeObject = cascadeObject;
 function cloneObject(data, options) {
-    let target, deep, deepIgnore, typedArray, inherited, nonenumerable, symbol, preserve;
+    let target, deep, deepIgnore, mergeArray, mergeDepth = Infinity, typedArray, inherited, nonenumerable, symbol, preserve;
     if (options === true) {
         deep = true;
     }
@@ -662,23 +719,30 @@ function cloneObject(data, options) {
         deepIgnore = options;
     }
     else if (options) {
-        ({ target, deep, deepIgnore, typedArray, inherited, nonenumerable, symbol, preserve } = options);
+        ({ target, deep, deepIgnore, mergeArray, typedArray, inherited, nonenumerable, symbol, preserve } = options);
+        if (options.mergeDepth !== undefined) {
+            mergeDepth = options.mergeDepth - 1;
+        }
     }
     let nested;
     if (deep) {
         deepIgnore || (deepIgnore = new WeakSet());
-        nested = { deep, deepIgnore, typedArray, preserve };
+        nested = { deep, deepIgnore, mergeArray, mergeDepth, typedArray, preserve };
     }
     if (Array.isArray(data)) {
-        if (deepIgnore) {
-            deepIgnore.add(data);
-        }
+        deepIgnore?.add(data);
         const length = data.length;
-        if (!target || !Array.isArray(target)) {
-            target = new Array(length);
+        if (Array.isArray(target)) {
+            if (mergeArray && mergeDepth >= 0 && !(mergeArray === 'join' || Array.isArray(mergeArray) && mergeArray[0] === 'join')) {
+                const out = { target };
+                if (mergedArray(out, 'target', data, mergeArray)) {
+                    return out.target;
+                }
+            }
+            target.length = 0;
         }
         else {
-            target.length = 0;
+            target = new Array(length);
         }
         for (let i = 0; i < length; ++i) {
             const value = data[i];
@@ -691,29 +755,11 @@ function cloneObject(data, options) {
         }
     }
     else if (isObject(data)) {
-        if (deepIgnore) {
-            deepIgnore.add(data);
-        }
-        if (!target || !isObject(target)) {
+        deepIgnore?.add(data);
+        if (!isObject(target)) {
             target = {};
         }
-        const getProperties = (obj) => {
-            let attrs;
-            if (inherited === false) {
-                attrs = nonenumerable ? Object.getOwnPropertyNames(obj) : Object.keys(obj);
-            }
-            else {
-                attrs = [];
-                for (const attr in obj) {
-                    attrs.push(attr);
-                }
-                if (nonenumerable) {
-                    attrs = Array.from(new Set(attrs.concat(Object.getOwnPropertyNames(obj))));
-                }
-            }
-            return symbol ? attrs.concat(Object.getOwnPropertySymbols(obj)) : attrs;
-        };
-        for (const attr of getProperties(data)) {
+        for (const attr of getProperties(data, inherited, nonenumerable, symbol)) {
             const value = data[attr];
             let merge;
             if (deepIgnore) {
@@ -722,23 +768,24 @@ function cloneObject(data, options) {
             else {
                 merge = Array.isArray(value) ? value.slice(0) : value;
             }
-            if (preserve && isPlainObject(target[attr]) && isPlainObject(merge)) {
+            const prop = target[attr];
+            if (preserve && isPlainObject(prop) && isPlainObject(merge)) {
                 (function recurse(current, next) {
-                    for (const item of getProperties(next)) {
+                    for (const item of getProperties(next, inherited, nonenumerable, symbol)) {
                         const b = next[item];
-                        if (!(item in current)) {
-                            current[item] = b;
-                        }
-                        else {
+                        if (item in current) {
                             const a = current[item];
                             if (isPlainObject(a) && isPlainObject(b)) {
                                 recurse(a, b);
                             }
                         }
+                        else if (!(mergeArray && mergeDepth >= 0 && mergedArray(current, item, b, mergeArray))) {
+                            current[item] = b;
+                        }
                     }
-                })(target[attr], merge);
+                })(prop, merge);
             }
-            else {
+            else if (!(mergeArray && mergeDepth >= 0 && mergedArray(target, attr, merge, mergeArray))) {
                 target[attr] = merge;
             }
         }

package/lib/compress.d.ts

@@ -2,7 +2,10 @@ import type { CompressFormat as ICompressFormat } from './squared';
 
 import type { LogBaseOptions, LogTime } from './logger';
 
-interface CompressFormat extends ICompressFormat, LogBaseOptions {
+type ResultCallback<T = Null<Buffer | Uint8Array>> = (err: unknown, data?: T, ext?: string) => void;
+type ResultData = Null<Buffer | Uint8Array> | string;
+
+export interface CompressFormat extends ICompressFormat, LogBaseOptions {
     filename?: string;
     startTime?: LogTime;
     etag?: string;
@@ -11,14 +14,11 @@ interface CompressFormat extends ICompressFormat, LogBaseOptions {
     outFile?: string;
 }
 
-interface Woff {
+export interface Woff {
     toWoff(this: void, data: BufferLike): Buffer;
     toSfnt(this: void, data: BufferLike): Buffer;
 }
 
-type ResultCallback<T = Null<Buffer | Uint8Array>> = (err: unknown, data?: T, ext?: string) => void;
-type ResultData = Null<Buffer | Uint8Array> | string;
-
 export type BufferLike = Buffer | Uint8Array | ArrayBuffer | SharedArrayBuffer | readonly number[];
 export type TryFileCompressor = (data: string | Buffer, output: string, config: CompressFormat, callback?: ResultCallback<ResultData>) => Void<Promise<ResultData>>;
 export type TryFileCompressorAsync = (data: string | Buffer, output: string, config: CompressFormat) => Promise<ResultData>;

package/lib/index.d.ts

@@ -106,7 +106,7 @@ declare namespace functions {
 
     interface ImageConstructor<T extends IHost = IHost, U extends ImageModule = ImageModule> extends ModuleConstructor {
         readonly REGEXP_SIZERANGE: RegExp;
-        transform<V extends TransformOptions>(file: string, command: string, options?: V): Promise<U extends { tempFile: true } ? string : Null<Buffer>>;
+        transform<V extends TransformOptions>(file: string, command: string, options?: V): Promise<V extends { tempFile: true } ? string : Null<Buffer>>;
         clamp(value: unknown, min?: number, max?: number): number;
         isBinary(mime: unknown): mime is string;
         toABGR(buffer: Uint8Array | Buffer): Buffer;
@@ -255,9 +255,9 @@ 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 */
+        /** @deprecated */
         createSourceMap(code: string, remove: boolean): SourceMap;
-        /* @deprecated */
+        /** @deprecated */
         createSourceMap(code: string, uri?: string, remove?: boolean): SourceMap;
         writeSourceMap(uri: string, data: SourceCode, options?: SourceMapOptions): Undef<string>;
         updateGradle(source: string, namespaces: string[], value: string, upgrade: boolean): string;
@@ -579,7 +579,7 @@ declare namespace functions {
     interface IModule<T extends IHost = IHost> extends EventEmitter, IAbortComponent {
         readonly status: LogStatus<StatusType>[];
         readonly errors: unknown[];
-        /* @deprecated */
+        /** @deprecated */
         supported(major: number, minor?: number, patch?: number, lts?: boolean): boolean;
         supports(name: string, value?: boolean): boolean;
         getTempDir(options: GetTempDirOptions): string;

package/lib/module.d.ts

@@ -71,6 +71,8 @@ export interface CloneObjectOptions<T = unknown> {
     deep?: boolean;
     deepIgnore?: WeakSet<object>;
     typedArray?: boolean;
+    mergeArray?: MergeArrayMethod;
+    mergeDepth?: number;
     symbol?: boolean;
     inherited?: boolean;
     nonenumerable?: boolean;
@@ -138,4 +140,5 @@ export interface IncludeAction<T = string[]> {
 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 ProtocolType = "http" | "https" | "http/s" | "ftp" | "sftp" | "s/ftp" | "torrent" | "unc";
+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?];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@e-mc/types",
-  "version": "0.9.4",
+  "version": "0.9.6",
   "description": "Type definitions for E-mc.",
   "main": "index.js",
   "types": "index.d.ts",