@glyphcss/compile 0.0.9

package/dist/vite-zkmogiPw.d.cts

@@ -0,0 +1,69 @@
+import { CompileSceneResult } from 'glyphcss';
+import { RenderMode, MeshResolution, Polygon } from '@glyphcss/core';
+
+interface CompileFileOptions {
+    /** Camera projection. Default: "perspective" (the library default). */
+    projection?: "perspective" | "orthographic";
+    rotX?: number;
+    rotY?: number;
+    zoom?: number;
+    /** Perspective only. */
+    distance?: number;
+    perspective?: number;
+    cols?: number;
+    rows?: number;
+    cellAspect?: number;
+    mode?: RenderMode;
+    glyphPalette?: string;
+    useColors?: boolean;
+    smoothShading?: boolean;
+    creaseAngle?: number;
+    doubleSided?: boolean;
+    supersample?: number;
+    /** Recenter the mesh bbox to the origin (matches `<glyph-mesh auto-center>`). Default false. */
+    autoCenter?: boolean;
+    /**
+     * Auto-fit: size the grid + zoom so the whole model shows, cropped tight.
+     * `by` is the axis to fit to `target` (the other axis adapts to the content):
+     * fit `cols` (width) when you give a column budget, `rows` (height) for a row
+     * budget. Implies `autoCenter`.
+     */
+    autoFit?: {
+        target: number;
+        by: "cols" | "rows";
+    };
+    /** Mesh-optimization quality passed to `loadMesh`. Default: the loadMesh default ("lossy"). */
+    meshResolution?: MeshResolution;
+    /** Explicit companion `.mtl` path for OBJ (overrides sibling auto-detection). */
+    mtlUrl?: string;
+}
+/**
+ * compilePolygons — render polygons you already have (a primitive, custom JSON,
+ * etc.) to a `<pre>`, with the same camera / auto-fit logic as `compileFile`.
+ * Pure + synchronous (no file I/O).
+ */
+declare function compilePolygons(polygons: Polygon[], options?: CompileFileOptions): CompileSceneResult;
+declare function compileFile(path: string, options?: CompileFileOptions): Promise<CompileSceneResult>;
+
+/**
+ * glyphcssCompile — a Vite plugin that compiles a mesh import to its static
+ * `<pre>` ASCII **at build time**:
+ *
+ *   import duck from "./duck.glb?glyph&rotX=60&rotY=45&autoCenter=1";
+ *   el.innerHTML = duck;          // the <pre>…ascii…</pre> string, zero runtime
+ *
+ * Query params map to `CompileFileOptions` (rotX, rotY, zoom, distance,
+ * perspective, cols, rows, cellAspect, mode, palette, colors=0|1, autoCenter,
+ * projection, meshResolution). Works in any Vite-based pipeline (Astro, vanilla
+ * Vite, Vite-React). Defaults match the glyphcss library.
+ */
+
+interface VitePluginLike {
+    name: string;
+    enforce?: "pre" | "post";
+    load(this: unknown, id: string): Promise<string | null> | string | null;
+}
+type GlyphCompileOptions = Partial<CompileFileOptions>;
+declare function glyphcssCompile(globalOptions?: GlyphCompileOptions): VitePluginLike;
+
+export { type CompileFileOptions as C, type GlyphCompileOptions as G, type VitePluginLike as V, compilePolygons as a, compileFile as c, glyphcssCompile as g };

package/dist/vite-zkmogiPw.d.ts

@@ -0,0 +1,69 @@
+import { CompileSceneResult } from 'glyphcss';
+import { RenderMode, MeshResolution, Polygon } from '@glyphcss/core';
+
+interface CompileFileOptions {
+    /** Camera projection. Default: "perspective" (the library default). */
+    projection?: "perspective" | "orthographic";
+    rotX?: number;
+    rotY?: number;
+    zoom?: number;
+    /** Perspective only. */
+    distance?: number;
+    perspective?: number;
+    cols?: number;
+    rows?: number;
+    cellAspect?: number;
+    mode?: RenderMode;
+    glyphPalette?: string;
+    useColors?: boolean;
+    smoothShading?: boolean;
+    creaseAngle?: number;
+    doubleSided?: boolean;
+    supersample?: number;
+    /** Recenter the mesh bbox to the origin (matches `<glyph-mesh auto-center>`). Default false. */
+    autoCenter?: boolean;
+    /**
+     * Auto-fit: size the grid + zoom so the whole model shows, cropped tight.
+     * `by` is the axis to fit to `target` (the other axis adapts to the content):
+     * fit `cols` (width) when you give a column budget, `rows` (height) for a row
+     * budget. Implies `autoCenter`.
+     */
+    autoFit?: {
+        target: number;
+        by: "cols" | "rows";
+    };
+    /** Mesh-optimization quality passed to `loadMesh`. Default: the loadMesh default ("lossy"). */
+    meshResolution?: MeshResolution;
+    /** Explicit companion `.mtl` path for OBJ (overrides sibling auto-detection). */
+    mtlUrl?: string;
+}
+/**
+ * compilePolygons — render polygons you already have (a primitive, custom JSON,
+ * etc.) to a `<pre>`, with the same camera / auto-fit logic as `compileFile`.
+ * Pure + synchronous (no file I/O).
+ */
+declare function compilePolygons(polygons: Polygon[], options?: CompileFileOptions): CompileSceneResult;
+declare function compileFile(path: string, options?: CompileFileOptions): Promise<CompileSceneResult>;
+
+/**
+ * glyphcssCompile — a Vite plugin that compiles a mesh import to its static
+ * `<pre>` ASCII **at build time**:
+ *
+ *   import duck from "./duck.glb?glyph&rotX=60&rotY=45&autoCenter=1";
+ *   el.innerHTML = duck;          // the <pre>…ascii…</pre> string, zero runtime
+ *
+ * Query params map to `CompileFileOptions` (rotX, rotY, zoom, distance,
+ * perspective, cols, rows, cellAspect, mode, palette, colors=0|1, autoCenter,
+ * projection, meshResolution). Works in any Vite-based pipeline (Astro, vanilla
+ * Vite, Vite-React). Defaults match the glyphcss library.
+ */
+
+interface VitePluginLike {
+    name: string;
+    enforce?: "pre" | "post";
+    load(this: unknown, id: string): Promise<string | null> | string | null;
+}
+type GlyphCompileOptions = Partial<CompileFileOptions>;
+declare function glyphcssCompile(globalOptions?: GlyphCompileOptions): VitePluginLike;
+
+export { type CompileFileOptions as C, type GlyphCompileOptions as G, type VitePluginLike as V, compilePolygons as a, compileFile as c, glyphcssCompile as g };

package/dist/vite.cjs

@@ -0,0 +1,299 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/vite.ts
+var vite_exports = {};
+__export(vite_exports, {
+  default: () => vite_default,
+  glyphcssCompile: () => glyphcssCompile
+});
+module.exports = __toCommonJS(vite_exports);
+
+// src/compileFile.ts
+var import_glyphcss = require("glyphcss");
+
+// src/loadMeshFromFile.ts
+var import_promises2 = require("fs/promises");
+var import_core = require("@glyphcss/core");
+
+// src/textureBakeNode.ts
+var import_promises = require("fs/promises");
+var import_pngjs = require("pngjs");
+var import_jpeg_js = __toESM(require("jpeg-js"), 1);
+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 (0, import_promises.readFile)(fp);
+    if (/\.png$/i.test(fp)) {
+      const p = import_pngjs.PNG.sync.read(buf);
+      return { w: p.width, h: p.height, data: p.data };
+    }
+    if (/\.jpe?g$/i.test(fp)) {
+      const j = import_jpeg_js.default.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 (0, import_promises2.readFile)(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 (0, import_promises2.readFile)(candidate);
+    return candidate;
+  } catch {
+    return void 0;
+  }
+}
+async function fileFetch(url) {
+  const path = stripQuery2(url);
+  try {
+    const buf = await (0, import_promises2.readFile)(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 (0, import_core.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" ? (0, import_glyphcss.createGlyphOrthographicCamera)({ rotX: options.rotX, rotY: options.rotY, zoom }) : (0, import_glyphcss.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 = (0, import_glyphcss.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 = (0, import_glyphcss.compileScene)({ polygons, camera: buildCam(zoom), cols, rows, ...shared, autoCenter: true });
+      const inner = (0, import_glyphcss.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 (0, import_glyphcss.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;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  glyphcssCompile
+});

package/dist/vite.d.cts

@@ -0,0 +1,3 @@
+export { G as GlyphCompileOptions, V as VitePluginLike, g as default, g as glyphcssCompile } from './vite-zkmogiPw.cjs';
+import 'glyphcss';
+import '@glyphcss/core';

package/dist/vite.d.ts

@@ -0,0 +1,3 @@
+export { G as GlyphCompileOptions, V as VitePluginLike, g as default, g as glyphcssCompile } from './vite-zkmogiPw.js';
+import 'glyphcss';
+import '@glyphcss/core';