sane-wasm 0.2.0 → 0.3.1

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 {};