@field/cascade 0.10.0 → 0.12.0

package/dist/cli/chunk-WGKPJZDY.js

@@ -0,0 +1,364 @@
+// packages/runtime/src/builtins/image/planar.ts
+var Planar = class _Planar {
+  constructor(width, height, channels) {
+    pixelCount(width, height);
+    this.width = width;
+    this.height = height;
+    this.channels = channels;
+  }
+  static grayscale(width, height) {
+    return new _Planar(width, height, [new Float32Array(pixelCount(width, height))]);
+  }
+  static rgba(width, height) {
+    const size = pixelCount(width, height);
+    return new _Planar(width, height, [
+      new Float32Array(size),
+      new Float32Array(size),
+      new Float32Array(size),
+      new Float32Array(size)
+    ]);
+  }
+  /** From 8-bit RGBA, unpremultiplied. */
+  static fromPixels(pixels) {
+    const { width, height, data } = pixels;
+    const size = width * height;
+    const r = new Float32Array(size);
+    const g = new Float32Array(size);
+    const b = new Float32Array(size);
+    const a = new Float32Array(size);
+    const inv255 = 1 / 255;
+    for (let i = 0; i < size; i++) {
+      const idx = i * 4;
+      r[i] = data[idx] * inv255;
+      g[i] = data[idx + 1] * inv255;
+      b[i] = data[idx + 2] * inv255;
+      a[i] = data[idx + 3] * inv255;
+    }
+    return new _Planar(width, height, [r, g, b, a]);
+  }
+  static solid(width, height, color) {
+    const buffer = _Planar.rgba(width, height);
+    buffer.fill(0, color.r);
+    buffer.fill(1, color.g);
+    buffer.fill(2, color.b);
+    buffer.fill(3, color.a ?? 1);
+    return buffer;
+  }
+  get channelCount() {
+    return this.channels.length;
+  }
+  get pixelCount() {
+    return this.width * this.height;
+  }
+  fill(channel, value) {
+    this.channels[channel].fill(value);
+  }
+  clone() {
+    return new _Planar(this.width, this.height, this.channels.map((channel) => new Float32Array(channel)));
+  }
+  emptyClone() {
+    return new _Planar(this.width, this.height, this.channels.map(() => new Float32Array(this.pixelCount)));
+  }
+  toRGBA() {
+    if (this.channels.length >= 4) return this.clone();
+    const result = _Planar.rgba(this.width, this.height);
+    const [r, g = r, b = r] = this.channels.length === 1 ? [this.channels[0]] : this.channels;
+    result.channels[0].set(r);
+    result.channels[1].set(g);
+    result.channels[2].set(b);
+    result.channels[3].fill(1);
+    return result;
+  }
+  /** To 8-bit RGBA: a grey image fills red, green and blue, and no alpha is opaque. */
+  toPixels() {
+    const size = this.pixelCount;
+    const data = new Uint8ClampedArray(size * 4);
+    const r = this.channels[0];
+    const g = this.channels.length > 1 ? this.channels[1] : r;
+    const b = this.channels.length > 2 ? this.channels[2] : r;
+    const a = this.channels.length > 3 ? this.channels[3] : null;
+    for (let i = 0; i < size; i++) {
+      const idx = i << 2;
+      let v = r[i] * 255 + 0.5 | 0;
+      data[idx] = v < 0 ? 0 : v > 255 ? 255 : v;
+      v = g[i] * 255 + 0.5 | 0;
+      data[idx + 1] = v < 0 ? 0 : v > 255 ? 255 : v;
+      v = b[i] * 255 + 0.5 | 0;
+      data[idx + 2] = v < 0 ? 0 : v > 255 ? 255 : v;
+      if (a) {
+        v = a[i] * 255 + 0.5 | 0;
+        data[idx + 3] = v < 0 ? 0 : v > 255 ? 255 : v;
+      } else {
+        data[idx + 3] = 255;
+      }
+    }
+    return { width: this.width, height: this.height, data };
+  }
+  /** Bilinear, clamped at the edges (or wrapped). */
+  sample(x, y, channel = 0, wrap = false) {
+    const x0 = Math.floor(x);
+    const y0 = Math.floor(y);
+    const fx = x - x0;
+    const fy = y - y0;
+    const ch = this.channels[channel];
+    const w = this.width;
+    const h = this.height;
+    const px0 = edge(x0, w, wrap);
+    const px1 = edge(x0 + 1, w, wrap);
+    const py0 = edge(y0, h, wrap);
+    const py1 = edge(y0 + 1, h, wrap);
+    const v0 = ch[py0 * w + px0] * (1 - fx) + ch[py0 * w + px1] * fx;
+    const v1 = ch[py1 * w + px0] * (1 - fx) + ch[py1 * w + px1] * fx;
+    return v0 * (1 - fy) + v1 * fy;
+  }
+};
+function edge(coord, max, wrap) {
+  return wrap ? (coord % max + max) % max : Math.max(0, Math.min(max - 1, coord));
+}
+function pixelCount(width, height) {
+  const count = width * height;
+  if (!Number.isSafeInteger(width) || !Number.isSafeInteger(height) || width < 1 || height < 1 || !Number.isSafeInteger(count)) {
+    throw new RangeError(`Image dimensions must be positive safe integers; received ${width}\xD7${height}`);
+  }
+  return count;
+}
+function resample(source, width, height) {
+  const result = Planar.rgba(width, height);
+  const scaleX = source.width / width;
+  const scaleY = source.height / height;
+  for (let c = 0; c < Math.min(source.channelCount, 4); c++) {
+    const dst = result.channels[c];
+    for (let y = 0; y < height; y++) {
+      for (let x = 0; x < width; x++) {
+        dst[y * width + x] = source.sample(x * scaleX, y * scaleY, c);
+      }
+    }
+  }
+  if (source.channelCount < 4) result.fill(3, 1);
+  return result;
+}
+function resolveOutputSize(mode, inputs, customSize) {
+  const valid = inputs.filter((buffer) => buffer !== null);
+  const area = (buffer) => buffer.width * buffer.height;
+  switch (mode) {
+    case "input":
+    case "input1":
+      if (valid[0]) return { width: valid[0].width, height: valid[0].height };
+      break;
+    case "input2": {
+      const chosen = valid[1] ?? valid[0];
+      if (chosen) return { width: chosen.width, height: chosen.height };
+      break;
+    }
+    case "largest":
+    case "smallest":
+      if (valid.length > 0) {
+        let best = valid[0];
+        let bestArea = mode === "largest" ? 0 : Infinity;
+        for (const buffer of valid) {
+          if (mode === "largest" ? area(buffer) > bestArea : area(buffer) < bestArea) {
+            bestArea = area(buffer);
+            best = buffer;
+          }
+        }
+        return { width: best.width, height: best.height };
+      }
+      break;
+    case "custom":
+      if (customSize) return { width: customSize[0], height: customSize[1] };
+      break;
+  }
+  if (valid[0]) return { width: valid[0].width, height: valid[0].height };
+  return { width: 512, height: 512 };
+}
+function resizeToFit(source, targetWidth, targetHeight, fitMode = "fill") {
+  if (source.width === targetWidth && source.height === targetHeight) return source;
+  const result = Planar.rgba(targetWidth, targetHeight);
+  const srcAspect = source.width / source.height;
+  const dstAspect = targetWidth / targetHeight;
+  let srcX = 0, srcY = 0, srcW = source.width, srcH = source.height;
+  let dstX = 0, dstY = 0, dstW = targetWidth, dstH = targetHeight;
+  const black = () => {
+    result.fill(0, 0);
+    result.fill(1, 0);
+    result.fill(2, 0);
+    result.fill(3, 1);
+  };
+  switch (fitMode) {
+    case "fill":
+      if (srcAspect > dstAspect) {
+        srcW = Math.round(source.height * dstAspect);
+        srcX = Math.round((source.width - srcW) / 2);
+      } else {
+        srcH = Math.round(source.width / dstAspect);
+        srcY = Math.round((source.height - srcH) / 2);
+      }
+      break;
+    case "fit":
+      if (srcAspect > dstAspect) {
+        dstH = Math.round(targetWidth / srcAspect);
+        dstY = Math.round((targetHeight - dstH) / 2);
+      } else {
+        dstW = Math.round(targetHeight * srcAspect);
+        dstX = Math.round((targetWidth - dstW) / 2);
+      }
+      black();
+      break;
+    case "stretch":
+      break;
+    case "native":
+      dstW = Math.min(source.width, targetWidth);
+      dstH = Math.min(source.height, targetHeight);
+      srcW = dstW;
+      srcH = dstH;
+      dstX = Math.round((targetWidth - dstW) / 2);
+      dstY = Math.round((targetHeight - dstH) / 2);
+      srcX = Math.round((source.width - srcW) / 2);
+      srcY = Math.round((source.height - srcH) / 2);
+      black();
+      break;
+  }
+  const scaleX = srcW / dstW;
+  const scaleY = srcH / dstH;
+  for (let c = 0; c < Math.min(source.channelCount, 4); c++) {
+    const dst = result.channels[c];
+    for (let y = 0; y < dstH; y++) {
+      for (let x = 0; x < dstW; x++) {
+        dst[(dstY + y) * targetWidth + (dstX + x)] = source.sample(srcX + x * scaleX, srcY + y * scaleY, c);
+      }
+    }
+  }
+  if (source.channelCount < 4 && fitMode !== "fit" && fitMode !== "native") {
+    const alpha = result.channels[3];
+    for (let y = 0; y < dstH; y++) {
+      for (let x = 0; x < dstW; x++) alpha[(dstY + y) * targetWidth + (dstX + x)] = 1;
+    }
+  }
+  return result;
+}
+
+// packages/runtime/src/builtins/image/io.ts
+var NO_CANVAS = 'cascade.image: this host has no canvas. In a browser this needs OffscreenCanvas; headless, Cascade installs @napi-rs/canvas before a run (install it with "npm install @napi-rs/canvas" if it is missing).';
+function canvasGlobals() {
+  return globalThis;
+}
+function surface(width, height) {
+  const Canvas = canvasGlobals().OffscreenCanvas;
+  if (!Canvas) throw new Error(NO_CANVAS);
+  const canvas = new Canvas(width, height);
+  const context = canvas.getContext("2d", { willReadFrequently: true });
+  if (!context) throw new Error("cascade.image: the canvas has no 2D context");
+  return { canvas, context };
+}
+function assetsOf(context) {
+  const assets = context.capabilities.assets;
+  if (!assets) throw new Error(`${context.nodeId}: this host gives cascade.image nodes no assets capability`);
+  return assets;
+}
+function imageReference(value) {
+  if (typeof value === "string") return value ? { path: value } : null;
+  const path = value?.path;
+  return typeof path === "string" && path ? { path } : null;
+}
+async function decodePixels(bytes) {
+  const globals = canvasGlobals();
+  if (!globals.createImageBitmap || !globals.Blob) throw new Error(NO_CANVAS);
+  const bitmap = await globals.createImageBitmap(new globals.Blob([bytes]));
+  try {
+    const { width, height } = bitmap;
+    if (!width || !height) throw new Error("cascade.image: could not decode the image data");
+    const { context } = surface(width, height);
+    context.drawImage(bitmap, 0, 0);
+    return { width, height, data: context.getImageData(0, 0, width, height).data };
+  } finally {
+    bitmap.close?.();
+  }
+}
+function readPixelsFromCanvas(canvas) {
+  const context = canvas.getContext("2d", { willReadFrequently: true });
+  if (!context) throw new Error("cascade.image: the canvas has no 2D context");
+  return { width: canvas.width, height: canvas.height, data: context.getImageData(0, 0, canvas.width, canvas.height).data };
+}
+async function readPixels(context, ref) {
+  const assets = assetsOf(context);
+  const kept = assets.imagePixels?.(ref);
+  if (kept) return kept;
+  return decodePixels(await assets.read(ref, { signal: context.signal }));
+}
+async function readPlanar(context, value) {
+  const ref = imageReference(value);
+  return ref ? Planar.fromPixels(await readPixels(context, ref)) : null;
+}
+async function encodePng(pixels) {
+  const globals = canvasGlobals();
+  if (!globals.ImageData) throw new Error(NO_CANVAS);
+  const { canvas, context } = surface(pixels.width, pixels.height);
+  context.putImageData(new globals.ImageData(pixels.data, pixels.width, pixels.height), 0, 0);
+  const blob = await canvas.convertToBlob({ type: "image/png" });
+  return new Uint8Array(await blob.arrayBuffer());
+}
+async function writePixels(context, pixels) {
+  const assets = assetsOf(context);
+  const name = `${context.nodeId}.png`;
+  const options = { signal: context.signal };
+  const stored = assets.keepImage ? await assets.keepImage(pixels, { suggestedName: name }, options) : await assets.write(await encodePng(pixels), { mediaType: "image/png", suggestedName: name }, options);
+  return { path: stored.path, size: [pixels.width, pixels.height], channels: "rgba", depth: "u8", space: "srgb" };
+}
+async function output(context, image) {
+  context.outputs.image.set(await writePixels(context, image.toPixels()));
+}
+function normalizeColor(input) {
+  if (input && typeof input === "object" && !Array.isArray(input) && "r" in input && "g" in input && "b" in input) {
+    const color = input;
+    const unit = color.r <= 1 && color.g <= 1 && color.b <= 1;
+    return {
+      r: unit ? color.r : color.r / 255,
+      g: unit ? color.g : color.g / 255,
+      b: unit ? color.b : color.b / 255,
+      a: color.a !== void 0 ? unit ? color.a : color.a / 255 : 1
+    };
+  }
+  if (Array.isArray(input)) {
+    const unit = input.every((value) => value <= 1);
+    return {
+      r: unit ? input[0] : input[0] / 255,
+      g: unit ? input[1] : input[1] / 255,
+      b: unit ? input[2] : input[2] / 255,
+      a: input[3] !== void 0 ? unit ? input[3] : input[3] / 255 : 1
+    };
+  }
+  if (typeof input === "string") {
+    const rgb = input.match(/rgb\s*\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\)/);
+    if (rgb) return { r: parseInt(rgb[1], 10) / 255, g: parseInt(rgb[2], 10) / 255, b: parseInt(rgb[3], 10) / 255, a: 1 };
+    const hex = input.replace("#", "");
+    if (hex.length === 3 || hex.length === 6) {
+      const expanded = hex.length === 3 ? hex.split("").map((digit) => digit + digit).join("") : hex;
+      const parts = /^([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(expanded);
+      if (parts) return { r: parseInt(parts[1], 16) / 255, g: parseInt(parts[2], 16) / 255, b: parseInt(parts[3], 16) / 255, a: 1 };
+    }
+  }
+  return { r: 0, g: 0, b: 0, a: 1 };
+}
+function colorToCss(color) {
+  const r = Math.round(color.r * 255);
+  const g = Math.round(color.g * 255);
+  const b = Math.round(color.b * 255);
+  const a = color.a !== void 0 ? color.a : 1;
+  return a < 1 ? `rgba(${r},${g},${b},${a})` : `rgb(${r},${g},${b})`;
+}
+
+export {
+  Planar,
+  resample,
+  resolveOutputSize,
+  resizeToFit,
+  surface,
+  imageReference,
+  readPixelsFromCanvas,
+  readPlanar,
+  writePixels,
+  output,
+  normalizeColor,
+  colorToCss
+};
+//# sourceMappingURL=chunk-WGKPJZDY.js.map