imagescript 1.2.9 → 1.2.15

package/ImageScript.d.ts

@@ -0,0 +1,223 @@
+export class Image {
+  private __width__: number;
+  private __height__: number;
+  private __buffer__: ArrayBuffer;
+  private __view__: DataView;
+  private __u32__: Uint32Array;
+  bitmap: Uint8ClampedArray;
+
+  constructor(width: number, height: number);
+
+  private toString(): string;
+
+  get width(): number;
+
+  get height(): number;
+
+  * [Symbol.iterator](): void;
+
+  * iterateWithColors(): Generator<[x: number, y: number, color: number], void, unknown>;
+  
+  static rgbaToColor(r: number, g: number, b: number, a: number): number;
+
+  static rgbToColor(r: number, g: number, b: number): number;
+
+  static hslaToColor(h: number, s: number, l: number, a: number): number;
+
+  static hslToColor(h: number, s: number, l: number): number;
+
+  static rgbaToHSLA(r: number, g: number, b: number, a: number): number[];
+
+  static colorToRGBA(color: number): number[];
+
+  static colorToRGB(color: number): number[];
+
+  getPixelAt(x: number, y: number): number;
+
+  getRGBAAt(x: number, y: number): Uint8ClampedArray;
+
+  setPixelAt(x: number, y: number, pixelColor: number): Image;
+
+  private __set_pixel__(x: number, y: number, pixelColor: number): void;
+
+  private __check_boundaries__(x: number, y: number): void;
+
+  private static get __out_of_bounds__(): string;
+
+  fill(color: number | colorFunction): Image;
+
+  clone(): Image;
+
+  static get RESIZE_NEAREST_NEIGHBOR(): string;
+
+  static get RESIZE_AUTO(): number;
+
+  scale(factor: number, mode?: string): Image;
+
+  private __scale__(factor: number, mode?: string);
+
+  resize(width: number, height: number, mode?: string): Image;
+
+  contain(width: number, height: number, mode?: string): Image;
+
+  fit(width: number, height: number, mode?: string): Image;
+
+  cover(width: number, height: number, mode?: string): Image;
+
+  private __resize__(width: number, height: number, mode?: string): Image;
+
+  private __resize_nearest_neighbor__(width: number, height: number): Image;
+
+  crop(x: number, y: number, width: number, height: number): Image;
+
+  private __crop__(x: number, y: number, width: number, height: number): Image;
+
+  drawBox(x: number, y: number, width: number, height: number, color: number | colorFunction): Image;
+
+  private __fast_box__(x: number, y: number, width: number, height: number, color: number): Image;
+
+  drawCircle(x: number, y: number, radius: number, color: number | colorFunction): Image;
+
+  cropCircle(max?: boolean, feathering?: number): Image;
+
+  opacity(opacity: number, absolute?: boolean): Image;
+
+  red(saturation: number, absolute?: boolean): Image;
+
+  green(saturation: number, absolute?: boolean): Image;
+
+  blue(saturation: number, absolute?: boolean): Image;
+
+  private __set_channel_value__(value: number, absolute: boolean, offset: number): void;
+
+  lightness(value: number, absolute?: boolean): Image;
+
+  saturation(value: number, absolute?: boolean): Image;
+
+  composite(source: Image, x?: number, y?: number): Image;
+
+  invert(): Image;
+
+  invertValue(): Image;
+
+  invertSaturation(): Image;
+
+  invertHue(): Image;
+
+  hueShift(degrees: number): Image;
+
+  averageColor(): number;
+
+  dominantColor(ignoreBlack?: boolean, ignoreWhite?: boolean, bwThreshold?: number): number;
+
+  rotate(angle: number, resize?: boolean): Image;
+
+  private __apply__(image: Image | Frame): Image | Frame;
+
+  static gradient(colors: { [position: number]: number; }): ((position: number) => number);
+
+  roundCorners(radius?: number): Image;
+
+  private static __gradient__(startColor: number, endColor: number): number;
+
+  fisheye(radius?: number): Image;
+
+  async encode(compression?: number, metadata?: PNGMetadata): Promise<Uint8Array>;
+  async encode(metadata?: PNGMetadata): Promise<Uint8Array>;
+
+  async encodeJPEG(quality?: number): Promise<Uint8Array>;
+
+  async encodeWEBP(quality?: null | number): Promise<Uint8Array>;
+
+  static async encode(data: Buffer | Uint8Array): Promise<Image>
+
+  static get SVG_MODE_SCALE(): number;
+
+  static get SVG_MODE_WIDTH(): number;
+
+  static get SVG_MODE_HEIGHT(): number;
+
+  static async renderSVG(svg: string, size?: number, mode?: number): Promise<Image>;
+
+  static async renderText(font: Uint8Array, scale: number, text: string, color?: number, layout?: TextLayout): Promise<Image>;
+};
+
+export class Frame extends Image {
+  static get DISPOSAL_KEEP(): string;
+
+  static get DISPOSAL_PREVIOUS(): string;
+
+  static get DISPOSAL_BACKGROUND(): string
+
+  private static __convert_disposal_mode__(mode: string | number): any;
+
+  constructor(width: number, height: number, duration?: number, xOffset?: number, yOffset?: number, disposalMode?: typeof Frame.DISPOSAL_KEEP | string);
+
+  toString(): string;
+
+  static from(image: Image, duration?: number, xOffset?: number, yOffset?: number, disposalMode?: typeof Frame.DISPOSAL_KEEP | string): Frame;
+
+  resize(width: number, height: number, mode?: typeof Image.RESIZE_NEAREST_NEIGHBOR | string): Image;
+};
+
+export class GIF extends Array {
+  constructor(frames: Frame[], loopCount?: number);
+
+  get width(): number;
+
+  get height(): number;
+
+  toString(): string;
+
+  * [Symbol.iterator](): Generator<Frame, void, *>
+
+  slice(start: number, end: number): GIF;
+
+  get duration(): number;
+
+  async encode(quality?: number): Promise<Uint8Array>
+
+  static async decode(data: Buffer | Uint8Array, onlyExtractFirstFrame?: boolean): Promise<GIF>;
+
+  resize(width: number, height: number, mode?: typeof Image.RESIZE_NEAREST_NEIGHBOR | string): void;
+}
+
+export class TextLayout {
+  constructor(options?: {
+    maxWidth?: number,
+    maxHeight?: number,
+    wrapStyle?: string,
+    verticalAlign?: string,
+    horizontalAlign?: string,
+    wrapHardBreaks?: boolean
+  });
+};
+
+export class ImageType {
+  static getType(data: Buffer | Uint8Array): string | null;
+
+  static isPNG(view: DataView): boolean;
+
+  static isJPEG(view: DataView): boolean;
+
+  static isTIFF(view: DataView): boolean;
+
+  static isGIF(view: DataView): boolean;
+};
+
+export function decode(data: Uint8Array | Buffer, onlyExtractFirstFrame?: boolean): Promise<GIF | Image>;
+
+type colorFunction = (x: number, y: number) => number;
+
+type PNGMetadata = {
+  title?: string,
+  author?: string,
+  description?: string,
+  copyright?: string,
+  creationTime?: string | number | Date,
+  software?: string,
+  disclaimer?: string,
+  warning?: string,
+  source?: string,
+  comment?: string
+};

package/ImageScript.js

@@ -1,12 +1,13 @@
 const png = require('./png/node.js');
 const mem = require('./utils/mem.js');
-const codecs = require('./node/index.js');
 const {version} = require('./package.json');
+const codecs = require('./codecs/node/index.js');
 const { default: v2 } = require('./v2/framebuffer.js');
 
 // old
 const svglib = require('./wasm/node/svg.js');
 const giflib = require('./wasm/node/gif.js');
+const pnglib = require('./wasm/node/png.js');
 const fontlib = require('./wasm/node/font.js');
 const jpeglib = require('./wasm/node/jpeg.js');
 const tifflib = require('./wasm/node/tiff.js');
@@ -83,16 +84,16 @@ class Image {
      * @yields {number[]} The coordinates of the pixel ([x, y])
      * @returns {void}
      */
-    [Symbol.iterator]() {
-        return new v2(this.width, this.height, this.bitmap)[Symbol.iterator]();
+    *[Symbol.iterator]() {
+        for (const x of new v2(this.width, this.height, this.bitmap)[Symbol.iterator]()) yield (x[0]++, x[1]++, x)
     }
 
     /**
      * Yields an [x, y, color] array for every pixel in the image
      * @yields {number[]} The coordinates and color of the pixel ([x, y, color])
      */
-    iterateWithColors() {
-        return new v2(this.width, this.height, this.bitmap).pixels('int');
+    *iterateWithColors() {
+        for (const x of new v2(this.width, this.height, this.bitmap).pixels('int')) yield (x[0]++, x[1]++, x);
     }
 
     /**
@@ -693,48 +694,11 @@ class Image {
      * @returns {Image}
      */
     composite(source, x = 0, y = 0) {
-        x = ~~x;
-        y = ~~y;
-
-        for (let yy = 0; yy < source.height; yy++) {
-            let y_offset = y + yy;
-            if (y_offset < 0) continue;
-            if (y_offset >= this.height) break;
-
-            for (let xx = 0; xx < source.width; xx++) {
-                let x_offset = x + xx;
-                if (x_offset < 0) continue;
-                if (x_offset >= this.width) break;
-
-                const offset = 4 * (x_offset + y_offset * this.width);
-                const fg = source.__view__.getUint32(4 * (xx + yy * source.width), false);
-                const bg = this.__view__.getUint32(offset, false);
-
-                if ((fg & 0xff) === 0xff) this.__view__.setUint32(offset, fg, false);
-                else if ((fg & 0xff) === 0x00) this.__view__.setUint32(offset, bg, false);
-                else this.__view__.setUint32(offset, Image.__alpha_blend__(fg, bg), false);
-            }
-        }
+        new v2(this.width, this.height, this.bitmap).overlay(new v2(source.width, source.height, source.bitmap), x, y);
 
         return this;
     }
 
-    /**
-     * @private
-     * @param {number} fg
-     * @param {number} bg
-     * @returns {number}
-     */
-    static __alpha_blend__(fg, bg) {
-        const fa = fg & 0xff;
-        const alpha = fa + 1;
-        const inv_alpha = 256 - fa;
-        const r = (alpha * (fg >>> 24) + inv_alpha * (bg >>> 24)) >> 8;
-        const b = (alpha * (fg >> 8 & 0xff) + inv_alpha * (bg >> 8 & 0xff)) >> 8;
-        const g = (alpha * (fg >> 16 & 0xff) + inv_alpha * (bg >> 16 & 0xff)) >> 8;
-        return (((r & 0xff) << 24) | ((g & 0xff) << 16) | ((b & 0xff) << 8) | (Math.max(fa, bg & 0xff) & 0xff));
-    }
-
     /**
      * Inverts the images colors
      * @returns {Image}
@@ -1119,9 +1083,9 @@ class Image {
         const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
 
         if (ImageType.isPNG(view)) { // PNG
-            const {width, height, pixels} = await png.decode(data);
+            const {width, height, framebuffer} = (await pnglib.init()).decode(data);
             image = new Image(width, height);
-            image.bitmap.set(pixels);
+            image.bitmap.set(framebuffer);
         } else if (ImageType.isJPEG(view)) { // JPEG
             const framebuffer = (await jpeglib.init()).decode(data);
 
@@ -1535,7 +1499,7 @@ class GIF extends Array {
                 }
 
                 else if (0 === mode || 1 === mode) {
-                    t8.set(u8)
+                    t8.set(u8);
                     for (let y = 0 | 0; y < height; y++) {
                         const y_offset = fx + gwidth * (y + fy) | 0;