@mapcatch/util 1.0.7 → 1.0.8-b

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mapcatch/util",
-  "version": "1.0.7",
+  "version": "1.0.8-b",
   "main": "./dist/catchUtil.min.esm.js",
   "repository": "",
   "author": "wanyanyan",

package/src/exif/index.js

@@ -1,16 +1,33 @@
 import {getData} from './parse_image'
 import {getAllTags} from './exif'
+import {imageSize} from '../image-size'
 
 export const getPhotoTags = (file) => {
   return new Promise((resolve, reject) => {
-    getData(file, function (img, err) {
-      if (err) {
-        reject(err)
-        return
-      }
-      let info = getAllTags(img)
-      let exif = JSON.parse(JSON.stringify(info).replaceAll('\\u0000', '')) || {}
-      resolve(exif)
-    })
+    if (file.type === 'image/jpeg') {
+      let sliceFile = file.slice(0, 131072)
+      sliceFile.name = file.name
+      getData(sliceFile, function (img, err) {
+        if (err) {
+          reject(err)
+          return
+        }
+        let info = getAllTags(img)
+        let exif = JSON.parse(JSON.stringify(info).replaceAll('\\u0000', '')) || {}
+        resolve(exif)
+      })
+    } else {
+      var fileReader = new FileReader();
+      fileReader.onload = function (e) {
+        let u8array = new Uint8Array(e.target.result)
+        let size = imageSize(u8array)
+        resolve({
+          PixelXDimension: size.width,
+          PixelYDimension: size.height
+        })
+      };
+
+      fileReader.readAsArrayBuffer(file);
+    }
   })
 }

package/src/exif/parse_image.js

@@ -4,6 +4,7 @@ import ExifTags from './tags'
 import StringValues from './string_values'
 import GPSTags from './gps_tags'
 import IptcFieldMap from './iptc_field_map'
+import {imageSize} from '../image-size'
 
 var isXmpEnabled = false
 
@@ -86,10 +87,6 @@ function findEXIFinJPEG(file) {
   var dataView = new DataView(file);
   let exif = {}
 
-  if ((dataView.getUint8(0) != 0xFF) || (dataView.getUint8(1) != 0xD8)) {
-    return false; // not a valid jpeg
-  }
-
   var offset = 2,
     length = file.byteLength,
     marker;
@@ -105,21 +102,16 @@ function findEXIFinJPEG(file) {
     // but we're only looking for 0xFFE1 for EXIF data
 
     if (marker == 225) {
-      Object.assign(exif, readEXIFData(dataView, offset + 4, dataView.getUint16(offset + 2) - 2))
-    } else if (marker === 192) {
-      let width = dataView.getUint16(offset + 7)
-      let height = dataView.getUint16(offset + 5)
-      if (width && height) {
-        Object.assign(exif, {
-          PixelXDimension: width,
-          PixelYDimension: height
-        })
-      }
-      return exif
+      exif = readEXIFData(dataView, offset + 4, dataView.getUint16(offset + 2) - 2)
+      break
     }
     offset += 2 + dataView.getUint16(offset + 2);
-
   }
+  let size = imageSize(new Uint8Array(file))
+  Object.assign(exif, {
+    PixelXDimension: size.width,
+    PixelYDimension: size.height
+  })
   return exif
 
 }

package/src/image-size/detector.js

@@ -0,0 +1,24 @@
+import { typeHandlers, types } from './types/index'
+
+// This map helps avoid validating for every single image type
+const firstBytes = new Map([
+  [0x38, 'psd'],
+  [0x42, 'bmp'],
+  [0x44, 'dds'],
+  [0x47, 'gif'],
+  [0x49, 'tiff'],
+  [0x4d, 'tiff'],
+  [0x52, 'webp'],
+  [0x69, 'icns'],
+  [0x89, 'png'],
+  [0xff, 'jpg'],
+])
+
+export function detector(input) {
+  const byte = input[0]
+  const type = firstBytes.get(byte)
+  if (type && typeHandlers.get(type).validate(input)) {
+    return type
+  }
+  return types.find((type) => typeHandlers.get(type).validate(input))
+}

package/src/image-size/fromFile.js

@@ -0,0 +1,55 @@
+import * as fs from 'node:fs'
+import * as path from 'node:path'
+
+import { lookup } from './lookup'
+
+// Maximum input size, with a default of 512 kilobytes.
+// TO-DO: make this adaptive based on the initial signature of the image
+const MaxInputSize = 512 * 1024
+
+// This queue is for async `fs` operations, to avoid reaching file-descriptor limits
+const queue = []
+
+let concurrency = 100
+export const setConcurrency = (c) => {
+  concurrency = c
+}
+
+const processQueue = async () => {
+  const jobs = queue.splice(0, concurrency)
+  const promises = jobs.map(async ({ filePath, resolve, reject }) => {
+    let handle
+    try {
+      handle = await fs.promises.open(path.resolve(filePath), 'r')
+    } catch (err) {
+      return reject(err)
+    }
+    try {
+      const { size } = await handle.stat()
+      if (size <= 0) {
+        throw new Error('Empty file')
+      }
+      const inputSize = Math.min(size, MaxInputSize)
+      const input = new Uint8Array(inputSize)
+      await handle.read(input, 0, inputSize, 0)
+      resolve(lookup(input))
+    } catch (err) {
+      reject(err)
+    } finally {
+      await handle.close()
+    }
+  })
+
+  await Promise.allSettled(promises)
+
+  if (queue.length) setTimeout(processQueue, 100)
+}
+
+/**
+ * @param {string} filePath - relative/absolute path of the image file
+ */
+export const imageSize = async (filePath) =>
+  new Promise<ISizeCalculationResult>((resolve, reject) => {
+    queue.push({ filePath, resolve, reject })
+    processQueue()
+  })

package/src/image-size/index.js

@@ -0,0 +1,2 @@
+export { types } from './types'
+export { lookup as imageSize, disableTypes } from './lookup'

package/src/image-size/lookup.js

@@ -0,0 +1,37 @@
+import { typeHandlers } from './types/index'
+import { detector } from './detector'
+
+const globalOptions = {
+  disabledTypes: [],
+}
+
+/**
+ * Return size information based on an Uint8Array
+ *
+ * @param {Uint8Array} input
+ * @returns {ISizeCalculationResult}
+ */
+export function lookup(input) {
+  // detect the file type... don't rely on the extension
+  const type = detector(input)
+
+  if (typeof type !== 'undefined') {
+    if (globalOptions.disabledTypes.indexOf(type) > -1) {
+      throw new TypeError('disabled file type: ' + type)
+    }
+
+    // find an appropriate handler for this file type
+    const size = typeHandlers.get(type).calculate(input)
+    if (size !== undefined) {
+      size.type = size.type ?? type
+      return size
+    }
+  }
+
+  // throw up, if we don't understand the file
+  throw new TypeError('unsupported file type: ' + type)
+}
+
+export const disableTypes = (types) => {
+  globalOptions.disabledTypes = types
+}

package/src/image-size/types/bmp.js

@@ -0,0 +1,10 @@
+import { toUTF8String, readInt32LE, readUInt32LE } from './utils'
+
+export const BMP = {
+  validate: (input) => toUTF8String(input, 0, 2) === 'BM',
+
+  calculate: (input) => ({
+    height: Math.abs(readInt32LE(input, 22)),
+    width: readUInt32LE(input, 18),
+  }),
+}

package/src/image-size/types/cur.js

@@ -0,0 +1,16 @@
+import { ICO } from './ico'
+import { readUInt16LE } from './utils'
+
+const TYPE_CURSOR = 2
+export const CUR = {
+  validate(input) {
+    const reserved = readUInt16LE(input, 0)
+    const imageCount = readUInt16LE(input, 4)
+    if (reserved !== 0 || imageCount === 0) return false
+
+    const imageType = readUInt16LE(input, 2)
+    return imageType === TYPE_CURSOR
+  },
+
+  calculate: (input) => ICO.calculate(input),
+}

package/src/image-size/types/dds.js

@@ -0,0 +1,10 @@
+import { readUInt32LE } from './utils'
+
+export const DDS = {
+  validate: (input) => readUInt32LE(input, 0) === 0x20534444,
+
+  calculate: (input) => ({
+    height: readUInt32LE(input, 12),
+    width: readUInt32LE(input, 16),
+  }),
+}

package/src/image-size/types/gif.js

@@ -0,0 +1,11 @@
+import { toUTF8String, readUInt16LE } from './utils'
+
+const gifRegexp = /^GIF8[79]a/
+export const GIF = {
+  validate: (input) => gifRegexp.test(toUTF8String(input, 0, 6)),
+
+  calculate: (input) => ({
+    height: readUInt16LE(input, 8),
+    width: readUInt16LE(input, 6),
+  }),
+}

package/src/image-size/types/heif.js

@@ -0,0 +1,35 @@
+import { findBox, readUInt32BE, toUTF8String } from './utils'
+
+const brandMap = {
+  avif: 'avif',
+  mif1: 'heif',
+  msf1: 'heif', // hief-sequence
+  heic: 'heic',
+  heix: 'heic',
+  hevc: 'heic', // heic-sequence
+  hevx: 'heic', // heic-sequence
+}
+
+export const HEIF = {
+  validate(buffer) {
+    const ftype = toUTF8String(buffer, 4, 8)
+    const brand = toUTF8String(buffer, 8, 12)
+    return 'ftyp' === ftype && brand in brandMap
+  },
+
+  calculate(buffer) {
+    // Based on https://nokiatech.github.io/heif/technical.html
+    const metaBox = findBox(buffer, 'meta', 0)
+    const iprpBox = metaBox && findBox(buffer, 'iprp', metaBox.offset + 12)
+    const ipcoBox = iprpBox && findBox(buffer, 'ipco', iprpBox.offset + 8)
+    const ispeBox = ipcoBox && findBox(buffer, 'ispe', ipcoBox.offset + 8)
+    if (ispeBox) {
+      return {
+        height: readUInt32BE(buffer, ispeBox.offset + 16),
+        width: readUInt32BE(buffer, ispeBox.offset + 12),
+        type: toUTF8String(buffer, 8, 12),
+      }
+    }
+    throw new TypeError('Invalid HEIF, no size found')
+  }
+}

package/src/image-size/types/icns.js

@@ -0,0 +1,112 @@
+import { toUTF8String, readUInt32BE } from './utils'
+
+/**
+ * ICNS Header
+ *
+ * | Offset | Size | Purpose                                                |
+ * | 0	    | 4    | Magic literal, must be "icns" (0x69, 0x63, 0x6e, 0x73) |
+ * | 4      | 4    | Length of file, in bytes, msb first.                   |
+ *
+ */
+const SIZE_HEADER = 4 + 4 // 8
+const FILE_LENGTH_OFFSET = 4 // MSB => BIG ENDIAN
+
+/**
+ * Image Entry
+ *
+ * | Offset | Size | Purpose                                                          |
+ * | 0	    | 4    | Icon type, see OSType below.                                     |
+ * | 4      | 4    | Length of data, in bytes (including type and length), msb first. |
+ * | 8      | n    | Icon data                                                        |
+ */
+const ENTRY_LENGTH_OFFSET = 4 // MSB => BIG ENDIAN
+
+const ICON_TYPE_SIZE = {
+  ICON: 32,
+  'ICN#': 32,
+  // m => 16 x 16
+  'icm#': 16,
+  icm4: 16,
+  icm8: 16,
+  // s => 16 x 16
+  'ics#': 16,
+  ics4: 16,
+  ics8: 16,
+  is32: 16,
+  s8mk: 16,
+  icp4: 16,
+  // l => 32 x 32
+  icl4: 32,
+  icl8: 32,
+  il32: 32,
+  l8mk: 32,
+  icp5: 32,
+  ic11: 32,
+  // h => 48 x 48
+  ich4: 48,
+  ich8: 48,
+  ih32: 48,
+  h8mk: 48,
+  // . => 64 x 64
+  icp6: 64,
+  ic12: 32,
+  // t => 128 x 128
+  it32: 128,
+  t8mk: 128,
+  ic07: 128,
+  // . => 256 x 256
+  ic08: 256,
+  ic13: 256,
+  // . => 512 x 512
+  ic09: 512,
+  ic14: 512,
+  // . => 1024 x 1024
+  ic10: 1024,
+}
+
+function readImageHeader(
+  input,
+  imageOffset,
+) {
+  const imageLengthOffset = imageOffset + ENTRY_LENGTH_OFFSET
+  return [
+    toUTF8String(input, imageOffset, imageLengthOffset),
+    readUInt32BE(input, imageLengthOffset),
+  ]
+}
+
+function getImageSize(type) {
+  const size = ICON_TYPE_SIZE[type]
+  return { width: size, height: size, type }
+}
+
+export const ICNS = {
+  validate: (input) => toUTF8String(input, 0, 4) === 'icns',
+
+  calculate(input) {
+    const inputLength = input.length
+    const fileLength = readUInt32BE(input, FILE_LENGTH_OFFSET)
+    let imageOffset = SIZE_HEADER
+
+    let imageHeader = readImageHeader(input, imageOffset)
+    let imageSize = getImageSize(imageHeader[0])
+    imageOffset += imageHeader[1]
+
+    if (imageOffset === fileLength) return imageSize
+
+    const result = {
+      height: imageSize.height,
+      images: [imageSize],
+      width: imageSize.width,
+    }
+
+    while (imageOffset < fileLength && imageOffset < inputLength) {
+      imageHeader = readImageHeader(input, imageOffset)
+      imageSize = getImageSize(imageHeader[0])
+      imageOffset += imageHeader[1]
+      result.images.push(imageSize)
+    }
+
+    return result
+  },
+}

package/src/image-size/types/ico.js

@@ -0,0 +1,74 @@
+import { readUInt16LE } from './utils'
+
+const TYPE_ICON = 1
+
+/**
+ * ICON Header
+ *
+ * | Offset | Size | Purpose |
+ * | 0	    | 2    | Reserved. Must always be 0.  |
+ * | 2      | 2    | Image type: 1 for icon (.ICO) image, 2 for cursor (.CUR) image. Other values are invalid. |
+ * | 4      | 2    | Number of images in the file. |
+ *
+ */
+const SIZE_HEADER = 2 + 2 + 2 // 6
+
+/**
+ * Image Entry
+ *
+ * | Offset | Size | Purpose |
+ * | 0	    | 1    | Image width in pixels. Can be any number between 0 and 255. Value 0 means width is 256 pixels. |
+ * | 1      | 1    | Image height in pixels. Can be any number between 0 and 255. Value 0 means height is 256 pixels. |
+ * | 2      | 1    | Number of colors in the color palette. Should be 0 if the image does not use a color palette. |
+ * | 3      | 1    | Reserved. Should be 0. |
+ * | 4      | 2    | ICO format: Color planes. Should be 0 or 1. |
+ * |        |      | CUR format: The horizontal coordinates of the hotspot in number of pixels from the left. |
+ * | 6      | 2    | ICO format: Bits per pixel. |
+ * |        |      | CUR format: The vertical coordinates of the hotspot in number of pixels from the top. |
+ * | 8      | 4    | The size of the image's data in bytes |
+ * | 12     | 4    | The offset of BMP or PNG data from the beginning of the ICO/CUR file |
+ *
+ */
+const SIZE_IMAGE_ENTRY = 1 + 1 + 1 + 1 + 2 + 2 + 4 + 4 // 16
+
+function getSizeFromOffset(input, offset) {
+  const value = input[offset]
+  return value === 0 ? 256 : value
+}
+
+function getImageSize(input, imageIndex) {
+  const offset = SIZE_HEADER + imageIndex * SIZE_IMAGE_ENTRY
+  return {
+    height: getSizeFromOffset(input, offset + 1),
+    width: getSizeFromOffset(input, offset),
+  }
+}
+
+export const ICO = {
+  validate(input) {
+    const reserved = readUInt16LE(input, 0)
+    const imageCount = readUInt16LE(input, 4)
+    if (reserved !== 0 || imageCount === 0) return false
+
+    const imageType = readUInt16LE(input, 2)
+    return imageType === TYPE_ICON
+  },
+
+  calculate(input) {
+    const nbImages = readUInt16LE(input, 4)
+    const imageSize = getImageSize(input, 0)
+
+    if (nbImages === 1) return imageSize
+
+    const imgs = [imageSize]
+    for (let imageIndex = 1; imageIndex < nbImages; imageIndex += 1) {
+      imgs.push(getImageSize(input, imageIndex))
+    }
+
+    return {
+      height: imageSize.height,
+      images: imgs,
+      width: imageSize.width,
+    }
+  },
+}

package/src/image-size/types/index.js

@@ -0,0 +1,43 @@
+// load all available handlers explicitely for browserify support
+import { BMP } from './bmp'
+import { CUR } from './cur'
+import { DDS } from './dds'
+import { GIF } from './gif'
+import { HEIF } from './heif'
+import { ICNS } from './icns'
+import { ICO } from './ico'
+import { J2C } from './j2c'
+import { JP2 } from './jp2'
+import { JPG } from './jpg'
+import { KTX } from './ktx'
+import { PNG } from './png'
+import { PNM } from './pnm'
+import { PSD } from './psd'
+import { SVG } from './svg'
+import { TGA } from './tga'
+import { TIFF } from './tiff'
+import { WEBP } from './webp'
+
+export const typeHandlers = new Map([
+  ['bmp', BMP],
+  ['cur', CUR],
+  ['dds', DDS],
+  ['gif', GIF],
+  ['heif', HEIF],
+  ['icns', ICNS],
+  ['ico', ICO],
+  ['j2c', J2C],
+  ['jp2', JP2],
+  ['jpg', JPG],
+  ['ktx', KTX],
+  ['png', PNG],
+  ['pnm', PNM],
+  ['psd', PSD],
+  ['svg', SVG],
+  ['tga', TGA],
+  ['tiff', TIFF],
+  ['webp', WEBP],
+])
+
+
+export const types = Array.from(typeHandlers.keys())

package/src/image-size/types/j2c.js

@@ -0,0 +1,11 @@
+import { toHexString, readUInt32BE } from './utils'
+
+export const J2C = {
+  // TODO: this doesn't seem right. SIZ marker doesn't have to be right after the SOC
+  validate: (input) => toHexString(input, 0, 4) === 'ff4fff51',
+
+  calculate: (input) => ({
+    height: readUInt32BE(input, 12),
+    width: readUInt32BE(input, 8),
+  }),
+}

package/src/image-size/types/jp2.js

@@ -0,0 +1,22 @@
+import { readUInt32BE, findBox } from './utils'
+
+export const JP2 = {
+  validate(input) {
+    if (readUInt32BE(input, 4) !== 0x6a502020 || readUInt32BE(input, 0) < 1)  return false
+    const ftypBox = findBox(input, 'ftyp', 0)
+    if (!ftypBox) return false
+    return readUInt32BE(input, ftypBox.offset + 4) === 0x66747970
+  },
+
+  calculate(input) {
+    const jp2hBox = findBox(input, 'jp2h', 0)
+    const ihdrBox = jp2hBox && findBox(input, 'ihdr', jp2hBox.offset + 8)
+    if (ihdrBox) {
+      return {
+        height: readUInt32BE(input, ihdrBox.offset + 8),
+        width: readUInt32BE(input, ihdrBox.offset + 12),
+      }
+    }
+    throw new TypeError('Unsupported JPEG 2000 format')
+  },
+}