sane-wasm 0.3.0 → 0.3.1

package/dist/index.d.ts

@@ -497,3 +497,5 @@ export declare const libsane: LibSANEFactory;
  * Use the 'libsane' named export.
  */
 export default libsane;
+export * from './options';
+export * from './readers';

package/dist/index.js

@@ -1,4 +1,18 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.libsane = exports.SANEFrame = exports.SANEConstraintType = exports.SANEUnit = exports.SANEValueType = exports.SANEStatus = void 0;
 /**
@@ -79,3 +93,5 @@ exports.libsane = require('../lib');
  * Use the 'libsane' named export.
  */
 exports.default = exports.libsane;
+__exportStar(require("./options"), exports);
+__exportStar(require("./readers"), exports);

package/dist/options.d.ts

@@ -0,0 +1,127 @@
+import { LibSANE, SANEOptionDescriptor, SANEStatus } from ".";
+export interface ScanOption<T = any> {
+    index: number;
+    descriptor: SANEOptionDescriptor;
+    value: T;
+}
+export interface IScanOptions extends Iterable<ScanOption> {
+    /**
+     * List of all SANE options.
+     */
+    readonly options: ReadonlyArray<ScanOption>;
+    /**
+     * Well-known SANE option index zero (total number of options).
+     *
+     * @see {@link https://sane-project.gitlab.io/standard/1.06/api.html#well-known-options}
+     */
+    readonly zero: ScanOption<number>;
+    /**
+     * Well-known SANE option `resolution`.
+     *
+     * @see {@link https://sane-project.gitlab.io/standard/1.06/api.html#well-known-options}
+     */
+    readonly resolution: ScanOption<number> | null;
+    /**
+     * Well-known SANE option `preview`.
+     *
+     * @see {@link https://sane-project.gitlab.io/standard/1.06/api.html#well-known-options}
+     */
+    readonly preview: ScanOption<boolean> | null;
+    /**
+     * Well-known SANE option `tl-x`.
+     *
+     * @see {@link https://sane-project.gitlab.io/standard/1.06/api.html#well-known-options}
+     */
+    readonly tlX: ScanOption<number> | null;
+    /**
+     * Well-known SANE option `tl-y`.
+     *
+     * @see {@link https://sane-project.gitlab.io/standard/1.06/api.html#well-known-options}
+     */
+    readonly tlY: ScanOption<number> | null;
+    /**
+     * Well-known SANE option `br-x`.
+     *
+     * @see {@link https://sane-project.gitlab.io/standard/1.06/api.html#well-known-options}
+     */
+    readonly brX: ScanOption<number> | null;
+    /**
+     * Well-known SANE option `br-y`.
+     *
+     * @see {@link https://sane-project.gitlab.io/standard/1.06/api.html#well-known-options}
+     */
+    readonly brY: ScanOption<number> | null;
+}
+/**
+ * @private
+ */
+export declare abstract class ScanOptionsBase implements IScanOptions {
+    protected _lib: LibSANE;
+    readonly options: ReadonlyArray<ScanOption>;
+    readonly zero: ScanOption<number>;
+    readonly resolution: ScanOption<number> | null;
+    readonly preview: ScanOption<boolean> | null;
+    readonly tlX: ScanOption<number> | null;
+    readonly tlY: ScanOption<number> | null;
+    readonly brX: ScanOption<number> | null;
+    readonly brY: ScanOption<number> | null;
+    [Symbol.iterator](): IterableIterator<ScanOption>;
+    protected static _getOpts(lib: LibSANE): Promise<ScanOption<any>[]>;
+    protected constructor(lib: LibSANE, opts: Array<ScanOption>);
+    protected _setOpts(this: {
+        -readonly [K in keyof ScanOptionsBase]: ScanOptionsBase[K];
+    }, opts: Array<ScanOption>): void;
+    protected _setValue(index: number, value: any): Promise<{
+        status: SANEStatus.UNSUPPORTED | SANEStatus.CANCELLED | SANEStatus.DEVICE_BUSY | SANEStatus.INVAL | SANEStatus.EOF | SANEStatus.JAMMED | SANEStatus.NO_DOCS | SANEStatus.COVER_OPEN | SANEStatus.IO_ERROR | SANEStatus.NO_MEM | SANEStatus.ACCESS_DENIED;
+        info: null;
+        opts: null;
+    } | {
+        status: SANEStatus.GOOD;
+        info: import(".").SANEInfo;
+        opts: ScanOption<any>[];
+    }>;
+    /**
+     * Get class instance (with all scanning options).
+     */
+    static get: (lib: LibSANE) => Promise<IScanOptions>;
+    /**
+     * Set option value. Use `null` as `value` for automatic.
+     *
+     * @see {@link https://sane-project.gitlab.io/standard/1.06/api.html#sane-control-option}
+     */
+    abstract setValue(index: number, value: any): any;
+}
+/**
+ * Helper class for getting/setting scan options.
+ *
+ * Any changes (i.e. calls to {@link ScanOptionsMutable.setValue}) affect the
+ * internal state.
+ */
+export declare class ScanOptionsMutable extends ScanOptionsBase {
+    static get(lib: LibSANE): Promise<ScanOptionsMutable>;
+    setValue(index: number, value: any): Promise<{
+        status: SANEStatus.GOOD;
+        info: import(".").SANEInfo;
+    } | {
+        status: SANEStatus.UNSUPPORTED | SANEStatus.CANCELLED | SANEStatus.DEVICE_BUSY | SANEStatus.INVAL | SANEStatus.EOF | SANEStatus.JAMMED | SANEStatus.NO_DOCS | SANEStatus.COVER_OPEN | SANEStatus.IO_ERROR | SANEStatus.NO_MEM | SANEStatus.ACCESS_DENIED;
+        info: null;
+    }>;
+}
+/**
+ * Helper class for getting/setting scan options.
+ *
+ * Any changes (i.e. calls to {@link ScanOptions.setValue}) return a
+ * new class instance.
+ */
+export declare class ScanOptions extends ScanOptionsBase {
+    static get(lib: LibSANE): Promise<ScanOptions>;
+    setValue(index: number, value: any): Promise<{
+        status: SANEStatus.GOOD;
+        info: import(".").SANEInfo;
+        updated: ScanOptions;
+    } | {
+        status: SANEStatus.UNSUPPORTED | SANEStatus.CANCELLED | SANEStatus.DEVICE_BUSY | SANEStatus.INVAL | SANEStatus.EOF | SANEStatus.JAMMED | SANEStatus.NO_DOCS | SANEStatus.COVER_OPEN | SANEStatus.IO_ERROR | SANEStatus.NO_MEM | SANEStatus.ACCESS_DENIED;
+        info: null;
+        updated: null;
+    }>;
+}

package/dist/options.js

@@ -0,0 +1,165 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScanOptions = exports.ScanOptionsMutable = exports.ScanOptionsBase = void 0;
+const _1 = require(".");
+/**
+ * @private
+ */
+class ScanOptionsBase {
+    [Symbol.iterator]() {
+        return this.options[Symbol.iterator]();
+    }
+    static _getOpts(lib) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const opts = [];
+            let desc = null;
+            for (let i = 0, n = -1; desc || i === 0; i++) {
+                ({ option_descriptor: desc } = lib.sane_get_option_descriptor(i));
+                if (desc) {
+                    if (!desc.cap.INACTIVE && desc.cap.SOFT_DETECT && desc.type !== _1.SANEValueType.BUTTON) {
+                        const { status, value } = yield lib.sane_control_option_get_value(i);
+                        if (status !== _1.SANEStatus.GOOD) {
+                            throw new Error(`Unexpected status ${_1.SANEStatus[status]} while getting option value.`);
+                        }
+                        opts.push({ index: i, descriptor: desc, value });
+                        if (i === 0) {
+                            n = value; // option 0 contains total number of options
+                        }
+                    }
+                    else {
+                        opts.push({ index: i, descriptor: desc, value: null });
+                    }
+                }
+                else if (!desc && i !== n) {
+                    throw new Error('Unexpected number of options.');
+                }
+            }
+            return opts;
+        });
+    }
+    constructor(lib, opts) {
+        this.resolution = null;
+        this.preview = null;
+        this.tlX = null;
+        this.tlY = null;
+        this.brX = null;
+        this.brY = null;
+        this._lib = lib;
+        this._setOpts(opts);
+    }
+    _setOpts(opts) {
+        this.options = opts;
+        this.zero = this.options[0];
+        for (let i = 0; i < this.options.length; i++) {
+            if (this.options[i].index !== i) {
+                throw new Error(`Option index mismatch ${this.options[i].index} != ${i}.`);
+            }
+            switch (this.options[i].descriptor.name) {
+                case 'resolution':
+                    this.resolution = this.options[i];
+                    break;
+                case 'preview':
+                    this.preview = this.options[i];
+                    break;
+                case 'tl-x':
+                    this.tlX = this.options[i];
+                    break;
+                case 'tl-y':
+                    this.tlY = this.options[i];
+                    break;
+                case 'br-x':
+                    this.brX = this.options[i];
+                    break;
+                case 'br-y':
+                    this.brY = this.options[i];
+                    break;
+            }
+        }
+    }
+    _setValue(index, value) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const auto = value === null; // null means auto
+            const { status, info } = auto ? yield this._lib.sane_control_option_set_auto(index) : yield this._lib.sane_control_option_set_value(index, value);
+            if (status !== _1.SANEStatus.GOOD) {
+                return { status, info, opts: null };
+            }
+            if (info.RELOAD_OPTIONS) {
+                return { status, info, opts: yield ScanOptionsBase._getOpts(this._lib) };
+            }
+            if (info.INEXACT || typeof value === 'number' || auto) {
+                // auto triggers get value... ok
+                // number triggers get value... this is a quirk for fixed numbers
+                // because the conversion from floating to fixed point happens
+                // on the library side, we might get INEXACT == false but in
+                // reality there were some small difference
+                // XXX: this could probably be fixed on the C side
+                const { status, value: v } = yield this._lib.sane_control_option_get_value(index);
+                if (status !== _1.SANEStatus.GOOD) {
+                    throw new Error(`Unexpected status ${_1.SANEStatus[status]} while getting option value.`);
+                }
+                value = v;
+            }
+            // update value
+            const opts = [...this.options];
+            opts[index] = Object.assign(Object.assign({}, opts[index]), { value });
+            return { status, info, opts };
+        });
+    }
+}
+exports.ScanOptionsBase = ScanOptionsBase;
+/**
+ * Helper class for getting/setting scan options.
+ *
+ * Any changes (i.e. calls to {@link ScanOptionsMutable.setValue}) affect the
+ * internal state.
+ */
+class ScanOptionsMutable extends ScanOptionsBase {
+    static get(lib) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new this(lib, yield this._getOpts(lib));
+        });
+    }
+    setValue(index, value) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { status, info, opts } = yield this._setValue(index, value);
+            if (status == _1.SANEStatus.GOOD) {
+                this._setOpts(opts);
+                return { status, info };
+            }
+            return { status, info };
+        });
+    }
+}
+exports.ScanOptionsMutable = ScanOptionsMutable;
+/**
+ * Helper class for getting/setting scan options.
+ *
+ * Any changes (i.e. calls to {@link ScanOptions.setValue}) return a
+ * new class instance.
+ */
+class ScanOptions extends ScanOptionsBase {
+    static get(lib) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new this(lib, yield this._getOpts(lib));
+        });
+    }
+    setValue(index, value) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { status, info, opts } = yield this._setValue(index, value);
+            if (status == _1.SANEStatus.GOOD) {
+                return { status, info, updated: new ScanOptions(this._lib, opts) };
+            }
+            return { status, info, updated: null };
+        });
+    }
+}
+exports.ScanOptions = ScanOptions;

package/dist/readers.d.ts

@@ -0,0 +1,108 @@
+import { LibSANE, SANEParameters, SANEStatus } from ".";
+declare abstract class EventBaseClass<T extends Record<keyof T, any[]>> {
+    private _firing;
+    private _listeners;
+    /**
+     * Add event listener.
+     */
+    on<K extends keyof T>(type: K, listener: (...args: T[K]) => void): void;
+    /**
+     * Fire event.
+     */
+    protected fire<K extends keyof T>(type: K, ...args: T[K]): Promise<null> | null;
+}
+/**
+ * @private Events types for {@link ScanDataReader}.
+ */
+export interface ScanDataReaderEventMap extends Record<string, any[]> {
+    /**
+     * Scanning stop event.
+     */
+    start: [parameters: SANEParameters];
+    /**
+     * Scanning start event.
+     */
+    stop: [parameters: SANEParameters, error: Error | null];
+    /**
+     * Raw image data event.
+     */
+    data: [parameters: SANEParameters, data: Uint8Array];
+}
+/**
+ * Raw data reader that automatically handles SANE's read code flow.
+ *
+ * Use {@link ScanDataReader.on} to listen to events, available event types
+ * are declared on {@link ScanDataReaderEventMap}.
+ *
+ * A device should already be open with sane_open(), the reader will call
+ * sane_start() do the scanning and call sane_stop().
+ *
+ * Other SANE functions cannot be used while scanning.
+ *
+ * Scan readers are single use.
+ *
+ * {@link https://sane-project.gitlab.io/standard/1.06/api.html#code-flow}
+ */
+export declare class ScanDataReader<T extends ScanDataReaderEventMap = ScanDataReaderEventMap> extends EventBaseClass<T> {
+    private _lib;
+    private _used;
+    private _killed;
+    constructor(lib: LibSANE);
+    private _readPromise;
+    /**
+     * Start scanning operation.
+     */
+    start(): {
+        status: SANEStatus.UNSUPPORTED | SANEStatus.CANCELLED | SANEStatus.DEVICE_BUSY | SANEStatus.INVAL | SANEStatus.EOF | SANEStatus.JAMMED | SANEStatus.NO_DOCS | SANEStatus.COVER_OPEN | SANEStatus.IO_ERROR | SANEStatus.NO_MEM | SANEStatus.ACCESS_DENIED;
+        parameters: null;
+        promise: Promise<void>;
+    } | {
+        status: SANEStatus.GOOD;
+        parameters: SANEParameters;
+        promise: Promise<void>;
+    };
+    /**
+     * Cancel scanning operation.
+     */
+    cancel(): void;
+}
+/**
+ * @private Events types for {@link ScanImageReader}.
+ */
+export interface ScanImageReaderEventMap extends ScanDataReaderEventMap {
+    /**
+     * Image line event, one or more full lines of RGBA data.
+     */
+    line: [parameters: SANEParameters, data: Uint8ClampedArray, line: number];
+    /**
+     * Full image event (end of scan), RGBA data.
+     */
+    image: [parameters: SANEParameters, data: Uint8ClampedArray];
+}
+/**
+ * Image reader that automatically generates RGBA data while reading from
+ * SANE's API using {@link ScanDataReader}. It supports the most common scan
+ * modes and image formats. More formats can be added in the future.
+ *
+ * Use {@link ScanImageReader.on} to listen to events, available event types
+ * are declared on {@link ScanImageReaderEventMap}.
+ *
+ * A device should already be open with sane_open(), the reader will call
+ * sane_start() do the scanning and call sane_stop().
+ *
+ * Other SANE functions cannot be used while scanning.
+ *
+ * Scan readers are single use.
+ *
+ * {@link https://sane-project.gitlab.io/standard/1.06/api.html#code-flow}
+ */
+export declare class ScanImageReader<T extends ScanImageReaderEventMap = ScanImageReaderEventMap> extends ScanDataReader<T> {
+    private _line;
+    private _allData;
+    private _remainder;
+    constructor(lib: LibSANE);
+    private _onStart;
+    private _onData;
+    private _onStop;
+}
+export {};

package/dist/readers.js

@@ -0,0 +1,320 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScanImageReader = exports.ScanDataReader = void 0;
+const _1 = require(".");
+class EventBaseClass {
+    constructor() {
+        this._firing = false;
+        this._listeners = {};
+    }
+    /**
+     * Add event listener.
+     */
+    on(type, listener) {
+        var _a;
+        if (!this._listeners[type]) {
+            this._listeners[type] = [];
+        }
+        (_a = this._listeners[type]) === null || _a === void 0 ? void 0 : _a.push(listener);
+    }
+    /**
+     * Fire event.
+     */
+    fire(type, ...args) {
+        var _a;
+        // if already firing an event, queue for later
+        if (this._firing) {
+            return Promise.resolve().then(() => this.fire(type, ...args));
+        }
+        // fire now
+        this._firing = true;
+        try {
+            (_a = this._listeners[type]) === null || _a === void 0 ? void 0 : _a.forEach(fn => fn.apply(this, args));
+        }
+        finally {
+            this._firing = false;
+        }
+        return null;
+    }
+}
+/**
+ * Raw data reader that automatically handles SANE's read code flow.
+ *
+ * Use {@link ScanDataReader.on} to listen to events, available event types
+ * are declared on {@link ScanDataReaderEventMap}.
+ *
+ * A device should already be open with sane_open(), the reader will call
+ * sane_start() do the scanning and call sane_stop().
+ *
+ * Other SANE functions cannot be used while scanning.
+ *
+ * Scan readers are single use.
+ *
+ * {@link https://sane-project.gitlab.io/standard/1.06/api.html#code-flow}
+ */
+class ScanDataReader extends EventBaseClass {
+    constructor(lib) {
+        super();
+        this._used = false;
+        this._killed = false;
+        this._lib = lib;
+    }
+    _readPromise(parameters) {
+        return new Promise((resolve, reject) => {
+            const read = () => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    if (this._killed) {
+                        yield this._lib.sane_cancel(); // ignore status
+                    }
+                    // reads are non-blocking because of how emscripten works
+                    // this causes sane_read() to immediately return with
+                    // 0 bytes of data, this goes against the SANE spec,
+                    // blocking I/O by default
+                    // the only option right now is to poll the read using
+                    // setTimeout(), this is not ideal
+                    // currently even emscripten's asyncify does not help here,
+                    // but in the future it might help support blocking I/O
+                    // XXX: are we in the future now? can we improve this
+                    // https://github.com/emscripten-core/emscripten/issues/13214
+                    const { status, data } = yield this._lib.sane_read(); // non-blocking
+                    if (status === _1.SANEStatus.GOOD) {
+                        if (parameters && data.length) {
+                            this.fire('data', parameters, data);
+                        }
+                    }
+                    else if (status === _1.SANEStatus.CANCELLED ||
+                        // special case for EOF after sane_cancel, after a successful
+                        // page read (EOF) and subsequent call to sane_cancel we expected a
+                        // CANCELLED status but the test backend never changes from EOF,
+                        // this is different on the pixma backend (it changes to CANCELLED),
+                        // it's unknown what is the correct option, or what happens on other
+                        // backends, handle special case as cancelled for now
+                        // XXX: more research
+                        // https://sane-project.gitlab.io/standard/1.06/api.html#code-flow
+                        (status === _1.SANEStatus.EOF && this._killed)) {
+                        if (this._killed instanceof Error) {
+                            reject(this._killed);
+                            return;
+                        }
+                        resolve();
+                        return;
+                    }
+                    else if (status === _1.SANEStatus.EOF) {
+                        // image finished
+                        this._killed = true;
+                    }
+                    else {
+                        // TODO: handle document feeder / multi-page scans
+                        this._killed = new Error(`Status ${_1.SANEStatus[status]} during sane_read().`);
+                    }
+                    setTimeout(read, data && data.length > 0 ? 10 : 200);
+                }
+                catch (e) {
+                    const ee = e instanceof Error ? e : new Error("Unknown error while scanning.");
+                    if (this._killed) {
+                        // already killed, but sane_read is still going? die
+                        reject(ee);
+                        return;
+                    }
+                    this._killed = ee;
+                    setTimeout(read, 200);
+                }
+            });
+            setTimeout(read, 200);
+        });
+    }
+    /**
+     * Start scanning operation.
+     */
+    start() {
+        if (this._used) {
+            // readers are single use
+            return {
+                status: _1.SANEStatus.INVAL,
+                parameters: null,
+                promise: Promise.reject(new Error("Scan readers cannot be reused.")),
+            };
+        }
+        else {
+            const { status } = this._lib.sane_start();
+            if (status !== _1.SANEStatus.GOOD) {
+                return {
+                    status,
+                    parameters: null,
+                    promise: Promise.reject(new Error(`Status ${_1.SANEStatus[status]} during sane_start().`)),
+                };
+            }
+            this._used = true;
+        }
+        // after successful start, sane_cancel needs to be called and we need
+        // to wait for sane_read, so subsequent fails need to use this._killed
+        // and run the read loop
+        const { status, parameters } = this._lib.sane_get_parameters();
+        if (status !== _1.SANEStatus.GOOD) {
+            this._killed = new Error(`Status ${_1.SANEStatus[status]} during sane_get_parameters().`);
+            return {
+                status, parameters,
+                promise: this._readPromise(parameters),
+            };
+        }
+        try {
+            this.fire('start', parameters);
+        }
+        catch (e) {
+            this._killed = e instanceof Error ? e : new Error("Unknown error while starting the scan.");
+        }
+        return {
+            status, parameters,
+            promise: this._readPromise(parameters).finally(() => {
+                this.fire('stop', parameters, this._killed instanceof Error ? this._killed : null);
+            }),
+        };
+    }
+    /**
+     * Cancel scanning operation.
+     */
+    cancel() {
+        if (this._used && !this._killed) {
+            this._killed = true;
+        }
+    }
+}
+exports.ScanDataReader = ScanDataReader;
+/**
+ * Image reader that automatically generates RGBA data while reading from
+ * SANE's API using {@link ScanDataReader}. It supports the most common scan
+ * modes and image formats. More formats can be added in the future.
+ *
+ * Use {@link ScanImageReader.on} to listen to events, available event types
+ * are declared on {@link ScanImageReaderEventMap}.
+ *
+ * A device should already be open with sane_open(), the reader will call
+ * sane_start() do the scanning and call sane_stop().
+ *
+ * Other SANE functions cannot be used while scanning.
+ *
+ * Scan readers are single use.
+ *
+ * {@link https://sane-project.gitlab.io/standard/1.06/api.html#code-flow}
+ */
+class ScanImageReader extends ScanDataReader {
+    constructor(lib) {
+        super(lib);
+        this._line = 0;
+        this._allData = new Uint8ClampedArray();
+        this._remainder = new Uint8ClampedArray();
+        this.on('start', this._onStart);
+        this.on('data', this._onData);
+        this.on('stop', this._onStop);
+    }
+    _onStart(parameters) {
+        if (parameters.format !== _1.SANEFrame.GRAY && parameters.format !== _1.SANEFrame.RGB) {
+            throw new Error(`Invalid format (${JSON.stringify(parameters)}).`);
+        }
+        if (parameters.depth !== 1 && parameters.depth !== 8) {
+            throw new Error(`Invalid bit depth (${JSON.stringify(parameters)}).`);
+        }
+        if (!parameters.last_frame) {
+            throw new Error(`Invalid scanner (3-pass) (${JSON.stringify(parameters)}).`);
+        }
+        if (parameters.lines < 0) {
+            throw new Error(`Invalid scanner (hand-scanner) (${JSON.stringify(parameters)}).`);
+        }
+        if (parameters.bytes_per_line <= 0 || parameters.pixels_per_line <= 0 || parameters.lines <= 0) {
+            throw new Error(`Unexpected image size (${JSON.stringify(parameters)}).`);
+        }
+        const channels = parameters.format === _1.SANEFrame.GRAY ? 1 : 3;
+        const bits = parameters.pixels_per_line * parameters.depth * channels;
+        if (parameters.bytes_per_line * 8 < bits) {
+            throw new Error(`Unexpected byte count (${JSON.stringify(parameters)}).`);
+        }
+        // what do we support then?
+        // we support GRAY and RGB single-pass, 1 and 8-bit, known height
+        // that should cover most modern scanners
+        this._allData = new Uint8ClampedArray(parameters.lines * parameters.pixels_per_line * 4);
+    }
+    _onData(parameters, data) {
+        const dataIn = new Uint8ClampedArray(this._remainder.length + data.length);
+        dataIn.set(this._remainder, 0);
+        dataIn.set(data, this._remainder.length);
+        // line count, number of full available lines
+        const lc = Math.floor(dataIn.length / parameters.bytes_per_line);
+        if (!lc) {
+            // not enough data for a full line
+            this._remainder = dataIn;
+            return;
+        }
+        const dataOut = new Uint8ClampedArray(lc * parameters.pixels_per_line * 4); // RGBA (8-bit)
+        let ik = 0; // consumed data on dataIn
+        if (parameters.depth === 8) {
+            if (parameters.format === _1.SANEFrame.GRAY) {
+                // 8-bit / 1 channel
+                for (let l = 0, o = 0; l < lc; l++, ik += parameters.bytes_per_line) { // for lines
+                    for (let p = 0, i = ik; p < parameters.pixels_per_line; p++, i++, o += 4) { // for pixels
+                        dataOut[o] = dataOut[o + 1] = dataOut[o + 2] = dataIn[i];
+                        dataOut[o + 3] = 0xff; // alpha
+                    }
+                }
+            }
+            else {
+                // 8-bit / 3 channels
+                for (let l = 0, o = 0; l < lc; l++, ik += parameters.bytes_per_line) { // for lines
+                    for (let p = 0, i = ik; p < parameters.pixels_per_line; p++, i += 3, o += 4) { // for pixels
+                        dataOut.set(dataIn.subarray(i, i + 3), o);
+                        dataOut[o + 3] = 0xff; // alpha
+                    }
+                }
+            }
+        }
+        else { // parameters.depth == 1
+            if (parameters.format === _1.SANEFrame.GRAY) {
+                // 1-bit / 1 channel
+                for (let l = 0, o = 0; l < lc; l++, ik += parameters.bytes_per_line) { // for lines
+                    for (let p = 0, i = ik; p < parameters.pixels_per_line; i++) { // for in bytes
+                        for (let mask = 0x80; mask !== 0 && p < parameters.pixels_per_line; mask >>= 1, p++, o += 4) { // for pixels
+                            dataOut[o] = dataOut[o + 1] = dataOut[o + 2] = dataIn[i] & mask ? 0x00 : 0xff;
+                            dataOut[o + 3] = 0xff; // alpha
+                        }
+                    }
+                }
+            }
+            else {
+                // 1-bit / 3 channels
+                // niche format, probably very few (if any) scanners support this
+                // according to the test backend the bits are inverted on this format, if compared
+                // with 1-bit gray (1 channel), it remains to be seen if this is correct in the wild
+                for (let l = 0, o = 0; l < lc; l++, ik += parameters.bytes_per_line) { // for lines
+                    for (let p = 0, i = ik; p < parameters.pixels_per_line; i += 3) { // for in bytes
+                        for (let mask = 0x80; mask !== 0 && p < parameters.pixels_per_line; mask >>= 1, p++, o += 4) { // for pixels
+                            // rbg is interlaced byte-by-byte not bit-by-bit
+                            // so 3 bytes have the R-G-B for 8 pixels
+                            dataOut[o] = dataIn[i] & mask ? 0xff : 0x00;
+                            dataOut[o + 1] = dataIn[i + 1] & mask ? 0xff : 0x00;
+                            dataOut[o + 2] = dataIn[i + 2] & mask ? 0xff : 0x00;
+                            dataOut[o + 3] = 0xff; // alpha
+                        }
+                    }
+                }
+            }
+        }
+        this._remainder = dataIn.subarray(ik);
+        this.fire('line', parameters, dataOut, this._line);
+        this._allData.set(dataOut, this._line * parameters.pixels_per_line * 4);
+        this._line += lc;
+    }
+    _onStop(parameters, error) {
+        if (!error) {
+            this.fire('image', parameters, this._allData);
+        }
+    }
+}
+exports.ScanImageReader = ScanImageReader;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sane-wasm",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "A project to bring the SANE API to the web.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",