@thi.ng/imago 0.2.0 → 0.3.0

package/ops/extend.js

@@ -0,0 +1,20 @@
+import { coerceColor, computeMargins } from "../units.js";
+const extendProc = async (spec, input, ctx) => {
+  const { bg, border, mode, ref, unit } = spec;
+  const sides = computeMargins(border, ctx.size, ref, unit);
+  const [left, right, top, bottom] = sides;
+  return [
+    input.extend({
+      left,
+      right,
+      top,
+      bottom,
+      background: coerceColor(bg || "#000"),
+      extendWith: mode
+    }),
+    true
+  ];
+};
+export {
+  extendProc
+};

package/ops/gamma.d.ts

@@ -0,0 +1,3 @@
+import type { Processor } from "../api.js";
+export declare const gammaProc: Processor;
+//# sourceMappingURL=gamma.d.ts.map

package/ops/gamma.js

@@ -0,0 +1,7 @@
+const gammaProc = async (spec, input) => {
+  const { gamma } = spec;
+  return [input.gamma(gamma, 1), false];
+};
+export {
+  gammaProc
+};

package/ops/grayscale.d.ts

@@ -0,0 +1,3 @@
+import type { Processor } from "../api.js";
+export declare const grayscaleProc: Processor;
+//# sourceMappingURL=grayscale.d.ts.map

package/ops/grayscale.js

@@ -0,0 +1,11 @@
+import { isNumber } from "@thi.ng/checks";
+const grayscaleProc = async (spec, input) => {
+  const { gamma } = spec;
+  if (gamma !== false) {
+    input = input.gamma(isNumber(gamma) ? gamma : void 0);
+  }
+  return [input.grayscale(), true];
+};
+export {
+  grayscaleProc
+};

package/ops/hsbl.d.ts

@@ -0,0 +1,3 @@
+import type { Processor } from "../api.js";
+export declare const hsblProc: Processor;
+//# sourceMappingURL=hsbl.d.ts.map

package/ops/hsbl.js

@@ -0,0 +1,15 @@
+const hsblProc = async (spec, input) => {
+  const { h = 0, s = 1, b = 1, l = 0 } = spec;
+  return [
+    input.modulate({
+      hue: h,
+      brightness: b,
+      saturation: s,
+      lightness: l * 255
+    }),
+    true
+  ];
+};
+export {
+  hsblProc
+};

package/ops/nest.d.ts

@@ -0,0 +1,3 @@
+import type { Processor } from "../api.js";
+export declare const nestProc: Processor;
+//# sourceMappingURL=nest.d.ts.map

package/ops/nest.js

@@ -0,0 +1,13 @@
+import { processImage } from "../proc.js";
+const nestProc = async (spec, input, ctx) => {
+  const { procs } = spec;
+  ctx.logger.debug("--- nest start ---");
+  await Promise.all(
+    procs.map((p) => processImage(input.clone(), p, ctx.opts, ctx))
+  );
+  ctx.logger.debug("--- nest end ---");
+  return [input, false];
+};
+export {
+  nestProc
+};

package/ops/output.d.ts

@@ -0,0 +1,3 @@
+import type { Processor } from "../api.js";
+export declare const outputProc: Processor;
+//# sourceMappingURL=output.d.ts.map

package/ops/output.js

@@ -0,0 +1,95 @@
+import { writeFile, writeJSON } from "@thi.ng/file-io";
+import { join, resolve } from "node:path";
+import { formatPath } from "../path.js";
+import { isPlainObject } from "@thi.ng/checks";
+const outputProc = async (spec, input, ctx) => {
+  const opts = spec;
+  const outDir = resolve(ctx.opts.outDir || ".");
+  let output = input.clone();
+  if (opts.raw) {
+    await outputRaw(opts, output, ctx, outDir);
+    return [input, false];
+  }
+  if (ctx.meta.exif && ctx.opts.keepEXIF) {
+    ctx.logger.warn(
+      "TODO injecting & merging EXIF in output still not supported"
+    );
+  }
+  if (Object.keys(ctx.exif).length) {
+    ctx.logger.debug("setting custom EXIF", ctx.exif);
+    output = output.withExif(ctx.exif);
+  }
+  if (ctx.iccFile && ctx.opts.keepICC) {
+    ctx.logger.debug("using stored ICC profile:", ctx.iccFile);
+    output = output.withIccProfile(ctx.iccFile);
+  }
+  let format = /\.(\w+)$/.exec(opts.path)?.[1];
+  switch (format) {
+    case "avif":
+      if (opts.avif)
+        output = output.avif(opts.avif);
+      break;
+    case "gif":
+      if (opts.gif)
+        output = output.gif(opts.gif);
+      break;
+    case "jpg":
+    case "jpeg":
+      if (opts.jpeg)
+        output = output.jpeg(opts.jpeg);
+      break;
+    case "jp2":
+      if (opts.jp2)
+        output = output.jp2(opts.jp2);
+      break;
+    case "jxl":
+      if (opts.jxl)
+        output = output.jxl(opts.jxl);
+      break;
+    case "png":
+      if (opts.png)
+        output = output.png(opts.png);
+      break;
+    case "tiff":
+      if (opts.tiff)
+        output = output.tiff(opts.tiff);
+      break;
+    case "webp":
+      if (opts.webp)
+        output = output.webp(opts.webp);
+      break;
+  }
+  if (opts.tile)
+    output = output.tile(opts.tile);
+  if (format)
+    output = output.toFormat(format);
+  const result = await output.toBuffer();
+  const path = join(
+    outDir,
+    formatPath(opts.path, ctx, spec, result)
+  );
+  writeFile(path, result, null, ctx.logger);
+  ctx.outputs[opts.id] = path;
+  return [input, false];
+};
+const outputRaw = async (opts, output, ctx, outDir) => {
+  const { alpha = false, meta = false } = isPlainObject(opts.raw) ? opts.raw : {};
+  if (alpha)
+    output = output.ensureAlpha();
+  const { data, info } = await output.raw().toBuffer({ resolveWithObject: true });
+  const path = join(outDir, formatPath(opts.path, ctx, opts, data));
+  writeFile(path, data, null, ctx.logger);
+  ctx.outputs[opts.id] = path;
+  if (meta) {
+    writeJSON(
+      path + ".meta.json",
+      { ...info, exif: ctx.exif },
+      void 0,
+      void 0,
+      ctx.logger
+    );
+  }
+};
+export {
+  outputProc
+};

package/ops/resize.d.ts

@@ -0,0 +1,3 @@
+import { type Processor } from "../api.js";
+export declare const resizeProc: Processor;
+//# sourceMappingURL=resize.d.ts.map

package/ops/resize.js

@@ -0,0 +1,20 @@
+import { GRAVITY_POSITION } from "../api.js";
+import { coerceColor, computeSize } from "../units.js";
+const resizeProc = async (spec, input, ctx) => {
+  const { bg, filter, fit, gravity, size, unit } = spec;
+  const [width, height] = computeSize(size, ctx.size, unit);
+  return [
+    input.resize({
+      width,
+      height,
+      fit,
+      kernel: filter,
+      position: gravity ? GRAVITY_POSITION[gravity] : void 0,
+      background: bg ? coerceColor(bg) : void 0
+    }),
+    true
+  ];
+};
+export {
+  resizeProc
+};

package/ops/rotate.d.ts

@@ -0,0 +1,3 @@
+import type { Processor } from "../api.js";
+export declare const rotateProc: Processor;
+//# sourceMappingURL=rotate.d.ts.map

package/ops/rotate.js

@@ -0,0 +1,12 @@
+import { coerceColor } from "../units.js";
+const rotateProc = async (spec, input, _) => {
+  const { angle, bg, flipX, flipY } = spec;
+  if (flipX)
+    input = input.flop();
+  if (flipY)
+    input = input.flip();
+  return [input.rotate(angle, { background: coerceColor(bg) }), true];
+};
+export {
+  rotateProc
+};

package/ops.d.ts

@@ -1,16 +1,16 @@
 import type { BlurSpec, CompSpec, CropSpec, DitherSpec, EXIFSpec, ExtendSpec, GammaSpec, GrayscaleSpec, HSBLSpec, NestSpec, OutputSpec, ProcSpec, ResizeSpec, RotateSpec } from "./api.js";
-export declare const defSpec: <T extends ProcSpec>(type: T["type"]) => (opts: Omit<T, "type">) => T;
-export declare const blur: (opts: Omit<BlurSpec, "type">) => BlurSpec;
-export declare const composite: (opts: Omit<CompSpec, "type">) => CompSpec;
-export declare const crop: (opts: Omit<CropSpec, "type">) => CropSpec;
-export declare const dither: (opts: Omit<DitherSpec, "type">) => DitherSpec;
-export declare const exif: (opts: Omit<EXIFSpec, "type">) => EXIFSpec;
-export declare const extend: (opts: Omit<ExtendSpec, "type">) => ExtendSpec;
-export declare const gamma: (opts: Omit<GammaSpec, "type">) => GammaSpec;
-export declare const grayscale: (opts: Omit<GrayscaleSpec, "type">) => GrayscaleSpec;
-export declare const hsbl: (opts: Omit<HSBLSpec, "type">) => HSBLSpec;
-export declare const nest: (opts: Omit<NestSpec, "type">) => NestSpec;
-export declare const output: (opts: Omit<OutputSpec, "type">) => OutputSpec;
-export declare const resize: (opts: Omit<ResizeSpec, "type">) => ResizeSpec;
-export declare const rotate: (opts: Omit<RotateSpec, "type">) => RotateSpec;
+export declare const defSpec: <T extends ProcSpec>(op: T["op"]) => (opts: Omit<T, "op">) => T;
+export declare const blur: (opts: Omit<BlurSpec, "op">) => BlurSpec;
+export declare const composite: (opts: Omit<CompSpec, "op">) => CompSpec;
+export declare const crop: (opts: Omit<CropSpec, "op">) => CropSpec;
+export declare const dither: (opts: Omit<DitherSpec, "op">) => DitherSpec;
+export declare const exif: (opts: Omit<EXIFSpec, "op">) => EXIFSpec;
+export declare const extend: (opts: Omit<ExtendSpec, "op">) => ExtendSpec;
+export declare const gamma: (opts: Omit<GammaSpec, "op">) => GammaSpec;
+export declare const grayscale: (opts: Omit<GrayscaleSpec, "op">) => GrayscaleSpec;
+export declare const hsbl: (opts: Omit<HSBLSpec, "op">) => HSBLSpec;
+export declare const nest: (opts: Omit<NestSpec, "op">) => NestSpec;
+export declare const output: (opts: Omit<OutputSpec, "op">) => OutputSpec;
+export declare const resize: (opts: Omit<ResizeSpec, "op">) => ResizeSpec;
+export declare const rotate: (opts: Omit<RotateSpec, "op">) => RotateSpec;
 //# sourceMappingURL=ops.d.ts.map

package/ops.js

@@ -1,4 +1,4 @@
-const defSpec = (type) => (opts) => ({ type, ...opts });
+const defSpec = (op) => (opts) => ({ op, ...opts });
 const blur = defSpec("blur");
 const composite = defSpec("composite");
 const crop = defSpec("crop");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thi.ng/imago",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "JSON & API-based declarative and extensible image processing trees/pipelines",
   "type": "module",
   "module": "./index.js",
@@ -44,6 +44,7 @@
     "@thi.ng/logger": "^3.0.2",
     "@thi.ng/pixel": "^6.1.11",
     "@thi.ng/pixel-dither": "^1.1.109",
+    "exif-reader": "^2.0.1",
     "sharp": "^0.33.2"
   },
   "devDependencies": {
@@ -95,7 +96,9 @@
   },
   "files": [
     "./*.js",
-    "./*.d.ts"
+    "./*.d.ts",
+    "layers",
+    "ops"
   ],
   "exports": {
     ".": {
@@ -121,5 +124,5 @@
     "status": "alpha",
     "year": 2024
   },
-  "gitHead": "16f2b92b5410bd35dcde6c2971c8e62783ebc472\n"
+  "gitHead": "c744c5f804ca763bc03163a41a0e150d8e7a9e54\n"
 }

package/proc.d.ts

@@ -1,17 +1,32 @@
 /// <reference types="node" />
 import sharp, { type Sharp } from "sharp";
-import { type CompLayer, type ImgProcCtx, type ImgProcOpts, type ProcSpec } from "./api.js";
+import type { ImgProcCtx, ImgProcOpts, ProcSpec } from "./api.js";
 export declare const LOGGER: import("@thi.ng/logger").ProxyLogger;
-export declare const processImage: (src: string | Buffer | Sharp, procs: ProcSpec[], opts?: Partial<ImgProcOpts>, parentCtx?: ImgProcCtx) => Promise<{
+/**
+ * Main API function. Takes an image input (file path, buffer or existing Sharp
+ * instance) and applies given processing pipeline specs in sequence. Returns a
+ * promise of final processed image, input metadata (if any) and an object of
+ * all written output paths (keyed by each output's {@link OutputSpec.id}). The
+ * process can be configured via provided options.
+ *
+ * @remarks
+ * The `parentCtx` arg is internal use only!
+ *
+ * @param src
+ * @param specs
+ * @param opts
+ * @param parentCtx
+ */
+export declare const processImage: (src: string | Buffer | Sharp, specs: ProcSpec[], opts?: Partial<ImgProcOpts>, parentCtx?: ImgProcCtx) => Promise<{
     img: sharp.Sharp;
     meta: sharp.Metadata;
-    outputs: string[];
+    outputs: Record<string, string>;
 }>;
 /**
  * Extensible polymorphic function performing a single image processing step.
  *
  * @remarks
- * The function returns a tuple of `[img, bake-flag]`. If the flag (2nd value)
+ * The function returns a tuple of `[img, bakeFlag]`. If the flag (2nd value)
  * is true, the returned image will be serialized/baked to an internal buffer
  * (also wiping any EXIF!) after the current processing step and then used as
  * input for the next processing step.
@@ -22,10 +37,13 @@ export declare const processImage: (src: string | Buffer | Sharp, procs: ProcSpe
  * function checks this flag after each processing step and its down to each
  * processor to determine if baking is required or not...
  *
+ * To add support for a custom operation/processor, call: `processor.add("myid",
+ * myProcessor)`. Note that registered IDs should be unique (but can also
+ * override existing impls).
+ *
  * @param spec
  * @param img
  * @param ctx
  **/
-export declare const process: import("@thi.ng/defmulti").MultiFn3<ProcSpec, sharp.Sharp, ImgProcCtx, Promise<[sharp.Sharp, boolean]>>;
-export declare const defLayer: import("@thi.ng/defmulti").MultiFn3<CompLayer, sharp.Sharp, ImgProcCtx, Promise<sharp.OverlayOptions>>;
+export declare const processor: import("@thi.ng/defmulti").MultiFn3<ProcSpec, sharp.Sharp, ImgProcCtx, Promise<[sharp.Sharp, boolean]>>;
 //# sourceMappingURL=proc.d.ts.map