beautiful-image 0.2.2 → 0.2.4

package/dist/beautiful-image.node.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const c=require("node:fs"),m=require("node:url"),l=require("node:path"),s=require("./image-processor-hqbPBWVw.cjs");var i=typeof document<"u"?document.currentScript:null;const h=l.dirname(m.fileURLToPath(typeof document>"u"?require("url").pathToFileURL(__filename).href:i&&i.tagName.toUpperCase()==="SCRIPT"&&i.src||new URL("beautiful-image.node.cjs",document.baseURI).href));let a=!1;async function f(){if(!a){const t=l.join(h,"../wasm/beautiful_image_bg.wasm"),e=c.readFileSync(t);await s.__wbg_init({module_or_path:e}),a=!0}}class p extends s.ImageProcessor{constructor(e){super(e)}async toJpeg(e){await f();const u=new Uint8Array(this.file.buffer,this.file.byteOffset,this.file.byteLength),n=s.processImageFromBytes(u,this.targetWidth??null,e,this.ops.sharpenSigma??null,this.ops.sharpenThreshold??null,this.ops.blurSigma??null,this.ops.brightness??null,this.ops.contrast??null,this.ops.grayscale,this.ops.invert,this.ops.hueRotate??null),o=this.file.byteLength,r=n.length;return{data:Buffer.from(n),originalSize:o,optimizedSize:r,compressionRatio:1-r/o}}}const d=t=>new p(t);exports.processImageFromBytes=s.processImageFromBytes;exports.image=d;

package/dist/beautiful-image.node.d.ts

@@ -0,0 +1,44 @@
+export declare const image: (file: Buffer | Uint8Array) => ImageProcessorNode;
+
+declare abstract class ImageProcessor<TInput, TResult> {
+    protected file: TInput;
+    protected targetWidth?: number;
+    protected ops: Operations;
+    constructor(file: TInput);
+    resize(width: number): this;
+    sharpen(sigma?: number, threshold?: number): this;
+    blur(sigma: number): this;
+    brightness(value: number): this;
+    contrast(value: number): this;
+    grayscale(): this;
+    invert(): this;
+    hueRotate(degrees: number): this;
+    abstract toJpeg(quality: number): Promise<TResult>;
+}
+
+declare class ImageProcessorNode extends ImageProcessor<Buffer | Uint8Array, NodeOptimizeResult> {
+    constructor(file: Buffer | Uint8Array);
+    toJpeg(quality: number): Promise<NodeOptimizeResult>;
+}
+
+export declare interface NodeOptimizeResult {
+    data: Buffer;
+    originalSize: number;
+    optimizedSize: number;
+    compressionRatio: number;
+}
+
+declare interface Operations {
+    sharpenSigma?: number;
+    sharpenThreshold?: number;
+    blurSigma?: number;
+    brightness?: number;
+    contrast?: number;
+    grayscale: boolean;
+    invert: boolean;
+    hueRotate?: number;
+}
+
+export declare function processImageFromBytes(image_data: Uint8Array, target_width: number | null | undefined, quality: number, sharpen_sigma: number | null | undefined, sharpen_threshold: number | null | undefined, blur_sigma: number | null | undefined, brightness: number | null | undefined, contrast: number | null | undefined, grayscale: boolean, invert: boolean, hue_rotate?: number | null): Uint8Array;
+
+export { }

package/dist/beautiful-image.node.js

@@ -0,0 +1,44 @@
+import { readFileSync as n } from "node:fs";
+import { fileURLToPath as l } from "node:url";
+import { dirname as m, join as h } from "node:path";
+import { I as p, a as u, _ as c } from "./image-processor-CfaoYWMt.js";
+const f = m(l(import.meta.url));
+let r = !1;
+async function g() {
+  if (!r) {
+    const s = h(f, "../wasm/beautiful_image_bg.wasm"), t = n(s);
+    await c({ module_or_path: t }), r = !0;
+  }
+}
+class d extends p {
+  constructor(t) {
+    super(t);
+  }
+  async toJpeg(t) {
+    await g();
+    const a = new Uint8Array(this.file.buffer, this.file.byteOffset, this.file.byteLength), e = u(
+      a,
+      this.targetWidth ?? null,
+      t,
+      this.ops.sharpenSigma ?? null,
+      this.ops.sharpenThreshold ?? null,
+      this.ops.blurSigma ?? null,
+      this.ops.brightness ?? null,
+      this.ops.contrast ?? null,
+      this.ops.grayscale,
+      this.ops.invert,
+      this.ops.hueRotate ?? null
+    ), i = this.file.byteLength, o = e.length;
+    return {
+      data: Buffer.from(e),
+      originalSize: i,
+      optimizedSize: o,
+      compressionRatio: 1 - o / i
+    };
+  }
+}
+const I = (s) => new d(s);
+export {
+  I as image,
+  u as processImageFromBytes
+};