omnius 1.0.9 → 1.0.11

package/vendor/image-to-ascii/index.cjs

@@ -0,0 +1,257 @@
+"use strict";
+
+var childProcess = require("node:child_process");
+var crypto = require("node:crypto");
+var fs = require("node:fs");
+var os = require("node:os");
+var path = require("node:path");
+
+var DEFAULT_PIXELS = " .,:;i1tfLCG08@";
+
+function isObject(value) {
+  return value !== null && typeof value === "object" && !Buffer.isBuffer(value);
+}
+
+function clamp(value, min, max) {
+  var n = Number(value);
+  if (!Number.isFinite(n)) return min;
+  n = Math.floor(n);
+  return Math.max(min, Math.min(max, n));
+}
+
+function percentOrNumber(value, basis, fallback) {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string") {
+    var trimmed = value.trim();
+    if (trimmed.endsWith("%")) {
+      var pct = Number(trimmed.slice(0, -1));
+      if (Number.isFinite(pct)) return Math.max(1, Math.floor((basis * pct) / 100));
+    }
+    var parsed = Number(trimmed);
+    if (Number.isFinite(parsed)) return parsed;
+  }
+  return fallback;
+}
+
+function resolveSize(options) {
+  var size = isObject(options.size) ? options.size : {};
+  var sizeOptions = isObject(options.size_options) ? options.size_options : {};
+  var screen = isObject(sizeOptions.screen_size) ? sizeOptions.screen_size : {};
+  var screenWidth = clamp(screen.width || process.stdout.columns || 80, 20, 240);
+  var screenHeight = clamp(screen.height || process.stdout.rows || 32, 8, 120);
+  var width = percentOrNumber(size.width, screenWidth, Math.min(80, screenWidth));
+  var height = percentOrNumber(size.height, screenHeight, Math.max(8, Math.round(width * 0.42)));
+  return {
+    width: clamp(width, 8, 240),
+    height: clamp(height, 4, 120)
+  };
+}
+
+function normalizeOptions(options) {
+  if (!isObject(options)) options = {};
+  var pixels = options.pixels;
+  if (Array.isArray(pixels)) pixels = pixels.join("");
+  if (typeof pixels !== "string" || pixels.length < 2) pixels = DEFAULT_PIXELS;
+  if (options.reverse === true) pixels = pixels.split("").reverse().join("");
+  return {
+    pixels: pixels,
+    colored: options.colored === true,
+    concat: options.concat !== false,
+    stringify: options.stringify !== false,
+    timeoutMs: clamp(options.timeoutMs || options.timeout || 5000, 500, 60000),
+    preserveAspectRatio: !options.size_options || options.size_options.preserve_aspect_ratio !== false,
+    size: resolveSize(options),
+    stringifyFn: typeof options.stringify_fn === "function" ? options.stringify_fn : null
+  };
+}
+
+function tempFilePath(ext) {
+  var suffix = ext || ".img";
+  if (!suffix.startsWith(".")) suffix = "." + suffix;
+  return path.join(os.tmpdir(), "omnius-image-to-ascii-" + crypto.randomUUID() + suffix);
+}
+
+function extensionFromUrl(url) {
+  try {
+    var parsed = new URL(url);
+    var ext = path.extname(parsed.pathname || "");
+    return ext || ".img";
+  } catch (e) {
+    return ".img";
+  }
+}
+
+function sourceToFile(source, callback) {
+  if (Buffer.isBuffer(source)) {
+    var bufPath = tempFilePath(".img");
+    fs.writeFile(bufPath, source, function (err) {
+      callback(err, bufPath, true);
+    });
+    return;
+  }
+
+  if (typeof source !== "string" || source.trim().length === 0) {
+    callback(new Error("image-to-ascii source must be a file path, URL, or Buffer"));
+    return;
+  }
+
+  if (/^https?:\/\//i.test(source)) {
+    if (typeof fetch !== "function") {
+      callback(new Error("image-to-ascii URL input requires Node fetch support"));
+      return;
+    }
+    fetch(source).then(function (res) {
+      if (!res.ok) throw new Error("image-to-ascii failed to fetch image: HTTP " + res.status);
+      return res.arrayBuffer();
+    }).then(function (arrayBuffer) {
+      var urlPath = tempFilePath(extensionFromUrl(source));
+      fs.writeFile(urlPath, Buffer.from(arrayBuffer), function (err) {
+        callback(err, urlPath, true);
+      });
+    }).catch(function (err) {
+      callback(err);
+    });
+    return;
+  }
+
+  callback(null, source, false);
+}
+
+function buildFilter(width, height, preserveAspectRatio) {
+  if (preserveAspectRatio) {
+    return [
+      "scale=" + width + ":" + height + ":force_original_aspect_ratio=decrease",
+      "pad=" + width + ":" + height + ":(ow-iw)/2:(oh-ih)/2:color=black",
+      "format=gray"
+    ].join(",");
+  }
+  return "scale=" + width + ":" + height + ",format=gray";
+}
+
+function matrixFromRaw(raw, width, height) {
+  var matrix = [];
+  for (var y = 0; y < height; y++) {
+    var row = [];
+    for (var x = 0; x < width; x++) {
+      var value = raw[y * width + x] || 0;
+      row.push({ r: value, g: value, b: value, a: 255, value: value });
+    }
+    matrix.push(row);
+  }
+  return matrix;
+}
+
+function stringifyMatrix(matrix, options) {
+  var lines = [];
+  var pixels = options.pixels;
+  var maxIdx = pixels.length - 1;
+  for (var y = 0; y < matrix.length; y++) {
+    var line = "";
+    for (var x = 0; x < matrix[y].length; x++) {
+      var value = matrix[y][x].value || 0;
+      var idx = Math.round((value / 255) * maxIdx);
+      var ch = pixels[idx] || " ";
+      if (options.colored) {
+        line += "\x1b[38;2;" + value + ";" + value + ";" + value + "m" + ch + "\x1b[0m";
+      } else {
+        line += ch;
+      }
+    }
+    lines.push(line.replace(/\s+$/g, ""));
+  }
+  return options.concat ? lines.join("\n") : lines;
+}
+
+function renderFile(filePath, options, callback) {
+  var width = options.size.width;
+  var height = options.size.height;
+  var args = [
+    "-hide_banner",
+    "-loglevel",
+    "error",
+    "-i",
+    filePath,
+    "-vf",
+    buildFilter(width, height, options.preserveAspectRatio),
+    "-frames:v",
+    "1",
+    "-f",
+    "rawvideo",
+    "-pix_fmt",
+    "gray",
+    "-"
+  ];
+
+  childProcess.execFile("ffmpeg", args, {
+    encoding: "buffer",
+    maxBuffer: width * height + 4096,
+    timeout: options.timeoutMs
+  }, function (err, stdout, stderr) {
+    if (err) {
+      var detail = stderr && stderr.length ? String(stderr).trim() : err.message;
+      callback(new Error("image-to-ascii failed via ffmpeg: " + detail));
+      return;
+    }
+    if (!stdout || stdout.length < width * height) {
+      callback(new Error("image-to-ascii decoded too few pixels for " + width + "x" + height));
+      return;
+    }
+    var matrix = matrixFromRaw(stdout, width, height);
+    if (!options.stringify) {
+      callback(null, matrix);
+      return;
+    }
+    if (options.stringifyFn) {
+      try {
+        callback(null, options.stringifyFn(matrix, options));
+      } catch (stringifyErr) {
+        callback(stringifyErr);
+      }
+      return;
+    }
+    callback(null, stringifyMatrix(matrix, options));
+  });
+}
+
+function imageToAscii(source, options, callback) {
+  if (typeof options === "function") {
+    callback = options;
+    options = {};
+  }
+  if (typeof callback !== "function") {
+    return new Promise(function (resolve, reject) {
+      imageToAscii(source, options || {}, function (err, converted) {
+        if (err) reject(err);
+        else resolve(converted);
+      });
+    });
+  }
+
+  var normalized = normalizeOptions(options || {});
+  sourceToFile(source, function (sourceErr, filePath, cleanup) {
+    if (sourceErr) {
+      callback(sourceErr);
+      return;
+    }
+    renderFile(filePath, normalized, function (renderErr, converted) {
+      if (cleanup) {
+        fs.unlink(filePath, function () {});
+      }
+      callback(renderErr, converted);
+    });
+  });
+}
+
+imageToAscii.defaults = {
+  size_options: {
+    px_size: { width: 1 }
+  },
+  stringify: true,
+  concat: true,
+  size: {
+    height: "100%"
+  }
+};
+
+module.exports = imageToAscii;
+module.exports.default = imageToAscii;

package/vendor/image-to-ascii/index.d.ts

@@ -0,0 +1,48 @@
+declare namespace imageToAscii {
+  interface Size {
+    width?: number | string;
+    height?: number | string;
+  }
+
+  interface SizeOptions {
+    screen_size?: {
+      width?: number;
+      height?: number;
+    };
+    preserve_aspect_ratio?: boolean;
+    fit_screen?: boolean;
+    px_size?: {
+      width?: number;
+      height?: number;
+    };
+  }
+
+  interface Options {
+    pxWidth?: number;
+    size?: Size;
+    size_options?: SizeOptions;
+    stringify?: boolean;
+    concat?: boolean;
+    pixels?: string | string[];
+    reverse?: boolean;
+    colored?: boolean;
+    bg?: boolean;
+    fg?: boolean;
+    white_bg?: boolean;
+    px_background?: { r: number; g: number; b: number };
+    image_type?: string;
+    timeout?: number;
+    timeoutMs?: number;
+    stringify_fn?: (pixels: unknown, options: Options) => unknown;
+  }
+
+  type Callback = (err: Error | null, converted?: unknown) => void;
+}
+
+declare function imageToAscii(
+  source: string | Buffer,
+  options: imageToAscii.Options | imageToAscii.Callback,
+  callback?: imageToAscii.Callback,
+): void | Promise<unknown>;
+
+export = imageToAscii;

package/vendor/image-to-ascii/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "image-to-ascii",
+  "version": "3.3.0-omnius.1",
+  "description": "Omnius bundled image-to-ascii compatibility renderer without the legacy lwip native dependency chain.",
+  "main": "index.cjs",
+  "types": "index.d.ts",
+  "bin": {
+    "image-to-ascii": "bin/image-to-ascii.cjs"
+  },
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "require": "./index.cjs",
+      "default": "./index.cjs"
+    }
+  },
+  "license": "MIT",
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "dependencies": {}
+}