sane-wasm 0.3.0 → 0.3.2

package/build/libsane.worker.js

@@ -27,23 +27,15 @@ if (ENVIRONMENT_IS_NODE) {
 
   Object.assign(global, {
     self: global,
-    require: require,
-    Module: Module,
+    require,
+    Module,
     location: {
       href: __filename
     },
     Worker: nodeWorkerThreads.Worker,
-    importScripts: function(f) {
-      (0, eval)(fs.readFileSync(f, 'utf8') + '//# sourceURL=' + f);
-    },
-    postMessage: function(msg) {
-      parentPort.postMessage(msg);
-    },
-    performance: global.performance || {
-      now: function() {
-        return Date.now();
-      }
-    },
+    importScripts: (f) => (0, eval)(fs.readFileSync(f, 'utf8') + '//# sourceURL=' + f),
+    postMessage: (msg) => parentPort.postMessage(msg),
+    performance: global.performance || { now: Date.now },
   });
 }
 
@@ -65,7 +57,7 @@ function threadPrintErr() {
 }
 function threadAlert() {
   var text = Array.prototype.slice.call(arguments).join(' ');
-  postMessage({cmd: 'alert', text: text, threadId: Module['_pthread_self']()});
+  postMessage({cmd: 'alert', text, threadId: Module['_pthread_self']()});
 }
 // We don't need out() for now, but may need to add it if we want to use it
 // here. Or, if this code all moves into the main JS, that problem will go
@@ -73,6 +65,7 @@ function threadAlert() {
 var out = () => { throw 'out() is not defined in worker.js.'; }
 var err = threadPrintErr;
 self.alert = threadAlert;
+var dbg = threadPrintErr;
 
 Module['instantiateWasm'] = (info, receiveInstance) => {
   // Instantiate from the module posted from the main thread.
@@ -90,7 +83,7 @@ Module['instantiateWasm'] = (info, receiveInstance) => {
 // Turn unhandled rejected promises into errors so that the main thread will be
 // notified about them.
 self.onunhandledrejection = (e) => {
-  throw e.reason ?? e;
+  throw e.reason || e;
 };
 
 function handleMessage(e) {
@@ -120,8 +113,8 @@ function handleMessage(e) {
       // Use `const` here to ensure that the variable is scoped only to
       // that iteration, allowing safe reference from a closure.
       for (const handler of e.data.handlers) {
-        Module[handler] = function() {
-          postMessage({ cmd: 'callHandler', handler, args: [...arguments] });
+        Module[handler] = (...args) => {
+          postMessage({ cmd: 'callHandler', handler, args: args });
         }
       }
 
@@ -143,7 +136,7 @@ function handleMessage(e) {
       LibSANE(Module);
     } else if (e.data.cmd === 'run') {
       // Pass the thread address to wasm to store it for fast access.
-      Module['__emscripten_thread_init'](e.data.pthread_ptr, /*isMainBrowserThread=*/0, /*isMainRuntimeThread=*/0, /*canBlock=*/1);
+      Module['__emscripten_thread_init'](e.data.pthread_ptr, /*is_main=*/0, /*is_runtime=*/0, /*can_block=*/1);
 
       // Await mailbox notifications with `Atomics.waitAsync` so we can start
       // using the fast `Atomics.notify` notification path.
@@ -186,11 +179,11 @@ function handleMessage(e) {
       // The received message looks like something that should be handled by this message
       // handler, (since there is a e.data.cmd field present), but is not one of the
       // recognized commands:
-      err('worker.js received unknown command ' + e.data.cmd);
+      err(`worker.js received unknown command ${e.data.cmd}`);
       err(e.data);
     }
   } catch(ex) {
-    err('worker.js onmessage() captured an uncaught exception: ' + ex);
+    err(`worker.js onmessage() captured an uncaught exception: ${ex}`);
     if (ex && ex.stack) err(ex.stack);
     if (Module['__emscripten_thread_crashed']) {
       Module['__emscripten_thread_crashed']();
@@ -200,5 +193,3 @@ function handleMessage(e) {
 };
 
 self.onmessage = handleMessage;
-
-

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