@openfn/language-image-utils 1.0.0

package/configuration-schema.json

@@ -0,0 +1,7 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "properties": {},
+  "type": "object",
+  "additionalProperties": true,
+  "required": []
+}

package/dist/index.cjs

@@ -0,0 +1,314 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.js
+var src_exports = {};
+__export(src_exports, {
+  as: () => import_language_common2.as,
+  combine: () => import_language_common2.combine,
+  compress: () => compress,
+  cursor: () => import_language_common2.cursor,
+  dataPath: () => import_language_common2.dataPath,
+  dataValue: () => import_language_common2.dataValue,
+  dateFns: () => import_language_common2.dateFns,
+  default: () => src_default,
+  each: () => import_language_common2.each,
+  embedMetadata: () => embedMetadata,
+  field: () => import_language_common2.field,
+  fields: () => import_language_common2.fields,
+  fn: () => import_language_common2.fn,
+  fnIf: () => import_language_common2.fnIf,
+  getExifData: () => getExifData,
+  group: () => import_language_common2.group,
+  http: () => import_language_common2.http,
+  lastReferenceValue: () => import_language_common2.lastReferenceValue,
+  map: () => import_language_common2.map,
+  merge: () => import_language_common2.merge,
+  metadata: () => metadata,
+  resize: () => resize,
+  scrubEmojis: () => import_language_common2.scrubEmojis,
+  sourceValue: () => import_language_common2.sourceValue,
+  stripMetadata: () => stripMetadata,
+  util: () => import_language_common2.util
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/Adaptor.js
+var Adaptor_exports = {};
+__export(Adaptor_exports, {
+  as: () => import_language_common2.as,
+  combine: () => import_language_common2.combine,
+  compress: () => compress,
+  cursor: () => import_language_common2.cursor,
+  dataPath: () => import_language_common2.dataPath,
+  dataValue: () => import_language_common2.dataValue,
+  dateFns: () => import_language_common2.dateFns,
+  each: () => import_language_common2.each,
+  embedMetadata: () => embedMetadata,
+  field: () => import_language_common2.field,
+  fields: () => import_language_common2.fields,
+  fn: () => import_language_common2.fn,
+  fnIf: () => import_language_common2.fnIf,
+  getExifData: () => getExifData,
+  group: () => import_language_common2.group,
+  http: () => import_language_common2.http,
+  lastReferenceValue: () => import_language_common2.lastReferenceValue,
+  map: () => import_language_common2.map,
+  merge: () => import_language_common2.merge,
+  metadata: () => metadata,
+  resize: () => resize,
+  scrubEmojis: () => import_language_common2.scrubEmojis,
+  sourceValue: () => import_language_common2.sourceValue,
+  stripMetadata: () => stripMetadata,
+  util: () => import_language_common2.util
+});
+var import_util = require("@openfn/language-common/util");
+var import_language_common = require("@openfn/language-common");
+
+// src/Utils.js
+var import_jimp = require("jimp");
+var import_piexifjs = __toESM(require("piexifjs"), 1);
+function decodeBase64Image(base64ImgStr) {
+  const raw = base64ImgStr.includes(",") ? base64ImgStr.split(",")[1] : base64ImgStr;
+  return Buffer.from(raw, "base64");
+}
+var TAG_MAP = {};
+var REVERSE_TAG_MAP = {};
+for (const [ifd, tags] of Object.entries({
+  "0th": import_piexifjs.default.ImageIFD,
+  Exif: import_piexifjs.default.ExifIFD,
+  GPS: import_piexifjs.default.GPSIFD,
+  Interop: import_piexifjs.default.InteropIFD
+})) {
+  REVERSE_TAG_MAP[ifd] = {};
+  for (const [name, tagId] of Object.entries(tags)) {
+    TAG_MAP[name] = { ifd, tag: tagId };
+    REVERSE_TAG_MAP[ifd][tagId] = name;
+  }
+}
+var POINTER_TAGS = /* @__PURE__ */ new Set(["ExifTag", "GPSTag", "InteroperabilityTag"]);
+function buildExifBytes(kvPairs) {
+  var _a;
+  const ifdData = {};
+  for (const [key, value] of Object.entries(kvPairs)) {
+    const entry = TAG_MAP[key];
+    if (!entry)
+      throw new Error(`Unknown EXIF tag: "${key}"`);
+    ifdData[_a = entry.ifd] ?? (ifdData[_a] = {});
+    ifdData[entry.ifd][entry.tag] = key === "UserComment" ? `ASCII\0\0\0${value}` : value;
+  }
+  return import_piexifjs.default.dump(ifdData);
+}
+function injectExif(jpegBuffer, kvPairs) {
+  const exifBytes = buildExifBytes(kvPairs);
+  const withExif = import_piexifjs.default.insert(exifBytes, jpegBuffer.toString("binary"));
+  return Buffer.from(withExif, "binary");
+}
+async function resizeImage(inputBuffer, options = {}) {
+  const { width, height } = options;
+  const kb = (n) => `${(n / 1024).toFixed(1)}KB`;
+  console.log(`\u2192 input ${kb(inputBuffer.length)}, target ${width}\xD7${height}px`);
+  const image = await import_jimp.Jimp.read(inputBuffer);
+  const orientation = image.width > image.height ? "landscape" : image.width < image.height ? "portrait" : "square";
+  console.log(
+    `\u2192 source ${image.width}\xD7${image.height}px | ${kb(inputBuffer.length)} | ${orientation}`
+  );
+  image.resize({ w: width, h: height });
+  console.log(`\u2192 resized to ${width}\xD7${height}px`);
+  const buffer = await image.getBuffer("image/jpeg", { quality: 100 });
+  return { buffer, width, height };
+}
+function embedImageMetadata(inputBuffer, kvPairs) {
+  return { buffer: injectExif(inputBuffer, kvPairs) };
+}
+async function compressImage(inputBuffer, options = {}) {
+  const { maxBytes = 700 * 1024, minQuality = 20 } = options;
+  const kb = (n) => `${(n / 1024).toFixed(1)}KB`;
+  const image = await import_jimp.Jimp.read(inputBuffer);
+  let quality = 80;
+  let outBuffer;
+  while (true) {
+    outBuffer = await image.getBuffer("image/jpeg", { quality });
+    console.log(`\u2192 quality=${quality} \u2192 ${kb(outBuffer.length)}`);
+    if (outBuffer.length <= maxBytes || quality <= minQuality)
+      break;
+    quality -= 5;
+  }
+  const targetMet = outBuffer.length <= maxBytes;
+  console.log(
+    `\u2192 done \u2014 quality=${quality}, size=${kb(outBuffer.length)}` + (targetMet ? "" : ` (min quality reached, target ${kb(maxBytes)} not met)`)
+  );
+  return { buffer: outBuffer, size: outBuffer.length, quality };
+}
+async function stripImage(inputBuffer) {
+  const image = await import_jimp.Jimp.read(inputBuffer);
+  const buffer = await image.getBuffer("image/jpeg", { quality: 100 });
+  return { buffer };
+}
+async function getImageMetadata(inputBuffer) {
+  const image = await import_jimp.Jimp.read(inputBuffer);
+  const orientation = image.width > image.height ? "landscape" : image.width < image.height ? "portrait" : "square";
+  return {
+    width: image.width,
+    height: image.height,
+    orientation,
+    size: inputBuffer.length,
+    exif: getExifData(inputBuffer)
+  };
+}
+function getExifData(inputBuffer, options = {}) {
+  var _a;
+  const { mergeOutput = true } = options;
+  const exifObj = import_piexifjs.default.load(inputBuffer.toString("binary"));
+  const exifData = {};
+  for (const ifd in exifObj) {
+    if (ifd === "thumbnail" || !exifObj[ifd])
+      continue;
+    if (!mergeOutput)
+      exifData[ifd] = {};
+    for (const tag in exifObj[ifd]) {
+      const tagInfo = (_a = import_piexifjs.default.TAGS[ifd]) == null ? void 0 : _a[tag];
+      if (!tagInfo || tagInfo.type === "UNDEFINED")
+        continue;
+      if (POINTER_TAGS.has(tagInfo.name))
+        continue;
+      const target = mergeOutput ? exifData : exifData[ifd];
+      target[tagInfo.name] = exifObj[ifd][tag];
+    }
+  }
+  return exifData;
+}
+
+// src/Adaptor.js
+var import_language_common2 = require("@openfn/language-common");
+function resolveInput(raw) {
+  return Buffer.isBuffer(raw) ? raw : decodeBase64Image(raw);
+}
+function applyParseAs(result, parseAs) {
+  if (parseAs !== "base64")
+    return result;
+  const { buffer, ...rest } = result;
+  return { ...rest, base64: buffer.toString("base64") };
+}
+function resize(base64ImgOrBuffer, options = {}) {
+  return async (state) => {
+    const [resolvedImg, resolvedOptions] = (0, import_util.expandReferences)(
+      state,
+      base64ImgOrBuffer,
+      options
+    );
+    const result = await resizeImage(
+      resolveInput(resolvedImg),
+      resolvedOptions
+    );
+    return (0, import_language_common.composeNextState)(
+      state,
+      applyParseAs(result, resolvedOptions.parseAs)
+    );
+  };
+}
+function compress(base64ImgOrBuffer, options = {}) {
+  return async (state) => {
+    const [resolvedImg, resolvedOptions] = (0, import_util.expandReferences)(
+      state,
+      base64ImgOrBuffer,
+      options
+    );
+    const result = await compressImage(
+      resolveInput(resolvedImg),
+      resolvedOptions
+    );
+    return (0, import_language_common.composeNextState)(
+      state,
+      applyParseAs(result, resolvedOptions.parseAs)
+    );
+  };
+}
+function stripMetadata(base64ImgOrBuffer, options = {}) {
+  return async (state) => {
+    const [resolvedImg, resolvedOptions] = (0, import_util.expandReferences)(
+      state,
+      base64ImgOrBuffer,
+      options
+    );
+    const result = await stripImage(resolveInput(resolvedImg));
+    return (0, import_language_common.composeNextState)(
+      state,
+      applyParseAs(result, resolvedOptions.parseAs)
+    );
+  };
+}
+function embedMetadata(base64ImgOrBuffer, exifObj, options = {}) {
+  return async (state) => {
+    const [resolvedImg, resolvedExif, resolvedOptions] = (0, import_util.expandReferences)(
+      state,
+      base64ImgOrBuffer,
+      exifObj,
+      options
+    );
+    const result = embedImageMetadata(resolveInput(resolvedImg), resolvedExif);
+    return (0, import_language_common.composeNextState)(
+      state,
+      applyParseAs(result, resolvedOptions.parseAs)
+    );
+  };
+}
+function metadata(base64ImgOrBuffer) {
+  return async (state) => {
+    const [resolvedImg] = (0, import_util.expandReferences)(state, base64ImgOrBuffer);
+    const result = await getImageMetadata(resolveInput(resolvedImg));
+    return (0, import_language_common.composeNextState)(state, result);
+  };
+}
+
+// src/index.js
+var src_default = Adaptor_exports;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  as,
+  combine,
+  compress,
+  cursor,
+  dataPath,
+  dataValue,
+  dateFns,
+  each,
+  embedMetadata,
+  field,
+  fields,
+  fn,
+  fnIf,
+  getExifData,
+  group,
+  http,
+  lastReferenceValue,
+  map,
+  merge,
+  metadata,
+  resize,
+  scrubEmojis,
+  sourceValue,
+  stripMetadata,
+  util
+});

package/dist/index.js

@@ -0,0 +1,284 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/Adaptor.js
+var Adaptor_exports = {};
+__export(Adaptor_exports, {
+  as: () => as,
+  combine: () => combine,
+  compress: () => compress,
+  cursor: () => cursor,
+  dataPath: () => dataPath,
+  dataValue: () => dataValue,
+  dateFns: () => dateFns,
+  each: () => each,
+  embedMetadata: () => embedMetadata,
+  field: () => field,
+  fields: () => fields,
+  fn: () => fn,
+  fnIf: () => fnIf,
+  getExifData: () => getExifData,
+  group: () => group,
+  http: () => http,
+  lastReferenceValue: () => lastReferenceValue,
+  map: () => map,
+  merge: () => merge,
+  metadata: () => metadata,
+  resize: () => resize,
+  scrubEmojis: () => scrubEmojis,
+  sourceValue: () => sourceValue,
+  stripMetadata: () => stripMetadata,
+  util: () => util
+});
+import { expandReferences } from "@openfn/language-common/util";
+import { composeNextState } from "@openfn/language-common";
+
+// src/Utils.js
+import { Jimp } from "jimp";
+import piexif from "piexifjs";
+function decodeBase64Image(base64ImgStr) {
+  const raw = base64ImgStr.includes(",") ? base64ImgStr.split(",")[1] : base64ImgStr;
+  return Buffer.from(raw, "base64");
+}
+var TAG_MAP = {};
+var REVERSE_TAG_MAP = {};
+for (const [ifd, tags] of Object.entries({
+  "0th": piexif.ImageIFD,
+  Exif: piexif.ExifIFD,
+  GPS: piexif.GPSIFD,
+  Interop: piexif.InteropIFD
+})) {
+  REVERSE_TAG_MAP[ifd] = {};
+  for (const [name, tagId] of Object.entries(tags)) {
+    TAG_MAP[name] = { ifd, tag: tagId };
+    REVERSE_TAG_MAP[ifd][tagId] = name;
+  }
+}
+var POINTER_TAGS = /* @__PURE__ */ new Set(["ExifTag", "GPSTag", "InteroperabilityTag"]);
+function buildExifBytes(kvPairs) {
+  var _a;
+  const ifdData = {};
+  for (const [key, value] of Object.entries(kvPairs)) {
+    const entry = TAG_MAP[key];
+    if (!entry)
+      throw new Error(`Unknown EXIF tag: "${key}"`);
+    ifdData[_a = entry.ifd] ?? (ifdData[_a] = {});
+    ifdData[entry.ifd][entry.tag] = key === "UserComment" ? `ASCII\0\0\0${value}` : value;
+  }
+  return piexif.dump(ifdData);
+}
+function injectExif(jpegBuffer, kvPairs) {
+  const exifBytes = buildExifBytes(kvPairs);
+  const withExif = piexif.insert(exifBytes, jpegBuffer.toString("binary"));
+  return Buffer.from(withExif, "binary");
+}
+async function resizeImage(inputBuffer, options = {}) {
+  const { width, height } = options;
+  const kb = (n) => `${(n / 1024).toFixed(1)}KB`;
+  console.log(`\u2192 input ${kb(inputBuffer.length)}, target ${width}\xD7${height}px`);
+  const image = await Jimp.read(inputBuffer);
+  const orientation = image.width > image.height ? "landscape" : image.width < image.height ? "portrait" : "square";
+  console.log(
+    `\u2192 source ${image.width}\xD7${image.height}px | ${kb(inputBuffer.length)} | ${orientation}`
+  );
+  image.resize({ w: width, h: height });
+  console.log(`\u2192 resized to ${width}\xD7${height}px`);
+  const buffer = await image.getBuffer("image/jpeg", { quality: 100 });
+  return { buffer, width, height };
+}
+function embedImageMetadata(inputBuffer, kvPairs) {
+  return { buffer: injectExif(inputBuffer, kvPairs) };
+}
+async function compressImage(inputBuffer, options = {}) {
+  const { maxBytes = 700 * 1024, minQuality = 20 } = options;
+  const kb = (n) => `${(n / 1024).toFixed(1)}KB`;
+  const image = await Jimp.read(inputBuffer);
+  let quality = 80;
+  let outBuffer;
+  while (true) {
+    outBuffer = await image.getBuffer("image/jpeg", { quality });
+    console.log(`\u2192 quality=${quality} \u2192 ${kb(outBuffer.length)}`);
+    if (outBuffer.length <= maxBytes || quality <= minQuality)
+      break;
+    quality -= 5;
+  }
+  const targetMet = outBuffer.length <= maxBytes;
+  console.log(
+    `\u2192 done \u2014 quality=${quality}, size=${kb(outBuffer.length)}` + (targetMet ? "" : ` (min quality reached, target ${kb(maxBytes)} not met)`)
+  );
+  return { buffer: outBuffer, size: outBuffer.length, quality };
+}
+async function stripImage(inputBuffer) {
+  const image = await Jimp.read(inputBuffer);
+  const buffer = await image.getBuffer("image/jpeg", { quality: 100 });
+  return { buffer };
+}
+async function getImageMetadata(inputBuffer) {
+  const image = await Jimp.read(inputBuffer);
+  const orientation = image.width > image.height ? "landscape" : image.width < image.height ? "portrait" : "square";
+  return {
+    width: image.width,
+    height: image.height,
+    orientation,
+    size: inputBuffer.length,
+    exif: getExifData(inputBuffer)
+  };
+}
+function getExifData(inputBuffer, options = {}) {
+  var _a;
+  const { mergeOutput = true } = options;
+  const exifObj = piexif.load(inputBuffer.toString("binary"));
+  const exifData = {};
+  for (const ifd in exifObj) {
+    if (ifd === "thumbnail" || !exifObj[ifd])
+      continue;
+    if (!mergeOutput)
+      exifData[ifd] = {};
+    for (const tag in exifObj[ifd]) {
+      const tagInfo = (_a = piexif.TAGS[ifd]) == null ? void 0 : _a[tag];
+      if (!tagInfo || tagInfo.type === "UNDEFINED")
+        continue;
+      if (POINTER_TAGS.has(tagInfo.name))
+        continue;
+      const target = mergeOutput ? exifData : exifData[ifd];
+      target[tagInfo.name] = exifObj[ifd][tag];
+    }
+  }
+  return exifData;
+}
+
+// src/Adaptor.js
+import {
+  as,
+  combine,
+  cursor,
+  dataPath,
+  dataValue,
+  dateFns,
+  each,
+  field,
+  fields,
+  fn,
+  fnIf,
+  group,
+  lastReferenceValue,
+  map,
+  merge,
+  scrubEmojis,
+  sourceValue,
+  util,
+  http
+} from "@openfn/language-common";
+function resolveInput(raw) {
+  return Buffer.isBuffer(raw) ? raw : decodeBase64Image(raw);
+}
+function applyParseAs(result, parseAs) {
+  if (parseAs !== "base64")
+    return result;
+  const { buffer, ...rest } = result;
+  return { ...rest, base64: buffer.toString("base64") };
+}
+function resize(base64ImgOrBuffer, options = {}) {
+  return async (state) => {
+    const [resolvedImg, resolvedOptions] = expandReferences(
+      state,
+      base64ImgOrBuffer,
+      options
+    );
+    const result = await resizeImage(
+      resolveInput(resolvedImg),
+      resolvedOptions
+    );
+    return composeNextState(
+      state,
+      applyParseAs(result, resolvedOptions.parseAs)
+    );
+  };
+}
+function compress(base64ImgOrBuffer, options = {}) {
+  return async (state) => {
+    const [resolvedImg, resolvedOptions] = expandReferences(
+      state,
+      base64ImgOrBuffer,
+      options
+    );
+    const result = await compressImage(
+      resolveInput(resolvedImg),
+      resolvedOptions
+    );
+    return composeNextState(
+      state,
+      applyParseAs(result, resolvedOptions.parseAs)
+    );
+  };
+}
+function stripMetadata(base64ImgOrBuffer, options = {}) {
+  return async (state) => {
+    const [resolvedImg, resolvedOptions] = expandReferences(
+      state,
+      base64ImgOrBuffer,
+      options
+    );
+    const result = await stripImage(resolveInput(resolvedImg));
+    return composeNextState(
+      state,
+      applyParseAs(result, resolvedOptions.parseAs)
+    );
+  };
+}
+function embedMetadata(base64ImgOrBuffer, exifObj, options = {}) {
+  return async (state) => {
+    const [resolvedImg, resolvedExif, resolvedOptions] = expandReferences(
+      state,
+      base64ImgOrBuffer,
+      exifObj,
+      options
+    );
+    const result = embedImageMetadata(resolveInput(resolvedImg), resolvedExif);
+    return composeNextState(
+      state,
+      applyParseAs(result, resolvedOptions.parseAs)
+    );
+  };
+}
+function metadata(base64ImgOrBuffer) {
+  return async (state) => {
+    const [resolvedImg] = expandReferences(state, base64ImgOrBuffer);
+    const result = await getImageMetadata(resolveInput(resolvedImg));
+    return composeNextState(state, result);
+  };
+}
+
+// src/index.js
+var src_default = Adaptor_exports;
+export {
+  as,
+  combine,
+  compress,
+  cursor,
+  dataPath,
+  dataValue,
+  dateFns,
+  src_default as default,
+  each,
+  embedMetadata,
+  field,
+  fields,
+  fn,
+  fnIf,
+  getExifData,
+  group,
+  http,
+  lastReferenceValue,
+  map,
+  merge,
+  metadata,
+  resize,
+  scrubEmojis,
+  sourceValue,
+  stripMetadata,
+  util
+};

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@openfn/language-image-utils",
+  "version": "1.0.0",
+  "description": "OpenFn image-utils adaptor",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./types/index.d.ts",
+      "require": "./dist/index.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "author": "Open Function Group",
+  "license": "LGPLv3",
+  "files": [
+    "dist/",
+    "types/",
+    "ast.json",
+    "configuration-schema.json"
+  ],
+  "dependencies": {
+    "jimp": "^1.6.0",
+    "piexifjs": "^1.0.6",
+    "@openfn/language-common": "3.3.4"
+  },
+  "devDependencies": {
+    "assertion-error": "2.0.0",
+    "chai": "4.3.6",
+    "deep-eql": "4.1.1",
+    "mocha": "^10.7.3",
+    "rimraf": "3.0.2"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/openfn/adaptors.git"
+  },
+  "types": "types/index.d.ts",
+  "main": "dist/index.cjs",
+  "scripts": {
+    "build": "pnpm clean && build-adaptor image-utils",
+    "test": "mocha test/*.test.js --experimental-specifier-resolution=node --no-warnings --timeout 30000",
+    "test:watch": "mocha test/*.test.js -w --experimental-specifier-resolution=node --no-warnings --timeout 30000",
+    "test:integration": "mocha --experimental-specifier-resolution=node --no-warnings test/integration.js",
+    "clean": "rimraf dist types docs",
+    "pack": "pnpm pack --pack-destination ../../dist",
+    "lint": "eslint src",
+    "benchmark": "echo 'benchmark removed — jsquash dependency dropped'"
+  }
+}