@workglow/util 0.2.14 → 0.2.16

package/dist/media-browser.js

@@ -1,4 +1,4 @@
-// src/media/image.ts
+// src/media/imageTypes.ts
 function parseDataUri(dataUri) {
   const match = dataUri.match(/^data:([^;]+);base64,(.+)$/);
   if (!match) {
@@ -9,65 +9,545 @@ function parseDataUri(dataUri) {
     base64: match[2]
   };
 }
-// src/media/image.browser.ts
-var convertBlobToOffscreenCanvas = async (blob) => {
-  const img = await createImageBitmap(blob);
-  const ctx = new OffscreenCanvas(img.width, img.height).getContext("2d");
-  if (!ctx) {
-    throw new Error("Failed to get context.");
+// src/media/color.ts
+var HEX_PATTERN = /^#([0-9a-fA-F]{3,4}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/;
+function parseHexColor(hex) {
+  if (typeof hex !== "string" || !HEX_PATTERN.test(hex)) {
+    throw new Error(`Invalid hex color: ${String(hex)}`);
   }
-  ctx.drawImage(img, 0, 0);
-  return ctx.canvas;
-};
+  const body = hex.slice(1);
+  const double = (nibble) => parseInt(nibble + nibble, 16);
+  if (body.length === 3) {
+    return { r: double(body[0]), g: double(body[1]), b: double(body[2]), a: 255 };
+  }
+  if (body.length === 4) {
+    return {
+      r: double(body[0]),
+      g: double(body[1]),
+      b: double(body[2]),
+      a: double(body[3])
+    };
+  }
+  if (body.length === 6) {
+    return {
+      r: parseInt(body.slice(0, 2), 16),
+      g: parseInt(body.slice(2, 4), 16),
+      b: parseInt(body.slice(4, 6), 16),
+      a: 255
+    };
+  }
+  return {
+    r: parseInt(body.slice(0, 2), 16),
+    g: parseInt(body.slice(2, 4), 16),
+    b: parseInt(body.slice(4, 6), 16),
+    a: parseInt(body.slice(6, 8), 16)
+  };
+}
+var CHANNEL_MIN = 0;
+var CHANNEL_MAX = 255;
+function assertChannel(name, value) {
+  if (!Number.isInteger(value) || value < CHANNEL_MIN || value > CHANNEL_MAX) {
+    throw new Error(`Color channel ${name} out of range (0-255 integer): ${value}`);
+  }
+}
+function byteToHex(value) {
+  return value.toString(16).padStart(2, "0");
+}
+function toHexColor(c) {
+  assertChannel("r", c.r);
+  assertChannel("g", c.g);
+  assertChannel("b", c.b);
+  assertChannel("a", c.a);
+  const head = `#${byteToHex(c.r)}${byteToHex(c.g)}${byteToHex(c.b)}`;
+  return c.a === 255 ? head : `${head}${byteToHex(c.a)}`;
+}
+function isInRangeByte(value) {
+  return typeof value === "number" && Number.isInteger(value) && value >= 0 && value <= 255;
+}
+function isColorObject(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value))
+    return false;
+  const candidate = value;
+  if (!isInRangeByte(candidate.r))
+    return false;
+  if (!isInRangeByte(candidate.g))
+    return false;
+  if (!isInRangeByte(candidate.b))
+    return false;
+  if (candidate.a !== undefined && !isInRangeByte(candidate.a))
+    return false;
+  return true;
+}
+function isHexColor(value) {
+  return typeof value === "string" && HEX_PATTERN.test(value);
+}
+function resolveColor(value) {
+  if (typeof value === "string")
+    return parseHexColor(value);
+  if (!isColorObject(value)) {
+    throw new Error(`Invalid color value: ${JSON.stringify(value)}`);
+  }
+  return {
+    r: value.r,
+    g: value.g,
+    b: value.b,
+    a: value.a ?? 255
+  };
+}
+// src/media/imageRasterCodecRegistry.ts
+var codec = null;
+function registerImageRasterCodec(next) {
+  codec = next;
+}
+function getImageRasterCodec() {
+  if (!codec) {
+    throw new Error("Image raster codec is not registered. Ensure you import @workglow/tasks from the browser or Node entry (dist/browser.js or dist/node.js), or call registerImageRasterCodec() during startup.");
+  }
+  return codec;
+}
+// src/media/MediaRawImage.ts
+class MediaRawImage {
+  data;
+  width;
+  height;
+  channels;
+  constructor(data, width, height, channels) {
+    this.data = data;
+    this.width = width;
+    this.height = height;
+    this.channels = channels;
+  }
+}
+function isMediaRawImageShape(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  const v = value;
+  return v.data instanceof Uint8ClampedArray && typeof v.width === "number" && typeof v.height === "number" && typeof v.channels === "number";
+}
+// src/media/Image.ts
+var IMAGE_BRAND = Symbol.for("@workglow/util/media/Image");
+function parseDataUriMimeType(dataUri) {
+  const match = dataUri.match(/^data:([^;,]+)/);
+  const raw = match?.[1]?.trim();
+  return raw ? raw.toLowerCase() : "image/png";
+}
 function dataUriToBlob(dataUri) {
   const { mimeType, base64 } = parseDataUri(dataUri);
   const binary = atob(base64);
-  const bytes = Uint8Array.from(binary, (char) => char.charCodeAt(0));
-  const blob = new Blob([bytes], { type: mimeType });
-  return blob;
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0;i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return new Blob([bytes], { type: mimeType });
+}
+function toImageBinary(value) {
+  const ch = value.channels;
+  if (ch !== 1 && ch !== 3 && ch !== 4) {
+    throw new Error(`Image: unsupported channel count ${ch}`);
+  }
+  const data = coerceToUint8ClampedArray(value.data);
+  return {
+    data,
+    width: value.width,
+    height: value.height,
+    channels: ch,
+    rawChannels: value.rawChannels
+  };
 }
-async function convertImageDataToUseableForm(imageData, supports) {
-  if (imageData === null || imageData === undefined) {
-    throw new Error("Image data is null or undefined");
+function coerceToUint8ClampedArray(data) {
+  if (data instanceof Uint8ClampedArray) {
+    return data;
   }
-  if (supports.includes("ImageBitmap") && imageData instanceof ImageBitmap) {
-    return imageData;
+  if (ArrayBuffer.isView(data)) {
+    return new Uint8ClampedArray(data.buffer, data.byteOffset, data.byteLength);
   }
-  if (supports.includes("VideoFrame") && imageData instanceof VideoFrame) {
-    return imageData;
+  if (Array.isArray(data)) {
+    return Uint8ClampedArray.from(data);
   }
-  if (supports.includes("Blob") && imageData instanceof Blob) {
-    return imageData;
+  if (data && typeof data === "object") {
+    const obj = data;
+    const keys = Object.keys(obj);
+    if (keys.length > 0 && keys.every((k) => /^\d+$/.test(k))) {
+      const arr = new Uint8ClampedArray(keys.length);
+      for (let i = 0;i < keys.length; i++) {
+        arr[i] = Number(obj[String(i)]);
+      }
+      return arr;
+    }
   }
-  if (supports.includes("ImageBinary") && typeof imageData === "object" && "data" in imageData && "width" in imageData && "height" in imageData && "channels" in imageData) {
-    return imageData;
+  throw new Error("Image: pixel data is not array-like");
+}
+
+class Image {
+  [IMAGE_BRAND] = true;
+  source;
+  pixelsCache;
+  dataUriCache = new Map;
+  blobCache = new Map;
+  constructor(source) {
+    this.source = source;
   }
-  if (supports.includes("ImageBitmap") && imageData instanceof Blob) {
-    return createImageBitmap(imageData);
+  static fromDataUri(dataUri) {
+    if (!dataUri.startsWith("data:")) {
+      throw new Error("Image.fromDataUri: input must start with 'data:'");
+    }
+    return new Image({ kind: "dataUri", dataUri, mimeType: parseDataUriMimeType(dataUri) });
   }
-  if (supports.includes("OffscreenCanvas") && imageData instanceof Blob) {
-    return await convertBlobToOffscreenCanvas(imageData);
+  static fromPixels(pixels) {
+    return new Image({ kind: "pixels", pixels });
   }
-  if (supports.includes("ImageBitmap") && imageData instanceof OffscreenCanvas) {
-    return imageData.transferToImageBitmap();
+  static fromBlob(blob) {
+    return new Image({ kind: "blob", blob });
   }
-  if (supports.includes("ImageBitmap") && typeof imageData === "string") {
-    return createImageBitmap(dataUriToBlob(imageData));
+  static from(value) {
+    if (Image.is(value)) {
+      return value;
+    }
+    if (typeof value === "string" && value.startsWith("data:")) {
+      return Image.fromDataUri(value);
+    }
+    if (typeof Blob !== "undefined" && value instanceof Blob) {
+      return Image.fromBlob(value);
+    }
+    if (typeof ImageBitmap !== "undefined" && value instanceof ImageBitmap) {
+      return new Image({ kind: "bitmap", bitmap: value });
+    }
+    if (typeof VideoFrame !== "undefined" && value instanceof VideoFrame) {
+      return new Image({ kind: "videoFrame", frame: value });
+    }
+    if (typeof OffscreenCanvas !== "undefined" && value instanceof OffscreenCanvas) {
+      return new Image({ kind: "offscreenCanvas", canvas: value });
+    }
+    if (value && typeof value === "object" && "data" in value && "width" in value && "height" in value && "channels" in value) {
+      return Image.fromPixels(toImageBinary(value));
+    }
+    throw new Error(`Image.from: unsupported image value of type ${typeof value}`);
   }
-  if (supports.includes("OffscreenCanvas") && typeof imageData === "string") {
-    return convertBlobToOffscreenCanvas(dataUriToBlob(imageData));
+  static is(value) {
+    return typeof value === "object" && value !== null && value[IMAGE_BRAND] === true;
   }
-  if (supports.includes("Blob") && typeof imageData === "string") {
-    return dataUriToBlob(imageData);
+  static fromJSON(value) {
+    if (Image.is(value)) {
+      return value;
+    }
+    if (typeof value === "string" && value.startsWith("data:")) {
+      return Image.fromDataUri(value);
+    }
+    if (value && typeof value === "object" && value.unsynced === true) {
+      const kind = value.kind;
+      throw new Error(`Image.fromJSON: cannot reconstruct image from "unsynced" sentinel (kind=${String(kind)}); pixels were not materialized before serialization. Call await image.getPixels() before JSON.stringify.`);
+    }
+    if (value && typeof value === "object" && "data" in value && typeof value.width === "number" && typeof value.height === "number" && typeof value.channels === "number") {
+      const v = value;
+      return Image.fromPixels(toImageBinary({
+        data: v.data,
+        width: v.width,
+        height: v.height,
+        channels: v.channels
+      }));
+    }
+    throw new Error("Image.fromJSON: value does not match any known Image shape");
   }
-  if (supports.includes("DataUri") && typeof imageData === "string" && imageData.startsWith("data:")) {
-    return imageData;
+  get kind() {
+    return this.source.kind;
   }
-  throw new Error(`Unsupported image data type: ${typeof imageData} `);
+  get mimeType() {
+    if (this.source.kind === "dataUri")
+      return this.source.mimeType;
+    if (this.source.kind === "blob")
+      return this.source.blob.type || undefined;
+    return;
+  }
+  get width() {
+    if (this.source.kind === "pixels")
+      return this.source.pixels.width;
+    if (this.source.kind === "bitmap")
+      return this.source.bitmap.width;
+    if (this.source.kind === "offscreenCanvas")
+      return this.source.canvas.width;
+    if (this.source.kind === "videoFrame")
+      return this.source.frame.displayWidth;
+    return this.pixelsCache?.width;
+  }
+  get height() {
+    if (this.source.kind === "pixels")
+      return this.source.pixels.height;
+    if (this.source.kind === "bitmap")
+      return this.source.bitmap.height;
+    if (this.source.kind === "offscreenCanvas")
+      return this.source.canvas.height;
+    if (this.source.kind === "videoFrame")
+      return this.source.frame.displayHeight;
+    return this.pixelsCache?.height;
+  }
+  get channels() {
+    if (this.source.kind === "pixels")
+      return this.source.pixels.channels;
+    return this.pixelsCache?.channels;
+  }
+  async getPixels() {
+    if (this.pixelsCache)
+      return this.pixelsCache;
+    if (this.source.kind === "pixels") {
+      this.pixelsCache = this.source.pixels;
+      return this.pixelsCache;
+    }
+    if (this.source.kind === "dataUri") {
+      this.pixelsCache = await getImageRasterCodec().decodeDataUri(this.source.dataUri);
+      return this.pixelsCache;
+    }
+    if (this.source.kind === "blob") {
+      const dataUri = await blobToDataUri(this.source.blob);
+      this.pixelsCache = await getImageRasterCodec().decodeDataUri(dataUri);
+      return this.pixelsCache;
+    }
+    throw new Error(`Image.getPixels: browser-only source '${this.source.kind}' requires Image.browser augmentation`);
+  }
+  async getDataUri(mimeType = "image/png") {
+    if (this.source.kind === "dataUri") {
+      if (mimeType === this.source.mimeType) {
+        return this.source.dataUri;
+      }
+    }
+    const cached = this.dataUriCache.get(mimeType);
+    if (cached)
+      return cached;
+    const pixels = await this.getPixels();
+    const dataUri = await getImageRasterCodec().encodeDataUri(pixels, mimeType);
+    this.dataUriCache.set(mimeType, dataUri);
+    return dataUri;
+  }
+  async getBlob(mimeType = "image/png") {
+    if (this.source.kind === "blob" && (!mimeType || this.source.blob.type === mimeType)) {
+      return this.source.blob;
+    }
+    const cached = this.blobCache.get(mimeType);
+    if (cached)
+      return cached;
+    if (this.source.kind === "dataUri" && this.source.mimeType === mimeType) {
+      const blob2 = dataUriToBlob(this.source.dataUri);
+      this.blobCache.set(mimeType, blob2);
+      return blob2;
+    }
+    const dataUri = await this.getDataUri(mimeType);
+    const blob = dataUriToBlob(dataUri);
+    this.blobCache.set(mimeType, blob);
+    return blob;
+  }
+  async toFirstSupported(supports) {
+    const canonical = this.canonicalSupport();
+    if (canonical && supports.includes(canonical)) {
+      return this.currentSourceValue();
+    }
+    for (const want of supports) {
+      switch (want) {
+        case "ImageBinary":
+          return this.getPixels();
+        case "Blob":
+          return this.getBlob();
+        case "DataUri":
+          return this.getDataUri();
+        case "RawImage": {
+          const p = await this.getPixels();
+          return new MediaRawImage(p.data, p.width, p.height, p.channels);
+        }
+        case "ImageBitmap":
+        case "VideoFrame":
+        case "OffscreenCanvas": {
+          const asBrowser = this;
+          if (asBrowser.toFirstSupportedBrowser) {
+            const produced = await asBrowser.toFirstSupportedBrowser(want);
+            if (produced !== undefined)
+              return produced;
+          }
+          continue;
+        }
+        case "Sharp":
+          continue;
+      }
+    }
+    throw new Error(`Image.toFirstSupported: none of [${supports.join(", ")}] can be produced on this platform`);
+  }
+  toJSON() {
+    if (this.source.kind === "dataUri") {
+      return this.source.dataUri;
+    }
+    const pixels = this.source.kind === "pixels" ? this.source.pixels : this.pixelsCache;
+    if (pixels) {
+      return {
+        data: Array.from(pixels.data),
+        width: pixels.width,
+        height: pixels.height,
+        channels: pixels.channels
+      };
+    }
+    return { unsynced: true, kind: this.source.kind };
+  }
+  canonicalSupport() {
+    switch (this.source.kind) {
+      case "dataUri":
+        return "DataUri";
+      case "pixels":
+        return "ImageBinary";
+      case "blob":
+        return "Blob";
+      case "bitmap":
+        return "ImageBitmap";
+      case "videoFrame":
+        return "VideoFrame";
+      case "offscreenCanvas":
+        return "OffscreenCanvas";
+    }
+  }
+  getSource() {
+    return this.source;
+  }
+  setPixelsCache(pixels) {
+    this.pixelsCache = pixels;
+  }
+  currentSourceValue() {
+    switch (this.source.kind) {
+      case "dataUri":
+        return this.source.dataUri;
+      case "pixels":
+        return this.source.pixels;
+      case "blob":
+        return this.source.blob;
+      case "bitmap":
+        return this.source.bitmap;
+      case "videoFrame":
+        return this.source.frame;
+      case "offscreenCanvas":
+        return this.source.canvas;
+    }
+  }
+}
+async function blobToDataUri(blob) {
+  const buffer = await blob.arrayBuffer();
+  const bytes = new Uint8Array(buffer);
+  let binary = "";
+  const CHUNK = 8192;
+  for (let i = 0;i < bytes.byteLength; i += CHUNK) {
+    binary += String.fromCharCode(...bytes.subarray(i, i + CHUNK));
+  }
+  const mime = blob.type || "image/png";
+  return `data:${mime};base64,${btoa(binary)}`;
 }
+// src/media/Image.browser.ts
+Image.fromBitmap = function fromBitmap(bitmap) {
+  return Image.from(bitmap);
+};
+Image.fromVideoFrame = function fromVideoFrame(frame) {
+  return Image.from(frame);
+};
+Image.fromOffscreenCanvas = function fromOffscreenCanvas(canvas) {
+  return Image.from(canvas);
+};
+function rasterToImageData(image) {
+  const { width, height, channels, data } = image;
+  const id = new ImageData(width, height);
+  if (channels === 4) {
+    id.data.set(data);
+    return id;
+  }
+  if (channels === 3) {
+    for (let i = 0;i < width * height; i++) {
+      id.data[i * 4] = data[i * 3];
+      id.data[i * 4 + 1] = data[i * 3 + 1];
+      id.data[i * 4 + 2] = data[i * 3 + 2];
+      id.data[i * 4 + 3] = 255;
+    }
+    return id;
+  }
+  if (channels === 1) {
+    for (let i = 0;i < width * height; i++) {
+      const v = data[i];
+      id.data[i * 4] = v;
+      id.data[i * 4 + 1] = v;
+      id.data[i * 4 + 2] = v;
+      id.data[i * 4 + 3] = 255;
+    }
+    return id;
+  }
+  throw new Error(`Image.getImageData: unsupported channel count ${channels}`);
+}
+async function blobToOffscreenCanvas(blob) {
+  const bitmap = await createImageBitmap(blob);
+  try {
+    const canvas = new OffscreenCanvas(bitmap.width, bitmap.height);
+    const ctx = canvas.getContext("2d");
+    if (!ctx)
+      throw new Error("Image: failed to get 2D context on OffscreenCanvas");
+    ctx.drawImage(bitmap, 0, 0);
+    return canvas;
+  } finally {
+    bitmap.close();
+  }
+}
+Image.prototype.getImageData = async function getImageData() {
+  const pixels = await this.getPixels();
+  return rasterToImageData(pixels);
+};
+Image.prototype.getImageBitmap = async function getImageBitmap() {
+  const source = this.getSource();
+  if (source.kind === "bitmap")
+    return source.bitmap;
+  if (source.kind === "blob")
+    return createImageBitmap(source.blob);
+  if (source.kind === "offscreenCanvas") {
+    return source.canvas.transferToImageBitmap();
+  }
+  if (source.kind === "dataUri") {
+    return createImageBitmap(dataUriToBlob(source.dataUri));
+  }
+  const id = await this.getImageData();
+  return createImageBitmap(id);
+};
+Image.prototype.getVideoFrame = async function getVideoFrame() {
+  const source = this.getSource();
+  if (source.kind === "videoFrame")
+    return source.frame;
+  const bitmap = await this.getImageBitmap();
+  return new VideoFrame(bitmap, { timestamp: 0 });
+};
+Image.prototype.getOffscreenCanvas = async function getOffscreenCanvas() {
+  const source = this.getSource();
+  if (source.kind === "offscreenCanvas")
+    return source.canvas;
+  if (source.kind === "blob")
+    return blobToOffscreenCanvas(source.blob);
+  if (source.kind === "dataUri")
+    return blobToOffscreenCanvas(dataUriToBlob(source.dataUri));
+  const id = await this.getImageData();
+  const canvas = new OffscreenCanvas(id.width, id.height);
+  const ctx = canvas.getContext("2d");
+  if (!ctx)
+    throw new Error("Image.getOffscreenCanvas: failed to get 2D context");
+  ctx.putImageData(id, 0, 0);
+  return canvas;
+};
+Image.prototype.toFirstSupportedBrowser = async function toFirstSupportedBrowser(want) {
+  if (want === "ImageBitmap")
+    return this.getImageBitmap();
+  if (want === "VideoFrame")
+    return this.getVideoFrame();
+  if (want === "OffscreenCanvas")
+    return this.getOffscreenCanvas();
+  return;
+};
 export {
+  toHexColor,
+  resolveColor,
+  registerImageRasterCodec,
+  parseHexColor,
   parseDataUri,
-  convertImageDataToUseableForm
+  isMediaRawImageShape,
+  isHexColor,
+  isColorObject,
+  getImageRasterCodec,
+  dataUriToBlob,
+  MediaRawImage,
+  Image
 };
 
-//# debugId=7D52B745FDBDACD364756E2164756E21
+//# debugId=9670F06EEC7694A064756E2164756E21