Update exported types for image parsers.

README.md

@@ -136,8 +136,6 @@ import { JpegParser } from './bitjs/image/parsers/jpeg.js'
 import { ExifTagNumber } from './bitjs/image/parsers/exif.js';
 
 const parser = new JpegParser(someArrayBuffer);
-let exif;
-const parser = new JpegParser(ab);
 parser.onApp1Exif(evt => {
   console.log(evt.exifValueMap.get(ExifTagNumber.IMAGE_DESCRIPTION).stringValue);
 });

image/parsers/jpeg.js

@@ -34,7 +34,7 @@ export const JpegParseEventType = {
 }
 
 /** @enum {number} */
-const JpegSegmentType = {
+export const JpegSegmentType = {
   SOF0: 0xC0,
   SOF1: 0xC1,
   SOF2: 0xC2,
@@ -155,14 +155,14 @@ export class JpegDefineHuffmanTableEvent extends Event {
 }
 
 /** @enum {number} */
-const JpegDctType = {
+export const JpegDctType = {
   BASELINE: 0,
   EXTENDED_SEQUENTIAL: 1,
   PROGRESSIVE: 2,
 };
 
 /** @enum {number} */
-const JpegComponentType = {
+export const JpegComponentType = {
   Y: 1,
   CB: 2,
   CR: 3,

index.js

@@ -6,15 +6,26 @@
  * Copyright(c) 2020 Google Inc.
  */
 
-/**
- * @typedef {import('./codecs/codecs.js').ProbeStream} ProbeStream
- */
-/**
- * @typedef {import('./codecs/codecs.js').ProbeFormat} ProbeFormat
- */
-/**
- * @typedef {import('./codecs/codecs.js').ProbeInfo} ProbeInfo
- */
+/** @typedef {import('./codecs/codecs.js').ProbeStream} ProbeStream */
+/** @typedef {import('./codecs/codecs.js').ProbeFormat} ProbeFormat */
+/** @typedef {import('./codecs/codecs.js').ProbeInfo} ProbeInfo */
+
+/** @typedef {import('./image/parsers/gif.js').GifApplicationExtension} GifApplicationExtension */
+/** @typedef {import('./image/parsers/gif.js').GifColor} GifColor */
+/** @typedef {import('./image/parsers/gif.js').GifCommentExtension} GifCommentExtension */
+/** @typedef {import('./image/parsers/gif.js').GifGraphicControlExtension} GifGraphicControlExtension */
+/** @typedef {import('./image/parsers/gif.js').GifHeader} GifHeader */
+/** @typedef {import('./image/parsers/gif.js').GifLogicalScreen} GifLogicalScreen */
+/** @typedef {import('./image/parsers/gif.js').GifPlainTextExtension} GifPlainTextExtension */
+/** @typedef {import('./image/parsers/gif.js').GifTableBasedImage} GifTableBasedImage */
+
+/** @typedef {import('./image/parsers/jpeg.js').JpegApp0Extension} JpegApp0Extension */
+/** @typedef {import('./image/parsers/jpeg.js').JpegApp0Marker} JpegApp0Marker */
+/** @typedef {import('./image/parsers/jpeg.js').JpegComponentDetail} JpegComponentDetail */
+/** @typedef {import('./image/parsers/jpeg.js').JpegDefineHuffmanTable} JpegDefineHuffmanTable */
+/** @typedef {import('./image/parsers/jpeg.js').JpegDefineQuantizationTable} JpegDefineQuantizationTable */
+/** @typedef {import('./image/parsers/jpeg.js').JpegStartOfFrame} JpegStartOfFrame */
+/** @typedef {import('./image/parsers/jpeg.js').JpegStartOfScan} JpegStartOfScan */
 
 export {
   UnarchiveEvent, UnarchiveEventType, UnarchiveInfoEvent, UnarchiveErrorEvent,
@@ -26,6 +37,11 @@ export { findMimeType } from './file/sniffer.js';
 export { GifApplicationExtensionEvent, GifCommentExtensionEvent, GifGraphicControlExtensionEvent,
          GifHeaderEvent, GifLogicalScreenEvent, GifParseEventType, GifParser,
          GifPlainTextExtensionEvent, GifTableBasedImageEvent } from './image/parsers/gif.js';
+export { JpegApp0ExtensionEvent, JpegApp0MarkerEvent, JpegApp1ExifEvent, JpegComponentType,
+         JpegDctType, JpegDefineHuffmanTableEvent, JpegDefineQuantizationTableEvent,
+         JpegDensityUnits, JpegExtensionThumbnailFormat, JpegHuffmanTableType, JpegParseEventType,
+         JpegParser, JpegSegmentType, JpegStartOfFrameEvent,
+         JpegStartOfScanEvent } from './image/parsers/jpeg.js';
 export { convertWebPtoPNG, convertWebPtoJPG } from './image/webp-shim/webp-shim.js';
 export { BitBuffer } from './io/bitbuffer.js';
 export { BitStream } from './io/bitstream.js';

io/bytestream.js

@@ -73,15 +73,15 @@ export class ByteStream {
 
   /**
    * Big-Endian is sometimes called Motorola-style.
-   * @param {boolean=} The value to set. If not present, the stream is set to big-endian.
+   * @param {boolean=} val The value to set. If not present, the stream is set to big-endian.
    */
   setBigEndian(val = true) {
     this.littleEndian_ = !val;
   }
 
   /**
    * Little-Endian is sometimes called Intel-style.
-   * @param {boolean=} The value to set. If not present, the stream is set to little-endian.
+   * @param {boolean=} val The value to set. If not present, the stream is set to little-endian.
    */
   setLittleEndian(val = true) {
     this.littleEndian_ = val;

package.json

@@ -19,6 +19,7 @@
     "file",
     "codecs",
     "gif",
+    "jpeg",
     "mp4",
     "avc",
     "webm",

types/image/parsers/exif.d.ts

@@ -0,0 +1,127 @@
+/**
+ * @param {ByteStream} stream
+ * @param {ByteStream} lookAheadStream
+ * @param {boolean} debug
+ * @returns {ExifValue}
+ */
+export function getExifValue(stream: ByteStream, lookAheadStream: ByteStream, DEBUG?: boolean): ExifValue;
+export type ExifTagNumber = number;
+export namespace ExifTagNumber {
+    const IMAGE_DESCRIPTION: number;
+    const MAKE: number;
+    const MODEL: number;
+    const ORIENTATION: number;
+    const X_RESOLUTION: number;
+    const Y_RESOLUTION: number;
+    const RESOLUTION_UNIT: number;
+    const SOFTWARE: number;
+    const DATE_TIME: number;
+    const WHITE_POINT: number;
+    const PRIMARY_CHROMATICITIES: number;
+    const Y_CB_CR_COEFFICIENTS: number;
+    const Y_CB_CR_POSITIONING: number;
+    const REFERENCE_BLACK_WHITE: number;
+    const COPYRIGHT: number;
+    const EXIF_OFFSET: number;
+    const EXPOSURE_TIME: number;
+    const F_NUMBER: number;
+    const EXPOSURE_PROGRAM: number;
+    const ISO_SPEED_RATINGS: number;
+    const EXIF_VERSION: number;
+    const DATE_TIME_ORIGINAL: number;
+    const DATE_TIME_DIGITIZED: number;
+    const COMPONENT_CONFIGURATION: number;
+    const COMPRESSED_BITS_PER_PIXEL: number;
+    const SHUTTER_SPEED_VALUE: number;
+    const APERTURE_VALUE: number;
+    const BRIGHTNESS_VALUE: number;
+    const EXPOSURE_BIAS_VALUE: number;
+    const MAX_APERTURE_VALUE: number;
+    const SUBJECT_DISTANCE: number;
+    const METERING_MODE: number;
+    const LIGHT_SOURCE: number;
+    const FLASH: number;
+    const FOCAL_LENGTH: number;
+    const MAKER_NOTE: number;
+    const USER_COMMENT: number;
+    const FLASH_PIX_VERSION: number;
+    const COLOR_SPACE: number;
+    const EXIF_IMAGE_WIDTH: number;
+    const EXIF_IMAGE_HEIGHT: number;
+    const RELATED_SOUND_FILE: number;
+    const EXIF_INTEROPERABILITY_OFFSET: number;
+    const FOCAL_PLANE_X_RESOLUTION: number;
+    const FOCAL_PLANE_Y_RESOLUTION: number;
+    const FOCAL_PLANE_RESOLUTION_UNIT: number;
+    const SENSING_METHOD: number;
+    const FILE_SOURCE: number;
+    const SCENE_TYPE: number;
+    const IMAGE_WIDTH: number;
+    const IMAGE_LENGTH: number;
+    const BITS_PER_SAMPLE: number;
+    const COMPRESSION: number;
+    const PHOTOMETRIC_INTERPRETATION: number;
+    const STRIP_OFFSETS: number;
+    const SAMPLES_PER_PIXEL: number;
+    const ROWS_PER_STRIP: number;
+    const STRIP_BYTE_COUNTS: number;
+    const PLANAR_CONFIGURATION: number;
+    const JPEG_IF_OFFSET: number;
+    const JPEG_IF_BYTE_COUNT: number;
+    const Y_CB_CR_SUB_SAMPLING: number;
+}
+export type ExifDataFormat = number;
+export namespace ExifDataFormat {
+    const UNSIGNED_BYTE: number;
+    const ASCII_STRING: number;
+    const UNSIGNED_SHORT: number;
+    const UNSIGNED_LONG: number;
+    const UNSIGNED_RATIONAL: number;
+    const SIGNED_BYTE: number;
+    const UNDEFINED: number;
+    const SIGNED_SHORT: number;
+    const SIGNED_LONG: number;
+    const SIGNED_RATIONAL: number;
+    const SINGLE_FLOAT: number;
+    const DOUBLE_FLOAT: number;
+}
+export type ExifValue = {
+    /**
+     * The numerical value of the tag.
+     */
+    tagNumber: ExifTagNumber;
+    /**
+     * A string representing the tag number.
+     */
+    tagName?: string | undefined;
+    /**
+     * The data format.
+     */
+    dataFormat: ExifDataFormat;
+    /**
+     * Populated for SIGNED/UNSIGNED BYTE/SHORT/LONG/FLOAT.
+     */
+    numericalValue?: number | undefined;
+    /**
+     * Populated only for ASCII_STRING.
+     */
+    stringValue?: string | undefined;
+    /**
+     * Populated only for SIGNED/UNSIGNED RATIONAL.
+     */
+    numeratorValue?: number | undefined;
+    /**
+     * Populated only for SIGNED/UNSIGNED RATIONAL.
+     */
+    denominatorValue?: number | undefined;
+    /**
+     * Populated only for UNDEFINED data format.
+     */
+    numComponents?: number | undefined;
+    /**
+     * Populated only for UNDEFINED data format.
+     */
+    offsetValue?: number | undefined;
+};
+import { ByteStream } from "../../io/bytestream.js";
+//# sourceMappingURL=exif.d.ts.map

types/image/parsers/gif.d.ts

@@ -12,7 +12,7 @@ export namespace GifParseEventType {
  * @typedef GifHeader
  * @property {string} version
  */
-export class GifHeaderParseEvent extends Event {
+export class GifHeaderEvent extends Event {
     /** @param {GifHeader} header */
     constructor(header: GifHeader);
     /** @type {GifHeader} */
@@ -36,7 +36,7 @@ export class GifHeaderParseEvent extends Event {
  * @property {number} pixelAspectRatio
  * @property {GifColor[]=} globalColorTable Only if globalColorTableFlag is true.
  */
-export class GifLogicalScreenParseEvent extends Event {
+export class GifLogicalScreenEvent extends Event {
     /** @param {GifLogicalScreen} */
     constructor(logicalScreen: any);
     /** @type {GifLogicalScreen} */
@@ -134,9 +134,7 @@ export class GifTrailerEvent extends Event {
  *                                Comment Extension
  */
 export class GifParser extends EventTarget {
-    /**
-     * @param {ArrayBuffer} ab
-     */
+    /** @param {ArrayBuffer} ab */
     constructor(ab: ArrayBuffer);
     /**
      * @type {ByteStream}
@@ -149,12 +147,53 @@ export class GifParser extends EventTarget {
      */
     private version;
     /**
-     * Overridden so that the type hints for eventType are specific.
-     * @param {'application_extension'|'comment_extension'|'graphical_control_extension'|'header'|'logical_screen'|'plain_text_extension'|'table_based_image'|'trailer'} eventType
-     * @param {EventListenerOrEventListenerObject} listener
-     * @override
+     * Type-safe way to bind a listener for a GifApplicationExtensionEvent.
+     * @param {function(GifApplicationExtensionEvent): void} listener
+     * @returns {GifParser} for chaining
+     */
+    onApplicationExtension(listener: (arg0: GifApplicationExtensionEvent) => void): GifParser;
+    /**
+     * Type-safe way to bind a listener for a GifCommentExtensionEvent.
+     * @param {function(GifCommentExtensionEvent): void} listener
+     * @returns {GifParser} for chaining
+     */
+    onCommentExtension(listener: (arg0: GifCommentExtensionEvent) => void): GifParser;
+    /**
+     * Type-safe way to bind a listener for a GifGraphicControlExtensionEvent.
+     * @param {function(GifGraphicControlExtensionEvent): void} listener
+     * @returns {GifParser} for chaining
+     */
+    onGraphicControlExtension(listener: (arg0: GifGraphicControlExtensionEvent) => void): GifParser;
+    /**
+     * Type-safe way to bind a listener for a GifHeaderEvent.
+     * @param {function(GifHeaderEvent): void} listener
+     * @returns {GifParser} for chaining
+     */
+    onHeader(listener: (arg0: GifHeaderEvent) => void): GifParser;
+    /**
+     * Type-safe way to bind a listener for a GifLogicalScreenEvent.
+     * @param {function(GifLogicalScreenEvent): void} listener
+     * @returns {GifParser} for chaining
+     */
+    onLogicalScreen(listener: (arg0: GifLogicalScreenEvent) => void): GifParser;
+    /**
+     * Type-safe way to bind a listener for a GifPlainTextExtensionEvent.
+     * @param {function(GifPlainTextExtensionEvent): void} listener
+     * @returns {GifParser} for chaining
+     */
+    onPlainTextExtension(listener: (arg0: GifPlainTextExtensionEvent) => void): GifParser;
+    /**
+     * Type-safe way to bind a listener for a GifTableBasedImageEvent.
+     * @param {function(GifTableBasedImageEvent): void} listener
+     * @returns {GifParser} for chaining
+     */
+    onTableBasedImage(listener: (arg0: GifTableBasedImageEvent) => void): GifParser;
+    /**
+     * Type-safe way to bind a listener for a GifTrailerEvent.
+     * @param {function(GifTrailerEvent): void} listener
+     * @returns {GifParser} for chaining
      */
-    override addEventListener(eventType: 'application_extension' | 'comment_extension' | 'graphical_control_extension' | 'header' | 'logical_screen' | 'plain_text_extension' | 'table_based_image' | 'trailer', listener: EventListenerOrEventListenerObject): void;
+    onTrailer(listener: (arg0: GifTrailerEvent) => void): GifParser;
     /**
      * @returns {Promise<void>} A Promise that resolves when the parsing is complete.
      */