@glyphcss/compile 0.0.9

package/dist/cli.js

@@ -0,0 +1,458 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { writeFile, readFile as readFile3 } from "fs/promises";
+
+// src/compileFile.ts
+import {
+  compileScene,
+  createGlyphPerspectiveCamera,
+  createGlyphOrthographicCamera,
+  cropGlyphInner
+} from "glyphcss";
+
+// src/loadMeshFromFile.ts
+import { readFile as readFile2 } from "fs/promises";
+import { loadMesh } from "@glyphcss/core";
+
+// src/textureBakeNode.ts
+import { readFile } from "fs/promises";
+import { PNG } from "pngjs";
+import jpeg from "jpeg-js";
+function stripQuery(url) {
+  return url.split("?")[0].split("#")[0];
+}
+function toFilePath(url) {
+  const clean = stripQuery(url);
+  if (/^https?:\/\//i.test(clean)) {
+    try {
+      return decodeURIComponent(new URL(clean).pathname);
+    } catch {
+    }
+  }
+  if (clean.startsWith("file://")) {
+    try {
+      return decodeURIComponent(new URL(clean).pathname);
+    } catch {
+    }
+  }
+  return clean;
+}
+async function decode(path) {
+  const fp = toFilePath(path);
+  try {
+    const buf = await readFile(fp);
+    if (/\.png$/i.test(fp)) {
+      const p = PNG.sync.read(buf);
+      return { w: p.width, h: p.height, data: p.data };
+    }
+    if (/\.jpe?g$/i.test(fp)) {
+      const j = jpeg.decode(buf, { useTArray: true });
+      return { w: j.width, h: j.height, data: j.data };
+    }
+  } catch {
+  }
+  return null;
+}
+function texelAt(img, u, v) {
+  const x = Math.min(img.w - 1, Math.max(0, Math.round(u * (img.w - 1))));
+  const y = Math.min(img.h - 1, Math.max(0, Math.round((1 - v) * (img.h - 1))));
+  const i = (y * img.w + x) * 4;
+  return [img.data[i], img.data[i + 1], img.data[i + 2]];
+}
+function sampleFace(img, uvs) {
+  const pts = [uvs[0], uvs[1], uvs[2], [(uvs[0][0] + uvs[1][0] + uvs[2][0]) / 3, (uvs[0][1] + uvs[1][1] + uvs[2][1]) / 3]];
+  let r = 0, g = 0, b = 0;
+  for (const [u, v] of pts) {
+    const c = texelAt(img, u, v);
+    r += c[0];
+    g += c[1];
+    b += c[2];
+  }
+  const n = pts.length;
+  const h = (x) => Math.round(x / n).toString(16).padStart(2, "0");
+  return `#${h(r)}${h(g)}${h(b)}`;
+}
+async function bakeTexturesNode(polygons) {
+  const cache = /* @__PURE__ */ new Map();
+  const get = async (url) => {
+    if (!cache.has(url)) cache.set(url, await decode(url));
+    return cache.get(url) ?? null;
+  };
+  const out = [];
+  for (const p of polygons) {
+    const tt = p.textureTriangles?.[0];
+    const tex = p.texture ?? p.material?.texture ?? tt?.texture;
+    const uvs = tt?.uvs ?? (p.uvs && p.uvs.length >= 3 ? [p.uvs[0], p.uvs[1], p.uvs[2]] : void 0);
+    if (tex && uvs) {
+      const img = await get(tex);
+      if (img) {
+        out.push({ ...p, color: sampleFace(img, uvs), texture: void 0, textureTriangles: void 0, uvs: void 0 });
+        continue;
+      }
+    }
+    out.push(p);
+  }
+  return out;
+}
+function hasTextures(polygons) {
+  return polygons.some((p) => p.texture || p.material?.texture || p.textureTriangles?.[0]?.texture);
+}
+
+// src/loadMeshFromFile.ts
+function stripQuery2(url) {
+  return url.split("?")[0].split("#")[0];
+}
+async function siblingMtl(objPath) {
+  const clean = stripQuery2(objPath);
+  const dir = clean.replace(/[^/\\]+$/, "");
+  let candidate;
+  try {
+    const m = (await readFile2(clean, "utf8")).match(/^\s*mtllib\s+(.+?)\s*$/im);
+    candidate = m ? dir + m[1].trim() : clean.replace(/\.obj$/i, ".mtl");
+  } catch {
+    candidate = clean.replace(/\.obj$/i, ".mtl");
+  }
+  try {
+    await readFile2(candidate);
+    return candidate;
+  } catch {
+    return void 0;
+  }
+}
+async function fileFetch(url) {
+  const path = stripQuery2(url);
+  try {
+    const buf = await readFile2(path);
+    const ab = buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
+    return {
+      ok: true,
+      status: 200,
+      text: async () => buf.toString("utf8"),
+      arrayBuffer: async () => ab
+    };
+  } catch {
+    return { ok: false, status: 404, text: async () => "", arrayBuffer: async () => new ArrayBuffer(0) };
+  }
+}
+async function loadMeshFromFile(path, options) {
+  const g = globalThis;
+  const prev = g.fetch;
+  g.fetch = fileFetch;
+  let result;
+  try {
+    const mtlUrl = options?.mtlUrl ?? (/\.obj(\?|$)/i.test(path) ? await siblingMtl(path) : void 0);
+    result = await loadMesh(path, { solidTextureSamples: false, ...options, mtlUrl });
+  } finally {
+    g.fetch = prev;
+  }
+  if (hasTextures(result.polygons)) {
+    return { ...result, polygons: await bakeTexturesNode(result.polygons) };
+  }
+  return result;
+}
+
+// src/compileFile.ts
+function worldMaxDim(polys) {
+  let mnx = Infinity, mxx = -Infinity, mny = Infinity, mxy = -Infinity, mnz = Infinity, mxz = -Infinity;
+  for (const p of polys) for (const v of p.vertices) {
+    if (v[0] < mnx) mnx = v[0];
+    if (v[0] > mxx) mxx = v[0];
+    if (v[1] < mny) mny = v[1];
+    if (v[1] > mxy) mxy = v[1];
+    if (v[2] < mnz) mnz = v[2];
+    if (v[2] > mxz) mxz = v[2];
+  }
+  if (!isFinite(mnx)) return 1;
+  return Math.max(mxx - mnx, mxy - mny, mxz - mnz, 1e-6);
+}
+function measureContent(inner) {
+  const lines = inner.replace(/<[^>]*>/g, "").split("\n");
+  let minC = Infinity, maxC = -1, minR = Infinity, maxR = -1;
+  lines.forEach((l, r) => {
+    for (let c = 0; c < l.length; c++) if (l[c] !== " ") {
+      if (c < minC) minC = c;
+      if (c > maxC) maxC = c;
+      if (r < minR) minR = r;
+      if (r > maxR) maxR = r;
+    }
+  });
+  return maxC < 0 ? { w: 0, h: 0 } : { w: maxC - minC + 1, h: maxR - minR + 1 };
+}
+function compilePolygons(polygons, options = {}) {
+  const buildCam = (zoom) => options.projection === "orthographic" ? createGlyphOrthographicCamera({ rotX: options.rotX, rotY: options.rotY, zoom }) : createGlyphPerspectiveCamera({ rotX: options.rotX, rotY: options.rotY, zoom, distance: options.distance, perspective: options.perspective });
+  const shared = {
+    autoCenter: options.autoCenter,
+    cellAspect: options.cellAspect,
+    mode: options.mode,
+    glyphPalette: options.glyphPalette,
+    useColors: options.useColors,
+    smoothShading: options.smoothShading,
+    creaseAngle: options.creaseAngle,
+    doubleSided: options.doubleSided,
+    supersample: options.supersample
+  };
+  if (options.autoFit && options.autoFit.target > 0) {
+    const { target, by } = options.autoFit;
+    const probeZoom = 40 / worldMaxDim(polygons);
+    const probe = compileScene({ polygons, camera: buildCam(probeZoom), cols: 200, rows: 120, ...shared, autoCenter: true });
+    const m = measureContent(probe.inner);
+    if (m.w > 0 && m.h > 0) {
+      const scale = by === "rows" ? target / m.h : target / m.w;
+      const zoom = probeZoom * scale;
+      const cols = Math.ceil(m.w * scale * 1.4) + 6;
+      const rows = Math.ceil(m.h * scale * 1.4) + 6;
+      const full = compileScene({ polygons, camera: buildCam(zoom), cols, rows, ...shared, autoCenter: true });
+      const inner = cropGlyphInner(full.inner);
+      const lines = inner.split("\n");
+      const w = lines.reduce((a, l) => Math.max(a, l.replace(/<[^>]*>/g, "").length), 0);
+      return { html: `<pre class="glyph-output">${inner}</pre>`, inner, cols: w, rows: lines.length, cellAspect: options.cellAspect ?? 2 };
+    }
+  }
+  return compileScene({
+    polygons,
+    camera: buildCam(options.zoom),
+    cols: options.cols,
+    rows: options.rows,
+    ...shared
+  });
+}
+async function compileFile(path, options = {}) {
+  const { polygons } = await loadMeshFromFile(path, { meshResolution: options.meshResolution, mtlUrl: options.mtlUrl });
+  return compilePolygons(polygons, options);
+}
+
+// src/compileInteractive.ts
+import {
+  buildGlyphInteractiveExport,
+  glyphCodepenPrefill
+} from "glyphcss";
+async function compileInteractive(path, options = {}) {
+  const { polygons } = await loadMeshFromFile(path, { meshResolution: options.meshResolution, mtlUrl: options.mtlUrl });
+  return buildGlyphInteractiveExport(polygons, options);
+}
+
+// src/cli.ts
+import { encodeGlyphAnsi } from "glyphcss";
+import { resolveGeometry } from "@glyphcss/core";
+var MESH_EXT = /\.(obj|glb|gltf|vox|stl)$/i;
+function normalizePolygons(data) {
+  const arr = Array.isArray(data) ? data : data?.polygons;
+  if (!Array.isArray(arr)) throw new Error("polygons JSON must be an array or { polygons: [...] }");
+  return arr.map((p, i) => {
+    const vertices = p.vertices ?? p.v;
+    if (!Array.isArray(vertices) || vertices.length < 3) throw new Error(`polygon ${i}: needs vertices [[x,y,z], \u2026] (>= 3)`);
+    return { vertices, color: p.color ?? p.c };
+  });
+}
+function parseArgs(argv) {
+  const opts = {};
+  let file;
+  let out;
+  let format;
+  let fit;
+  let shape;
+  let polygonsFile;
+  let polygonsJson;
+  let interactive = false;
+  let interactions;
+  let decimateGrid;
+  let cdnVersion;
+  const num = (v) => {
+    const n = Number(v);
+    return v !== void 0 && Number.isFinite(n) ? n : void 0;
+  };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    const next = () => argv[++i];
+    switch (a) {
+      case "--rot-x":
+        opts.rotX = num(next());
+        break;
+      case "--rot-y":
+        opts.rotY = num(next());
+        break;
+      case "--zoom":
+        opts.zoom = num(next());
+        break;
+      case "--distance":
+        opts.distance = num(next());
+        break;
+      case "--perspective":
+        opts.perspective = num(next());
+        break;
+      case "--cols":
+        opts.cols = num(next());
+        break;
+      case "--rows":
+        opts.rows = num(next());
+        break;
+      case "--cell-aspect":
+        opts.cellAspect = num(next());
+        break;
+      case "--crease-angle":
+        opts.creaseAngle = num(next());
+        break;
+      case "--supersample":
+        opts.supersample = num(next());
+        break;
+      case "--mode":
+        opts.mode = next();
+        break;
+      case "--palette":
+        opts.glyphPalette = next();
+        break;
+      case "--mesh-resolution":
+        opts.meshResolution = next();
+        break;
+      case "--mtl":
+        opts.mtlUrl = next();
+        break;
+      // Geometry input (instead of a mesh file).
+      case "--shape":
+        shape = next();
+        break;
+      case "--polygons":
+        polygonsFile = next();
+        break;
+      case "--polygons-json":
+        polygonsJson = next();
+        break;
+      case "--ortho":
+        opts.projection = "orthographic";
+        break;
+      case "--auto-center":
+        opts.autoCenter = true;
+        break;
+      case "--smooth":
+        opts.smoothShading = true;
+        break;
+      case "--double-sided":
+        opts.doubleSided = true;
+        break;
+      case "--fit":
+        fit = num(next());
+        break;
+      // Output format (+ back-compat aliases).
+      case "-f":
+      case "--format":
+        format = next();
+        break;
+      case "--ansi":
+        format = "ansi";
+        break;
+      case "--no-colors":
+      case "--text":
+        format = "text";
+        break;
+      case "--pre":
+      case "--html":
+        format = "html";
+        break;
+      case "--full":
+        format = "full";
+        break;
+      case "--interactive":
+        interactive = true;
+        break;
+      case "--interactions":
+        interactive = true;
+        interactions = (next() ?? "").split(",").map((s) => s.trim()).filter(Boolean);
+        break;
+      case "--decimate-grid":
+        decimateGrid = num(next());
+        break;
+      case "--cdn-version":
+        cdnVersion = next();
+        break;
+      case "-o":
+      case "--out":
+        out = next();
+        break;
+      case "-h":
+      case "--help":
+        file = void 0;
+        return { file, out, format, fit, shape, polygonsFile, polygonsJson, interactive, interactions, decimateGrid, cdnVersion, opts };
+      default:
+        if (!a.startsWith("-") && !file) file = a;
+    }
+  }
+  return { file, out, format, fit, shape, polygonsFile, polygonsJson, interactive, interactions, decimateGrid, cdnVersion, opts };
+}
+var HELP = `glyphcss <mesh-file | shape> [options]
+
+  Input    a mesh file (.obj/.glb/.gltf/.vox/.stl), a primitive shape name
+           (e.g. cube, sphere, icosahedron, torus, cone), or:
+           --shape NAME   --polygons FILE.json   --polygons-json '[{"vertices":[...],"color":"#f00"}]'
+  Camera   --rot-x N  --rot-y N  --zoom N  --distance N  --perspective N  --ortho
+  Grid     --cols N  --rows N  --cell-aspect N   (omit cols/rows \u2192 auto-fit to content)
+  Fit      --fit N   target width in columns for auto-fit (default: terminal width or 80)
+  Render   --mode solid|wireframe|voxel  --palette NAME  --no-colors  --smooth  --double-sided
+  Mesh     --auto-center  --mtl FILE (OBJ material override)  --mesh-resolution lossy|lossless  --crease-angle N  --supersample N
+  Interact --interactive  --interactions orbit,zoom,pan,fpv  --decimate-grid N  --cdn-version V
+  Output   -f, --format text|ansi|html|full     (default: terminal \u2192 ansi, file \u2192 html, pipe \u2192 text)
+           -o, --out FILE
+`;
+function wrapHtml(inner) {
+  return `<!doctype html>
+<html><head><meta charset="utf-8"><title>glyphcss</title>
+<style>
+  html,body{margin:0;background:#0b0d10;color:#e2e8f0}
+  pre.glyph-output{margin:0;font:13px/1 ui-monospace,"SF Mono",Menlo,monospace;white-space:pre}
+</style></head>
+<body>${inner}</body></html>`;
+}
+async function main() {
+  const { file, out, format: fmtArg, fit, shape, polygonsFile, polygonsJson, interactive, interactions, decimateGrid, cdnVersion, opts } = parseArgs(process.argv.slice(2));
+  const positionalShape = file && !MESH_EXT.test(file) ? file : void 0;
+  const meshFile = file && MESH_EXT.test(file) ? file : void 0;
+  const shapeName = shape ?? positionalShape;
+  if (!meshFile && !shapeName && !polygonsFile && !polygonsJson) {
+    process.stderr.write(HELP);
+    process.exit(process.argv.length <= 2 ? 1 : 0);
+    return;
+  }
+  const format = fmtArg ?? (out ? "html" : process.stdout.isTTY ? "ansi" : "text");
+  if (interactive) {
+    if (!meshFile) throw new Error("--interactive needs a mesh file (shapes/polygons are static-only for now)");
+    const r = await compileInteractive(meshFile, { ...opts, interactions, decimateGrid, cdnVersion });
+    const output2 = format === "full" ? wrapHtml(r.html) : r.html;
+    if (out) {
+      await writeFile(out, output2, "utf8");
+      process.stderr.write(`glyphcss: wrote ${out} \u2014 interactive [${r.interactions.join(", ")}], ${r.polygonCount}/${r.sourcePolygonCount} tris
+`);
+    } else {
+      process.stdout.write(output2 + "\n");
+    }
+    return;
+  }
+  opts.useColors = format !== "text";
+  const hasCols = opts.cols !== void 0, hasRows = opts.rows !== void 0;
+  const termW = process.stdout.columns ? process.stdout.columns - 1 : 80;
+  if (fit !== void 0) opts.autoFit = { target: fit, by: "cols" };
+  else if (hasCols && !hasRows) opts.autoFit = { target: opts.cols, by: "cols" };
+  else if (hasRows && !hasCols) opts.autoFit = { target: opts.rows, by: "rows" };
+  else if (!hasCols && !hasRows) opts.autoFit = { target: termW, by: "cols" };
+  if (opts.autoFit) {
+    opts.cols = void 0;
+    opts.rows = void 0;
+  }
+  let result;
+  if (polygonsJson) result = compilePolygons(normalizePolygons(JSON.parse(polygonsJson)), opts);
+  else if (polygonsFile) result = compilePolygons(normalizePolygons(JSON.parse(await readFile3(polygonsFile, "utf8"))), opts);
+  else if (shapeName) result = compilePolygons(resolveGeometry(shapeName, { size: 1 }), { ...opts, autoCenter: true });
+  else result = await compileFile(meshFile, opts);
+  const output = format === "text" ? result.inner : format === "ansi" ? encodeGlyphAnsi(result.inner) : format === "full" ? wrapHtml(result.html) : result.html;
+  if (out) {
+    await writeFile(out, output, "utf8");
+    process.stderr.write(`glyphcss: wrote ${out} (${result.cols}\xD7${result.rows}, ${format})
+`);
+  } else {
+    process.stdout.write(output + "\n");
+  }
+}
+main().catch((err) => {
+  process.stderr.write(`glyphcss: ${err instanceof Error ? err.message : String(err)}
+`);
+  process.exit(1);
+});