@gmitch215/tinyimg 1.0.0

package/dist/image.d.ts

@@ -0,0 +1,263 @@
+import { type Color, type Fit, type FlipAxis, type Gravity, type ImageFormat, type PlanDecision, type RawImage, type ResampleFilter, type Source } from './types.js';
+import { TinyImgModule } from './wasm.js';
+/** What {@link Image.bytes} and its siblings take. */
+export interface EncodeOptions {
+    /** Quality for a lossy format, 1 through 100. */
+    quality?: number;
+    /** Use the format's lossless mode where it has one. */
+    lossless?: boolean;
+    /** Write a progressive or interlaced stream. */
+    progressive?: boolean;
+    /** Drop EXIF and other metadata from the output. */
+    stripMetadata?: boolean;
+    /**
+     * How much computation the encoder may spend. `'fancy'` is the default.
+     *
+     * A separate axis from {@link EncodeOptions.quality}. Quality says what the output should look
+     * like; this says how hard to work to get there. `'fast'` bounds the WebP encoder's 4x4
+     * prediction search to its four whole-block modes, which over six fixtures at 800 wide measured
+     * 1.18x to 1.45x faster for between 8.8% smaller and 17.5% larger, never more than 0.05 dB
+     * apart. Flat-color illustrations pay the most, because hard diagonal edges are what the
+     * omitted modes are for.
+     *
+     * Formats with nothing to trade ignore it and do the exact thing.
+     */
+    effort?: 'fancy' | 'fast';
+}
+/** What {@link Image.fit} takes beyond the target extent. */
+export interface FitOptions {
+    /** Which part a crop keeps, or where a pad puts the image. */
+    gravity?: Gravity;
+    /** Fills whatever a pad leaves empty. */
+    background?: Color;
+    /** Weights the fit's scale samples through. `auto` leaves the choice to the planner. */
+    filter?: ResampleFilter;
+}
+/**
+ * A chainable transformation over one source.
+ *
+ * **Nothing runs until you ask for the output.** Every method here appends to a plan, and the plan
+ * runs once, when {@link bytes} or one of its siblings is called. That is not an implementation
+ * detail: it is what lets a 100x100 thumbnail of a 16 megapixel photograph decode a 500x500 region
+ * at a quarter scale instead of 16 megapixels, and the decision cannot be made after the first
+ * operation has already run.
+ *
+ * The handle lives in the module's memory, so an image has to be released. Prefer `using`:
+ *
+ * ```ts
+ * using image = await tinyimg.open(request.body);
+ * const webp = await image.fit(800, 600, { gravity: 'face' }).sharpen(1).bytes('webp', { quality: 80 });
+ * ```
+ *
+ * Without `using`, call {@link dispose} in a `finally`. {@link bytes} does not dispose, because a
+ * caller may want two encodings of one plan.
+ */
+export declare class Image {
+    #private;
+    private constructor();
+    /**
+     * Opens a source without decoding it.
+     *
+     * The header is read so the planner knows the extent it is working from; no pixel is touched
+     * until the plan runs.
+     *
+     * @param module The loaded module.
+     * @param source The encoded image, in any shape {@link Source} accepts.
+     * @return A transformation with no operations in it yet.
+     */
+    static open(module: TinyImgModule, source: Source): Promise<Image>;
+    /** The container the source arrived in, and the default {@link bytes} encodes back to. */
+    get sourceFormat(): ImageFormat | 'unknown';
+    /**
+     * Frames the source holds, which is 1 for a still image.
+     *
+     * Only the first is decoded, so a value above 1 means an encode of this plan is a still taken
+     * from an animation. The count comes from the header read {@link open} already performed.
+     */
+    get sourceFrames(): number;
+    /**
+     * Operations appended so far.
+     *
+     * The count before any rewrite, so it says what was asked for rather than what will run; see
+     * {@link decide} for the latter.
+     */
+    get operations(): number;
+    /**
+     * Resamples to an extent.
+     *
+     * @param width Target width. Zero, or omitted with a height given, keeps the aspect ratio.
+     * @param height Target height. Same rule.
+     * @param filter Weights to sample through. `auto` is an area average down and a cubic up,
+     * which is the right answer for almost every request.
+     */
+    resize(width: number, height?: number, filter?: ResampleFilter): this;
+    /** Takes a rectangle, in the coordinates the previous operation produced. */
+    crop(x: number, y: number, width: number, height: number): this;
+    /**
+     * Resamples and then crops or pads to an exact extent.
+     *
+     * @param width Target width.
+     * @param height Target height.
+     * @param options `fit` defaults to `cover`; `gravity` to `center`; `filter` to `auto`.
+     */
+    fit(width: number, height: number, options?: FitOptions & {
+        fit?: Fit;
+    }): this;
+    /**
+     * Turns by a multiple of 90 degrees clockwise.
+     *
+     * Folded into the output addressing rather than run as a pass, so any number of turns and flips
+     * cost one pass between them. {@link rotateFree} is the arbitrary-angle form.
+     */
+    rotate(degrees: 0 | 90 | 180 | 270): this;
+    /** Mirrors along one axis or both. */
+    flip(axis?: FlipAxis): this;
+    /**
+     * Turns by an arbitrary angle, filling the corners with the background.
+     *
+     * **Runs after the plan rather than inside it.** An arbitrary rotation changes the extent by a
+     * non-integer factor, so it cannot fold into the sample map the way a quarter turn does; it is
+     * applied to the materialized image. A quarter turn passed here is still handed to
+     * {@link rotate}, which is free.
+     */
+    rotateFree(degrees: number): this;
+    /**
+     * Trims a uniform border.
+     *
+     * **Runs after the plan rather than inside it.** How much to trim is a function of the pixels,
+     * and the planner decides the decode region and scale before a pixel is read, so a trim cannot
+     * be a plan operation. Chain it before a resize and the resize still happens first.
+     *
+     * @param tolerance How far a pixel may differ from the border color and still be trimmed.
+     */
+    trim(tolerance?: number): this;
+    /** Scales every channel. 1 is unchanged. */
+    brightness(factor: number): this;
+    /** Scales every channel about mid gray. 1 is unchanged. */
+    contrast(factor: number): this;
+    /** Moves every channel toward or away from its luminance. 1 is unchanged. */
+    saturation(factor: number): this;
+    /** Rotates the hue, in degrees. */
+    hue(degrees: number): this;
+    /** Raises every channel to a power. 1 is unchanged. */
+    gamma(value: number): this;
+    /** Replaces every channel with the pixel's luminance, and drops the color channels. */
+    grayscale(): this;
+    /** Subtracts every channel from full scale, leaving alpha alone. */
+    invert(): this;
+    /**
+     * Blurs.
+     *
+     * A true gaussian, as three box passes. The planner moves a blur that feeds a reduction of two
+     * or more to after the reduction, at a scaled sigma, which is exact for a gaussian.
+     *
+     * @param sigma Radius in pixels. Zero is a no-op and is eliminated.
+     */
+    blur(sigma: number): this;
+    /**
+     * Sharpens with an unsharp mask.
+     *
+     * @param amount How much of the high-frequency difference to add back. 1 is a typical value.
+     * @param sigma Radius of the blur it is measured against.
+     */
+    sharpen(amount: number, sigma?: number): this;
+    /**
+     * Sets what a pad or an arbitrary rotation fills with.
+     *
+     * Not an operation: it is a property of the plan, so calling it twice replaces rather than
+     * stacking, and calling it after {@link fit} still applies to that fit.
+     */
+    background(color: Color): this;
+    /**
+     * Turns operation fusion off, so every operation runs as its own pass.
+     *
+     * **Leave this on.** It exists to measure what the planner is worth: with it off the same chain
+     * costs one traversal and one buffer per operation, which is what the library would be without
+     * the planner. `bench/` is the only caller that should ever pass `false`.
+     *
+     * @param enabled False to run one operation per pass.
+     */
+    fusion(enabled: boolean): this;
+    /**
+     * Chooses how much work the decode may spend.
+     *
+     * `fancy`, the default, decodes to the bitstream's definition. `fast` lets a lossy decoder drop
+     * its smoothing pass, which is 1.53x on a lossy WebP for 46.8 dB and 1.11x to 1.25x on a
+     * subsampled JPEG for 43.6 to 59.5 dB.
+     *
+     * A lossless format has nothing to drop, because it defines its pixels exactly, so PNG, GIF,
+     * TIFF and lossless WebP decode identically either way. So does a 4:4:4 JPEG, which has no
+     * chroma to upsample.
+     *
+     * This is the decode side only. The encoder's effort is an argument to {@link bytes}.
+     *
+     * @param effort How hard to work.
+     */
+    effort(effort: 'fancy' | 'fast'): this;
+    /**
+     * Reports what the planner decided, without producing the image.
+     *
+     * The saving is visible here: `region` and `scale` are what the decoder will be asked for, and
+     * `eliminated` and `collapsed` are what the rewrites removed. Useful in a log line, and it is
+     * how the library's own tests assert a plan rather than inferring it from the pixels.
+     */
+    decide(): PlanDecision;
+    /**
+     * Runs the plan and encodes the result.
+     *
+     * The plan is not consumed, so this can be called twice for two formats of one transformation
+     * and the planner's work is done once.
+     *
+     * @param format Container to encode as. Defaults to the source's own.
+     * @param options Encoder settings.
+     * @return The encoded bytes.
+     */
+    bytes(format?: ImageFormat, options?: EncodeOptions): Promise<Uint8Array<ArrayBuffer>>;
+    /**
+     * Runs the plan and hands back the raw samples.
+     *
+     * Below the encoders, for a caller who wants the pixels themselves: a histogram, a hand-written
+     * kernel, or a measurement that should not include an encoder's time. Rows are tightly packed
+     * and there is no stride separate from `width * channels`.
+     *
+     * @return The extent, the channel count and `width * height * channels` bytes.
+     */
+    pixels(): Promise<RawImage>;
+    /**
+     * The result as a `Blob`, ready to hand to a `FormData` or a `Response`.
+     *
+     * @param format Container to encode as.
+     * @param options Encoder settings.
+     */
+    blob(format?: ImageFormat, options?: EncodeOptions): Promise<Blob>;
+    /**
+     * The result as a `Response`, which is what a Worker returns.
+     *
+     * @param format Container to encode as.
+     * @param options Encoder settings, plus `headers` merged into the response's own.
+     */
+    response(format?: ImageFormat, options?: EncodeOptions & {
+        headers?: HeadersInit;
+    }): Promise<Response>;
+    /**
+     * The result as a `data:` URL.
+     *
+     * For an inline `<img src>` or a placeholder. Base64 costs a third more bytes than the image,
+     * so this is for small results.
+     *
+     * @param format Container to encode as.
+     * @param options Encoder settings.
+     */
+    dataUrl(format?: ImageFormat, options?: EncodeOptions): Promise<string>;
+    /**
+     * Releases the plan and the source bytes.
+     *
+     * Safe to call twice. Every later call on the image throws instead of reading freed memory.
+     */
+    dispose(): void;
+    /** Lets `using` release the handle; see {@link dispose}. */
+    [Symbol.dispose](): void;
+}
+/** The content type a container is served as. */
+export declare function mimeFor(format: ImageFormat | 'unknown'): string;
+//# sourceMappingURL=image.d.ts.map

package/dist/image.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"image.d.ts","sourceRoot":"","sources":["../src/ts/image.ts"],"names":[],"mappings":"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"}

package/dist/image.js

@@ -0,0 +1,391 @@
+import { readColor, readSource } from './types.js';
+import { TinyImgModule } from './wasm.js';
+const FITS = {
+    'scale-down': 0,
+    contain: 1,
+    cover: 2,
+    crop: 3,
+    'aspect-crop': 4,
+    'aspect-contain': 5,
+    'aspect-cover': 6,
+    pad: 7,
+    stretch: 8,
+    fill: 9,
+    'scale-up': 10
+};
+const GRAVITIES = {
+    center: 0,
+    north: 1,
+    south: 2,
+    west: 3,
+    east: 4,
+    'north-west': 5,
+    'north-east': 6,
+    'south-west': 7,
+    'south-east': 8,
+    auto: 9,
+    face: 10
+};
+const FILTERS = {
+    auto: 0,
+    nearest: 1,
+    bilinear: 2,
+    box: 3,
+    'catmull-rom': 4
+};
+const KERNELS = [
+    [1 << 0, 'region'],
+    [1 << 1, 'scaled'],
+    [1 << 2, 'copy'],
+    [1 << 3, 'resample'],
+    [1 << 4, 'orient'],
+    [1 << 5, 'color'],
+    [1 << 6, 'pad'],
+    [1 << 7, 'gray-decode'],
+    [1 << 8, 'neighborhood']
+];
+const FX_UNSHARP = 0;
+const Field = {
+    regionX: 0,
+    regionY: 1,
+    regionWidth: 2,
+    regionHeight: 3,
+    scale: 4,
+    decodeWidth: 5,
+    decodeHeight: 6,
+    width: 7,
+    height: 8,
+    channels: 9,
+    ops: 10,
+    eliminated: 11,
+    collapsed: 12,
+    colorStages: 13,
+    passes: 14,
+    kernels: 15
+};
+export class Image {
+    #module;
+    #plan;
+    #buffer;
+    #size;
+    #format;
+    #frames;
+    #after = [];
+    #background;
+    #disposed = false;
+    constructor(module, plan, buffer, size, format, frames) {
+        this.#module = module;
+        this.#plan = plan;
+        this.#buffer = buffer;
+        this.#size = size;
+        this.#format = format;
+        this.#frames = frames;
+    }
+    static async open(module, source) {
+        const bytes = await readSource(source);
+        const info = await module.probe(bytes);
+        const buffer = module.copyIn(bytes);
+        const plan = module.alloc(module.exports.tiny_plan_sizeof());
+        try {
+            module.check(module.exports.tiny_plan_init(plan, buffer, bytes.byteLength), 'open the image');
+        }
+        catch (error) {
+            module.free(plan);
+            module.free(buffer);
+            throw error;
+        }
+        return new Image(module, plan, buffer, bytes.byteLength, info.format, info.frames);
+    }
+    get sourceFormat() {
+        return this.#format;
+    }
+    get sourceFrames() {
+        return this.#frames;
+    }
+    get operations() {
+        this.#alive();
+        return this.#module.exports.tiny_plan_count(this.#plan);
+    }
+    resize(width, height = 0, filter = 'auto') {
+        return this.#append(filter === 'auto'
+            ? this.#module.exports.tiny_plan_resize(this.#plan, width, height)
+            : this.#module.exports.tiny_plan_resize_with(this.#plan, width, height, FILTERS[filter]), 'resize');
+    }
+    crop(x, y, width, height) {
+        return this.#append(this.#module.exports.tiny_plan_crop(this.#plan, x, y, width, height), 'crop');
+    }
+    fit(width, height, options = {}) {
+        if (options.background !== undefined)
+            this.background(options.background);
+        return this.#append(this.#module.exports.tiny_plan_fit_with(this.#plan, width, height, FITS[options.fit ?? 'cover'], GRAVITIES[options.gravity ?? 'center'], FILTERS[options.filter ?? 'auto']), 'fit');
+    }
+    rotate(degrees) {
+        return this.#append(this.#module.exports.tiny_plan_rotate(this.#plan, degrees), 'rotate');
+    }
+    flip(axis = 'horizontal') {
+        if (axis === 'horizontal' || axis === 'both') {
+            this.#append(this.#module.exports.tiny_plan_flip_horizontal(this.#plan), 'flip');
+        }
+        if (axis === 'vertical' || axis === 'both') {
+            this.#append(this.#module.exports.tiny_plan_flip_vertical(this.#plan), 'flip');
+        }
+        return this;
+    }
+    rotateFree(degrees) {
+        this.#alive();
+        const quarter = ((degrees % 360) + 360) % 360;
+        if (quarter % 90 === 0)
+            return this.rotate(quarter);
+        const background = this.#background;
+        this.#after.push((image) => {
+            const color = background ? this.#module.copyIn(background) : 0;
+            try {
+                this.#module.check(this.#module.exports.tiny_image_rotate(image, degrees, color), 'rotate');
+            }
+            finally {
+                if (color !== 0)
+                    this.#module.free(color);
+            }
+        });
+        return this;
+    }
+    trim(tolerance = 8) {
+        this.#alive();
+        this.#after.push((image) => {
+            this.#module.check(this.#module.exports.tiny_image_trim(image, tolerance), 'trim');
+        });
+        return this;
+    }
+    brightness(factor) {
+        return this.#append(this.#module.exports.tiny_plan_brightness(this.#plan, factor), 'brightness');
+    }
+    contrast(factor) {
+        return this.#append(this.#module.exports.tiny_plan_contrast(this.#plan, factor), 'contrast');
+    }
+    saturation(factor) {
+        return this.#append(this.#module.exports.tiny_plan_saturation(this.#plan, factor), 'saturation');
+    }
+    hue(degrees) {
+        return this.#append(this.#module.exports.tiny_plan_hue(this.#plan, degrees), 'hue');
+    }
+    gamma(value) {
+        return this.#append(this.#module.exports.tiny_plan_gamma(this.#plan, value), 'gamma');
+    }
+    grayscale() {
+        return this.#append(this.#module.exports.tiny_plan_grayscale(this.#plan), 'grayscale');
+    }
+    invert() {
+        return this.#append(this.#module.exports.tiny_plan_invert(this.#plan), 'invert');
+    }
+    blur(sigma) {
+        return this.#append(this.#module.exports.tiny_plan_gaussian_blur(this.#plan, sigma), 'blur');
+    }
+    sharpen(amount, sigma = 1) {
+        this.#alive();
+        const params = this.#module.alloc(16);
+        const view = this.#module.view();
+        view.setFloat32(params, sigma, true);
+        view.setFloat32(params + 4, amount, true);
+        view.setFloat32(params + 8, 0, true);
+        view.setFloat32(params + 12, 0, true);
+        try {
+            return this.#append(this.#module.exports.tiny_plan_effect(this.#plan, FX_UNSHARP, params), 'sharpen');
+        }
+        finally {
+            this.#module.free(params);
+        }
+    }
+    background(color) {
+        this.#alive();
+        this.#background = readColor(color, 4);
+        const pointer = this.#module.copyIn(this.#background);
+        try {
+            this.#module.check(this.#module.exports.tiny_plan_background(this.#plan, pointer), 'set the background');
+        }
+        finally {
+            this.#module.free(pointer);
+        }
+        return this;
+    }
+    fusion(enabled) {
+        return this.#append(this.#module.exports.tiny_plan_set_fusion(this.#plan, enabled ? 1 : 0), 'fusion setting');
+    }
+    effort(effort) {
+        return this.#append(this.#module.exports.tiny_plan_set_effort(this.#plan, effort === 'fast' ? 1 : 0), 'effort setting');
+    }
+    decide() {
+        this.#alive();
+        const module = this.#module;
+        const resolution = module.alloc(module.exports.tiny_plan_resolution_sizeof());
+        try {
+            module.check(module.exports.tiny_plan_resolve(this.#plan, resolution), 'resolve the plan');
+            const field = (name) => module.exports.tiny_plan_field(resolution, Field[name]);
+            const bits = field('kernels');
+            return {
+                region: {
+                    x: field('regionX'),
+                    y: field('regionY'),
+                    width: field('regionWidth'),
+                    height: field('regionHeight')
+                },
+                scale: field('scale'),
+                decoded: { width: field('decodeWidth'), height: field('decodeHeight') },
+                output: {
+                    width: field('width'),
+                    height: field('height'),
+                    channels: field('channels')
+                },
+                operations: field('ops'),
+                eliminated: field('eliminated'),
+                collapsed: field('collapsed'),
+                colorStages: field('colorStages'),
+                passes: field('passes'),
+                kernels: KERNELS.filter(([bit]) => (bits & bit) !== 0).map(([, name]) => name),
+                estimateMs: module.exports.tiny_plan_cost(this.#plan) / 1000
+            };
+        }
+        finally {
+            module.free(resolution);
+        }
+    }
+    async bytes(format, options = {}) {
+        this.#alive();
+        const target = format ?? this.#format;
+        if (target === 'unknown') {
+            throw new TypeError('the source format is unknown, so a format has to be given');
+        }
+        const module = this.#module;
+        const writer = module.alloc(module.exports.tiny_writer_sizeof());
+        const opts = module.alloc(5);
+        const view = module.view();
+        view.setUint8(opts, options.quality ?? 0);
+        view.setUint8(opts + 1, options.lossless ? 1 : 0);
+        view.setUint8(opts + 2, options.progressive ? 1 : 0);
+        view.setUint8(opts + 3, options.stripMetadata ? 1 : 0);
+        view.setUint8(opts + 4, options.effort === 'fast' ? 1 : 0);
+        try {
+            module.check(module.exports.tiny_writer_init(writer, 0), 'prepare the encoder');
+            try {
+                if (this.#after.length === 0) {
+                    module.check(module.exports.tiny_plan_encode(this.#plan, module.formatId(target), opts, writer), 'run and encode');
+                }
+                else {
+                    this.#runWithAfter(target, opts, writer);
+                }
+                return module.copyOut(module.exports.tiny_writer_data(writer), module.exports.tiny_writer_size(writer));
+            }
+            finally {
+                module.exports.tiny_writer_free(writer);
+            }
+        }
+        finally {
+            module.free(opts);
+            module.free(writer);
+        }
+    }
+    async pixels() {
+        this.#alive();
+        const module = this.#module;
+        const image = module.alloc(module.exports.tiny_image_sizeof());
+        try {
+            module.check(module.exports.tiny_plan_run(this.#plan, image), 'run the plan');
+            try {
+                for (const step of this.#after)
+                    step(image);
+                return {
+                    width: module.exports.tiny_image_getwidth(image),
+                    height: module.exports.tiny_image_getheight(image),
+                    channels: module.exports.tiny_image_getchannels(image),
+                    pixels: module.copyOut(module.exports.tiny_image_getdata(image), module.exports.tiny_image_getsize(image))
+                };
+            }
+            finally {
+                module.exports.tiny_image_destroy(image);
+            }
+        }
+        finally {
+            module.free(image);
+        }
+    }
+    async blob(format, options = {}) {
+        const target = format ?? this.#format;
+        const bytes = await this.bytes(format, options);
+        return new Blob([bytes], { type: mimeFor(target) });
+    }
+    async response(format, options = {}) {
+        const target = format ?? this.#format;
+        const bytes = await this.bytes(format, options);
+        const headers = new Headers(options.headers);
+        headers.set('content-type', mimeFor(target));
+        headers.set('content-length', String(bytes.byteLength));
+        return new Response(bytes, { headers });
+    }
+    async dataUrl(format, options = {}) {
+        const target = format ?? this.#format;
+        const bytes = await this.bytes(format, options);
+        let binary = '';
+        for (const byte of bytes)
+            binary += String.fromCharCode(byte);
+        return `data:${mimeFor(target)};base64,${btoa(binary)}`;
+    }
+    dispose() {
+        if (this.#disposed)
+            return;
+        this.#disposed = true;
+        this.#module.free(this.#plan);
+        this.#module.free(this.#buffer);
+    }
+    [Symbol.dispose]() {
+        this.dispose();
+    }
+    #alive() {
+        if (this.#disposed)
+            throw new TypeError('this image has been disposed');
+    }
+    #append(result, what) {
+        this.#alive();
+        this.#module.check(result, `append a ${what}`);
+        return this;
+    }
+    #runWithAfter(target, opts, writer) {
+        const module = this.#module;
+        const image = module.alloc(module.exports.tiny_image_sizeof());
+        try {
+            module.check(module.exports.tiny_plan_run(this.#plan, image), 'run the plan');
+            try {
+                for (const step of this.#after)
+                    step(image);
+                module.check(module.exports.tiny_image_encode(image, module.formatId(target), opts, writer), 'encode');
+            }
+            finally {
+                module.exports.tiny_image_destroy(image);
+            }
+        }
+        finally {
+            module.free(image);
+        }
+    }
+}
+export function mimeFor(format) {
+    switch (format) {
+        case 'png':
+            return 'image/png';
+        case 'jpeg':
+            return 'image/jpeg';
+        case 'bmp':
+            return 'image/bmp';
+        case 'gif':
+            return 'image/gif';
+        case 'tiff':
+            return 'image/tiff';
+        case 'webp':
+            return 'image/webp';
+        case 'avif':
+            return 'image/avif';
+        case 'heif':
+            return 'image/heif';
+        default:
+            return 'application/octet-stream';
+    }
+}
+//# sourceMappingURL=image.js.map