@e-mc/compress

* NodeJS 18.20.5 LTS
* ES2022

General Usage

* Read the Docs

Interface

* View Source

``typescript
import type { IModule, ModuleConstructor } from "./index";
import type { BrotliCompressLevel, BufferResult, CompressFormat, CompressLevel, ReadableOptions, TryFileCompressor } from "./compress";
import type { CompressModule, CompressSettings } from "./settings";

import type { WriteStream } from "node:fs";
import type { Readable } from "node:stream";
import type { BrotliCompress, BrotliOptions, Gzip, ZlibOptions } from "node:zlib";

interface ICompress extends IModule {
module: CompressModule;
level: Record;
compressors: Record;
chunkSize?: number;
init(...args: unknown[]): this;
register(format: string, callback: TryFileCompressor): void;
getLevel(value: string, fallback?: number): number | undefined;
getReadable(file: string | URL | Buffer, options?: ReadableOptions): Readable;
createGzip(file: string | Buffer, options?: CompressLevel): Gzip;
createBrotliCompress(file: string | Buffer, options?: BrotliCompressLevel): BrotliCompress;
createWriteStreamAsGzip(file: string | Buffer, output: string, options?: CompressLevel): WriteStream;
createWriteStreamAsBrotli(file: string | Buffer, output: string, options?: BrotliCompressLevel): WriteStream;
intoGzipStream(output: string, options?: ZlibOptions): WriteStream;
intoBrotliStream(output: string, options?: BrotliOptions): WriteStream;
writeGzip(file: string | Buffer, output: string, options?: CompressLevel): Promise;
writeBrotli(file: string | Buffer, output: string, options?: CompressLevel): Promise;
tryFile(file: string | Buffer, options: CompressFormat): Promise;
tryFile(file: string | Buffer, output: string, options?: CompressFormat): Promise;
tryImage(file: string, options: CompressFormat): Promise;
tryImage(file: string | Buffer, output: string, options?: CompressFormat): Promise;
hasPermission(type: string, options?: unknown): boolean;
set chunkSize(value: number | string | undefined): void;
get chunkSize(): number | undefined;
get settings(): CompressSettings;
}

interface CompressConstructor extends ModuleConstructor {
singleton(): ICompress;
asBuffer(data: Buffer | Uint8Array): Buffer;
readonly prototype: ICompress;
new(module?: CompressModule): ICompress;
}
`

Settings

`typescript
import type { CacheDirAction } from "./settings";

import type { BrotliOptions, ZlibOptions } from "node:zlib";
import type { Options as ZopfliOptions } from "node-zopfli";

interface CompressModule {
gzip?: ZlibOptions;
brotli?: BrotliOptions;
/* @deprecated /
zopfli?: ZopfliOptions;
settings?: {
broadcast_id?: string | string[];
cache?: boolean | CacheDirAction & { font?: string | number | boolean; image?: string | number | boolean; };
/* @deprecated cache.expires /
cache_expires?: number | string;
gzip_level?: number;
brotli_quality?: number;
/* @deprecated /
zopfli_iterations?: number;
chunk_size?: number | string;
};
}
`

$3

`javascript
const Compress = require("@e-mc/compress");

const instance = new Compress({
gzip: {
memLevel: 1,
windowBits: 16
},
tinify: {
api_key: ""
},
settings: {
gzip_level: 9, // Lowest priority
brotli_quality: 11,
chunk_size: "16kb" // All compression types
}
});
instance.init();

const stream = instance.createWriteStreamAsGzip("/tmp/archive.tar", "/path/output/archive.tar.gz", { level: 5, chunkSize: 4 * 1024 }); // Override settings
stream
.on("finish", () => console.log("finish"))
.on("error", err => console.error(err));

const options = {
plugin: "@pi-r/tinify",
format: "png", // Recommended
timeout: 60 * 1000, // 1m
options: {
apiKey: "" // Override settings
}
};
instance.tryImage("/tmp/image.png", "/path/output/compressed.png", options)
.then(data => {
console.log(Buffer.byteLength(data));
})
.catch(err => console.error(err));
``

References

- https://www.unpkg.com/@e-mc/types@0.13.7/lib/squared.d.ts
- https://www.unpkg.com/@e-mc/types@0.13.7/lib/compress.d.ts
- https://www.unpkg.com/@e-mc/types@0.13.7/lib/settings.d.ts

* https://www.npmjs.com/package/@types/node

LICENSE

BSD 3-Clause