circuit-json-to-gltf 0.0.34 → 0.0.36

package/dist/{chunk-JSBRDJBE.js → chunk-QGM4M3NI.js}

@@ -4,7 +4,13 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __commonJS = (cb, mod) => function __require() {
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
 var __copyProps = (to, from, except, desc) => {
@@ -25,6 +31,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 
 export {
+  __require,
   __commonJS,
   __toESM
 };

package/dist/chunk-W5ZY3YD5.js

@@ -0,0 +1,6 @@
+// lib/assets/tscircuit-font.ts
+var tscircuit_font_default = "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";
+
+export {
+  tscircuit_font_default
+};

package/dist/index.js

@@ -1,7 +1,7 @@
 import {
   __commonJS,
   __toESM
-} from "./chunk-JSBRDJBE.js";
+} from "./chunk-QGM4M3NI.js";
 
 // node_modules/@jscad/modeling/src/utils/flatten.js
 var require_flatten = __commonJS({
@@ -14552,10 +14552,14 @@ async function renderBoardLayer(circuitJson, options) {
 }
 async function convertSvgToPng(svgString, resolution, backgroundColor) {
   if (typeof window !== "undefined" && typeof document !== "undefined") {
-    return convertSvgToCanvasBrowser(svgString, resolution, backgroundColor);
+    const { svgToPngDataUrl } = await import("./svg-to-png-browser-VH734VGT.js");
+    return await svgToPngDataUrl(svgString, {
+      width: resolution,
+      background: backgroundColor
+    });
   } else {
     try {
-      const { svgToPngDataUrl } = await import("./svg-to-png-FCHG2ZUX.js");
+      const { svgToPngDataUrl } = await import("./svg-to-png-XFKMCXOE.js");
       return await svgToPngDataUrl(svgString, {
         width: resolution,
         background: backgroundColor
@@ -15744,6 +15748,38 @@ function transformMesh(mesh, translation, rotation, scale) {
   }
   return result;
 }
+function convertMeshToGLTFOrientation(mesh) {
+  const result = {
+    positions: [...mesh.positions],
+    normals: [...mesh.normals],
+    texcoords: [...mesh.texcoords],
+    indices: [...mesh.indices]
+  };
+  if (mesh.colors) {
+    result.colors = [...mesh.colors];
+  }
+  for (let i = 0; i < result.positions.length; i += 3) {
+    const x = result.positions[i];
+    if (typeof x === "number") {
+      result.positions[i] = -x;
+    }
+  }
+  for (let i = 0; i < result.normals.length; i += 3) {
+    const nx = result.normals[i];
+    if (typeof nx === "number") {
+      result.normals[i] = -nx;
+    }
+  }
+  for (let i = 0; i < result.indices.length; i += 3) {
+    const i1 = result.indices[i + 1];
+    const i2 = result.indices[i + 2];
+    if (typeof i1 === "number" && typeof i2 === "number") {
+      result.indices[i + 1] = i2;
+      result.indices[i + 2] = i1;
+    }
+  }
+  return result;
+}
 function getBounds(positions) {
   if (positions.length === 0) {
     return {
@@ -15831,6 +15867,7 @@ var GLTFBuilder = class {
       meshData = createBoxMesh(box.size);
     }
     meshData = transformMesh(meshData, box.center, box.rotation);
+    meshData = convertMeshToGLTFOrientation(meshData);
     let materialIndex = defaultMaterialIndex;
     if (box.color) {
       materialIndex = this.addMaterialFromColor(box.color, !box.mesh);
@@ -15884,10 +15921,8 @@ var GLTFBuilder = class {
     }
     const primitives = [];
     for (const { meshData, materialIndex } of meshDataArray) {
-      const transformedMeshData = transformMesh(
-        meshData,
-        box.center,
-        box.rotation
+      const transformedMeshData = convertMeshToGLTFOrientation(
+        transformMesh(meshData, box.center, box.rotation)
       );
       const positionAccessorIndex = this.addAccessor(
         transformedMeshData.positions,
@@ -16055,10 +16090,8 @@ var GLTFBuilder = class {
         vertexIndex += 3;
       }
       const meshData = { positions, normals, texcoords, indices };
-      const transformedMeshData = transformMesh(
-        meshData,
-        box.center,
-        box.rotation
+      const transformedMeshData = convertMeshToGLTFOrientation(
+        transformMesh(meshData, box.center, box.rotation)
       );
       const positionAccessorIndex = this.addAccessor(
         transformedMeshData.positions,
@@ -16177,10 +16210,8 @@ var GLTFBuilder = class {
     const meshIndex = this.meshes.length;
     const primitives = [];
     for (const [faceName, faceData] of Object.entries(faceMeshes)) {
-      const transformedFaceData = transformMesh(
-        faceData,
-        box.center,
-        box.rotation
+      const transformedFaceData = convertMeshToGLTFOrientation(
+        transformMesh(faceData, box.center, box.rotation)
       );
       const positionAccessorIndex = this.addAccessor(
         transformedFaceData.positions,

package/dist/svg-to-png-XFKMCXOE.js

@@ -0,0 +1,71 @@
+import {
+  tscircuit_font_default
+} from "./chunk-W5ZY3YD5.js";
+import "./chunk-QGM4M3NI.js";
+
+// lib/utils/svg-to-png.ts
+import { Resvg } from "@resvg/resvg-js";
+var isNode = typeof process !== "undefined" && process.versions && process.versions.node;
+async function svgToPng(svgString, options = {}) {
+  const fontBuffer = Buffer.from(tscircuit_font_default, "base64");
+  let tempFontPath;
+  let cleanupFn;
+  if (isNode) {
+    try {
+      const [fs, os, path] = await Promise.all([
+        import("fs"),
+        import("os"),
+        import("path")
+      ]);
+      const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "resvg-font-"));
+      tempFontPath = path.join(tempDir, "tscircuit-font.ttf");
+      fs.writeFileSync(tempFontPath, fontBuffer);
+      cleanupFn = () => {
+        try {
+          fs.unlinkSync(tempFontPath);
+        } catch {
+        }
+      };
+    } catch (err) {
+      console.warn(
+        "Failed to create temporary font file, falling back to browser mode:",
+        err
+      );
+    }
+  }
+  try {
+    const opts = {
+      background: options.background,
+      fitTo: options.width ? {
+        mode: "width",
+        value: options.width
+      } : options.height ? {
+        mode: "height",
+        value: options.height
+      } : void 0,
+      font: {
+        fontFiles: tempFontPath ? [tempFontPath, ...options.fonts || []] : options.fonts || [],
+        loadSystemFonts: false,
+        defaultFontFamily: "TscircuitAlphabet",
+        monospaceFamily: "TscircuitAlphabet",
+        sansSerifFamily: "TscircuitAlphabet"
+      }
+    };
+    const resvg = new Resvg(svgString, opts);
+    const pngData = resvg.render();
+    const pngBuffer = pngData.asPng();
+    return Buffer.from(pngBuffer);
+  } finally {
+    if (cleanupFn) {
+      cleanupFn();
+    }
+  }
+}
+async function svgToPngDataUrl(svgString, options = {}) {
+  const pngBuffer = await svgToPng(svgString, options);
+  return `data:image/png;base64,${pngBuffer.toString("base64")}`;
+}
+export {
+  svgToPng,
+  svgToPngDataUrl
+};

package/dist/svg-to-png-browser-VH734VGT.js

@@ -0,0 +1,99 @@
+import {
+  tscircuit_font_default
+} from "./chunk-W5ZY3YD5.js";
+import {
+  __require
+} from "./chunk-QGM4M3NI.js";
+
+// lib/utils/svg-to-png-browser.ts
+import { Resvg, initWasm } from "@resvg/resvg-wasm";
+var wasmInitialized = false;
+async function ensureWasmInitialized() {
+  if (!wasmInitialized) {
+    try {
+      if (typeof process !== "undefined" && process.versions?.node) {
+        const { readFileSync } = await import("fs");
+        const { dirname, join } = await import("path");
+        try {
+          const packagePath = __require.resolve("@resvg/resvg-wasm/package.json");
+          const wasmPath = join(dirname(packagePath), "index_bg.wasm");
+          const wasmBuffer = readFileSync(wasmPath);
+          await initWasm(wasmBuffer);
+        } catch (pathError) {
+          try {
+            const modulePath = __require.resolve("@resvg/resvg-wasm");
+            const wasmPath = join(dirname(modulePath), "index_bg.wasm");
+            const wasmBuffer = readFileSync(wasmPath);
+            await initWasm(wasmBuffer);
+          } catch (fallbackError) {
+            throw new Error(
+              `Failed to locate WASM file: ${pathError.message}, ${fallbackError.message}`
+            );
+          }
+        }
+      } else {
+        try {
+          const wasmUrl = await import("@resvg/resvg-wasm/index_bg.wasm?url");
+          await initWasm(fetch(wasmUrl.default));
+        } catch {
+          await initWasm(
+            fetch("https://unpkg.com/@resvg/resvg-wasm@2.6.2/index_bg.wasm")
+          );
+        }
+      }
+      wasmInitialized = true;
+    } catch (error) {
+      console.error("Failed to initialize WASM:", error);
+      throw error;
+    }
+  }
+}
+async function svgToPng(svgString, options = {}) {
+  await ensureWasmInitialized();
+  const base64ToUint8Array = (base64) => {
+    const binaryString = atob(base64);
+    const len = binaryString.length;
+    const bytes = new Uint8Array(len);
+    for (let i = 0; i < len; i++) {
+      bytes[i] = binaryString.charCodeAt(i);
+    }
+    return bytes;
+  };
+  const fontBuffer = base64ToUint8Array(tscircuit_font_default);
+  const opts = {
+    background: options.background,
+    font: {
+      loadSystemFonts: false,
+      fontBuffers: [fontBuffer],
+      defaultFontFamily: "TscircuitAlphabet",
+      monospaceFamily: "TscircuitAlphabet",
+      sansSerifFamily: "TscircuitAlphabet"
+    },
+    fitTo: options.width ? {
+      mode: "width",
+      value: options.width
+    } : options.height ? {
+      mode: "height",
+      value: options.height
+    } : void 0
+  };
+  const resvg = new Resvg(svgString, opts);
+  const pngData = resvg.render();
+  const pngBuffer = pngData.asPng();
+  return pngBuffer;
+}
+async function svgToPngDataUrl(svgString, options = {}) {
+  const pngBuffer = await svgToPng(svgString, options);
+  let binary = "";
+  const bytes = new Uint8Array(pngBuffer);
+  const len = bytes.byteLength;
+  for (let i = 0; i < len; i++) {
+    binary += String.fromCharCode(bytes[i]);
+  }
+  const base64 = btoa(binary);
+  return `data:image/png;base64,${base64}`;
+}
+export {
+  svgToPng,
+  svgToPngDataUrl
+};

package/package.json

@@ -2,12 +2,13 @@
   "name": "circuit-json-to-gltf",
   "main": "dist/index.js",
   "type": "module",
-  "version": "0.0.34",
+  "version": "0.0.36",
   "scripts": {
     "test": "bun test tests/",
     "format": "biome format --write .",
     "format:check": "biome format .",
     "build:site": "cosmos-export",
+    "build:font": "bun scripts/encode-font.ts",
     "start": "cosmos",
     "build": "tsup-node"
   },
@@ -24,6 +25,7 @@
     "@google/model-viewer": "^4.1.0",
     "@resvg/resvg-js": "^2.6.2",
     "@resvg/resvg-wasm": "^2.6.2",
+    "@tscircuit/alphabet": "^0.0.8",
     "@tscircuit/circuit-json-util": "^0.0.72",
     "@types/bun": "latest",
     "@types/react": "^19.1.9",

package/dist/svg-to-png-FCHG2ZUX.js

@@ -1,31 +0,0 @@
-import "./chunk-JSBRDJBE.js";
-
-// lib/utils/svg-to-png.ts
-import { Resvg } from "@resvg/resvg-js";
-async function svgToPng(svgString, options = {}) {
-  const opts = {
-    background: options.background,
-    fitTo: options.width ? {
-      mode: "width",
-      value: options.width
-    } : options.height ? {
-      mode: "height",
-      value: options.height
-    } : void 0,
-    font: {
-      fontFiles: options.fonts || []
-    }
-  };
-  const resvg = new Resvg(svgString, opts);
-  const pngData = resvg.render();
-  const pngBuffer = pngData.asPng();
-  return Buffer.from(pngBuffer);
-}
-async function svgToPngDataUrl(svgString, options = {}) {
-  const pngBuffer = await svgToPng(svgString, options);
-  return `data:image/png;base64,${pngBuffer.toString("base64")}`;
-}
-export {
-  svgToPng,
-  svgToPngDataUrl
-};