@glyphcss/compile 0.0.9

package/dist/vite.js

@@ -0,0 +1,267 @@
+// 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/vite.ts
+var MESH_RE = /\.(glb|gltf|obj|vox|stl)(\?|$)/i;
+function hasGlyphFlag(id) {
+  const q = id.split("?")[1];
+  return q != null && new URLSearchParams(q).has("glyph");
+}
+function parseQuery(id) {
+  const q = id.split("?")[1] ?? "";
+  const p = new URLSearchParams(q);
+  const num = (k) => p.has(k) ? Number(p.get(k)) : void 0;
+  const out = {};
+  for (const k of ["rotX", "rotY", "zoom", "distance", "perspective", "cols", "rows", "cellAspect", "creaseAngle", "supersample"]) {
+    const v = num(k);
+    if (v !== void 0 && Number.isFinite(v)) out[k] = v;
+  }
+  if (p.has("mode")) out.mode = p.get("mode");
+  if (p.has("palette")) out.glyphPalette = p.get("palette") ?? void 0;
+  if (p.has("projection")) out.projection = p.get("projection") === "orthographic" ? "orthographic" : "perspective";
+  if (p.has("meshResolution")) out.meshResolution = p.get("meshResolution");
+  if (p.has("colors")) out.useColors = p.get("colors") !== "0" && p.get("colors") !== "false";
+  if (p.has("autoCenter")) out.autoCenter = p.get("autoCenter") !== "0" && p.get("autoCenter") !== "false";
+  if (p.has("smoothShading")) out.smoothShading = p.get("smoothShading") !== "0" && p.get("smoothShading") !== "false";
+  if (p.has("doubleSided")) out.doubleSided = p.get("doubleSided") !== "0" && p.get("doubleSided") !== "false";
+  return out;
+}
+function glyphcssCompile(globalOptions = {}) {
+  return {
+    name: "glyphcss-compile",
+    enforce: "pre",
+    async load(id) {
+      if (!MESH_RE.test(id) || !hasGlyphFlag(id)) return null;
+      const path = id.split("?")[0];
+      const opts = { ...globalOptions, ...parseQuery(id) };
+      const result = await compileFile(path, opts);
+      const meta = { cols: result.cols, rows: result.rows, cellAspect: result.cellAspect };
+      return [
+        `export default ${JSON.stringify(result.html)};`,
+        `export const inner = ${JSON.stringify(result.inner)};`,
+        `export const meta = ${JSON.stringify(meta)};`
+      ].join("\n");
+    }
+  };
+}
+var vite_default = glyphcssCompile;
+export {
+  vite_default as default,
+  glyphcssCompile
+};

package/package.json

@@ -0,0 +1,72 @@
+{
+  "name": "@glyphcss/compile",
+  "version": "0.0.9",
+  "description": "Compile 3D meshes to static glyphcss ASCII at build time — a Vite plugin, a CLI, and a Node API. Zero-runtime <pre> output for any static pipeline.",
+  "type": "module",
+  "main": "dist/index.cjs",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "keywords": [
+    "glyphcss",
+    "ascii",
+    "3d",
+    "compile",
+    "vite",
+    "vite-plugin",
+    "static",
+    "ssg",
+    "cli"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/apresmoi/glyphcss.git",
+    "directory": "packages/compile"
+  },
+  "bugs": {
+    "url": "https://github.com/apresmoi/glyphcss/issues"
+  },
+  "homepage": "https://github.com/apresmoi/glyphcss#readme",
+  "files": [
+    "dist",
+    "SKILL.md"
+  ],
+  "bin": {
+    "glyphcss": "dist/cli.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    },
+    "./vite": {
+      "types": "./dist/vite.d.ts",
+      "import": "./dist/vite.js",
+      "require": "./dist/vite.cjs"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "pngjs": "^7.0.0",
+    "jpeg-js": "^0.4.4",
+    "@glyphcss/core": "^0.0.9",
+    "glyphcss": "^0.0.9"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.0",
+    "@types/pngjs": "^6.0.5",
+    "happy-dom": "^20.7.0",
+    "tsup": "^8.0.1",
+    "typescript": "^5.3.3",
+    "vitest": "^3.1.1",
+    "@vitest/coverage-v8": "^3.1.1"
+  },
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest run --passWithNoTests",
+    "test:coverage": "vitest run --coverage --passWithNoTests"
+  }
+}