gds-lens 0.1.0

package/dist/inline-wasm/gds-lens-host.js

@@ -0,0 +1,82 @@
+(() => {
+  // src/hosts/browser.js
+  function createBrowserHost() {
+    const VIEWS_KEY = "gds-lens:named-views";
+    const readViews = () => {
+      try {
+        const parsed = JSON.parse(localStorage.getItem(VIEWS_KEY) || "[]");
+        return Array.isArray(parsed) ? parsed : [];
+      } catch {
+        return [];
+      }
+    };
+    const pickText = (accept) => new Promise((resolve) => {
+      const input = document.createElement("input");
+      input.type = "file";
+      input.accept = accept;
+      input.addEventListener("change", () => {
+        const file = input.files && input.files[0];
+        if (!file) return resolve(null);
+        file.text().then(
+          (text) => resolve({ name: file.name, text }),
+          () => resolve(null)
+        );
+      });
+      input.click();
+    });
+    return {
+      pickLyp: () => pickText(".lyp"),
+      pickMarkers: () => pickText(".lyrdb,.txt,.db"),
+      loadViews: async () => readViews(),
+      saveViews: (views) => {
+        try {
+          localStorage.setItem(VIEWS_KEY, JSON.stringify(views));
+        } catch {
+        }
+      },
+      // A plain page has to be told which layout to show. Three ways in,
+      // covering the three situations a page is actually in: a URL for an
+      // embed, a drop for a scratch look at a local file, and a direct call
+      // for a page driving the viewer itself (or a test).
+      connect: (viewer) => {
+        window.gdsLens = viewer;
+        const loadBytes = (bytes) => viewer.load(bytes, { reload: false });
+        const src = new URLSearchParams(location.search).get("src");
+        if (src) {
+          fetch(src).then((response) => {
+            if (!response.ok) throw new Error(`HTTP ${response.status}`);
+            return response.arrayBuffer();
+          }).then((buffer) => loadBytes(new Uint8Array(buffer))).catch((err) => viewer.showError(`Could not fetch ${src}: ${err.message || err}`));
+        }
+        const bindDrop = (target) => {
+          if (!target) return;
+          target.addEventListener("dragover", (event) => event.preventDefault());
+          target.addEventListener("drop", (event) => {
+            event.preventDefault();
+            const file = event.dataTransfer && event.dataTransfer.files[0];
+            if (!file) return;
+            file.arrayBuffer().then(
+              (buffer) => loadBytes(new Uint8Array(buffer)),
+              (err) => viewer.showError(`Could not read ${file.name}: ${err.message || err}`)
+            );
+          });
+        };
+        bindDrop(viewer.element || document.querySelector("gds-lens"));
+        if (typeof viewer.onAdopt === "function") viewer.onAdopt(bindDrop);
+      },
+      promptViewName: async (existingNames) => {
+        const name = window.prompt(
+          existingNames.length ? `Name this view (reusing a name replaces it):
+${existingNames.join(", ")}` : "Name this view:"
+        );
+        return name && name.trim() ? name.trim() : null;
+      }
+      // No requestReload / setAutoReload / onGotoResult: a plain page has no
+      // file on disk to watch and no command palette to answer. The viewer
+      // hides the stale-file banner when requestReload is missing.
+    };
+  }
+  if (typeof window !== "undefined" && !window.gdsLensHost) {
+    window.gdsLensHost = createBrowserHost();
+  }
+})();

package/dist/inline-wasm/gds-lens-worker.js

@@ -0,0 +1,118 @@
+(() => {
+  // src/load-errors.js
+  var OOM_PATTERN = /memory access out of bounds|Cannot enlarge memory|Aborted\(|out of memory|Array buffer allocation failed|Invalid (typed )?array length/i;
+  var OOM_MESSAGE = "Out of memory: this layout is too large to open.\n\nThe viewer parses layouts in a 32-bit WebAssembly module, so the whole flattened design has to fit in 4 GB. Layouts that reuse cells (arrays and repeated placements) go much further than fully flattened ones, because a repeated cell is drawn as GPU instances instead of being copied for every placement.";
+  function describeLoadFailure(err, prefix) {
+    const text = err && err.message ? err.message : String(err);
+    if (OOM_PATTERN.test(text)) return `${OOM_MESSAGE}
+
+(${text})`;
+    return prefix ? `${prefix}: ${text}` : text;
+  }
+
+  // src/wasm-worker.js
+  function safeStringify(arg) {
+    if (typeof arg === "string") return arg;
+    if (arg instanceof Error) return arg.stack || arg.message;
+    try {
+      return JSON.stringify(arg);
+    } catch {
+      return String(arg);
+    }
+  }
+  var originalLog = console.log.bind(console);
+  var originalError = console.error.bind(console);
+  console.log = (...args) => {
+    originalLog(...args);
+    try {
+      postMessage({ type: "gdsLog", level: "log", text: args.map(safeStringify).join(" ") });
+    } catch {
+    }
+  };
+  console.error = (...args) => {
+    originalError(...args);
+    try {
+      postMessage({ type: "gdsLog", level: "error", text: args.map(safeStringify).join(" ") });
+    } catch {
+    }
+  };
+  console.log("[GDS worker] script started executing, typeof createGdstkModule:", typeof createGdstkModule);
+  self.onerror = (msg, url, line, col, err) => {
+    console.error("[GDS worker] self.onerror:", msg, "at", url + ":" + line + ":" + col, err && err.stack);
+  };
+  self.addEventListener("unhandledrejection", (event) => {
+    console.error("[GDS worker] unhandled promise rejection inside worker:", event.reason);
+  });
+  function moduleArgs() {
+    const base = self.gdsLensScriptBase;
+    if (!base) return {};
+    return { locateFile: (file) => new URL(file, base).href };
+  }
+  console.log("[GDS worker] registering onmessage handler");
+  self.onmessage = (event) => {
+    const message = event.data;
+    console.log("[GDS worker] received message, type:", message.type);
+    if (message.type !== "parse") return;
+    console.log("[GDS worker] fileData byteLength:", message.fileData && message.fileData.byteLength);
+    console.log("[GDS worker] calling createGdstkModule()...");
+    createGdstkModule(moduleArgs()).then((Module) => {
+      console.log("[GDS worker] createGdstkModule() resolved, Module keys:", Object.keys(Module).filter((k) => typeof Module[k] === "function"));
+      console.log("[GDS worker] writing /input.layout to MEMFS...");
+      Module.FS.writeFile("/input.layout", new Uint8Array(message.fileData));
+      console.log("[GDS worker] calling Module.parseGdsToLayers('/input.layout')...");
+      const result = Module.parseGdsToLayers("/input.layout");
+      console.log("[GDS worker] parseGdsToLayers returned, ok:", result.ok, "format:", result.format, "error:", result.error);
+      Module.FS.unlink("/input.layout");
+      if (!result.ok) {
+        postMessage({ type: "gdsResult", ok: false, error: result.error });
+        return;
+      }
+      console.log("[GDS worker] layers:", result.layers.length, "instance groups:", result.instanceGroups.length, "labels:", result.totalLabels, "cells:", result.hierarchy.cellCount, "-- posting gdsResult back to main thread");
+      const transferList = [];
+      for (const layer of result.layers) {
+        transferList.push(
+          layer.outlineVertices.buffer,
+          layer.outlineRanges.buffer,
+          layer.fillVertices.buffer
+        );
+        transferList.push(
+          layer.textChars.buffer,
+          layer.textLengths.buffer,
+          layer.textOrigins.buffer,
+          layer.textAnchors.buffer
+        );
+      }
+      for (const group of result.instanceGroups) {
+        transferList.push(group.instances.buffer);
+        for (const layer of group.layers) {
+          transferList.push(
+            layer.outlineVertices.buffer,
+            layer.outlineRanges.buffer,
+            layer.fillVertices.buffer
+          );
+        }
+      }
+      for (const cell of result.hierarchy.cells) {
+        for (const ref of cell.refs) {
+          if (ref.placements) transferList.push(ref.placements.buffer);
+        }
+      }
+      postMessage(
+        {
+          type: "gdsResult",
+          ok: true,
+          layers: result.layers,
+          instanceGroups: result.instanceGroups,
+          hierarchy: result.hierarchy,
+          bbox: result.bbox
+        },
+        transferList
+      );
+      console.log("[GDS worker] postMessage(gdsResult) call returned");
+    }).catch((err) => {
+      console.error("[GDS worker] createGdstkModule() chain rejected:", err, err && err.stack);
+      postMessage({ type: "gdsResult", ok: false, error: describeLoadFailure(err, "Layout worker failed") });
+    });
+  };
+  console.log("[GDS worker] onmessage handler registered, script finished top-level execution");
+})();

package/dist/inline-wasm/gds-lens.html

@@ -0,0 +1,29 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta http-equiv="Content-Security-Policy"
+        content="default-src 'none'; style-src 'unsafe-inline'; script-src 'self' 'wasm-unsafe-eval'; worker-src blob:; connect-src 'self';">
+    <title>GDS Lens</title>
+    <style>
+        /* The page harness only. Everything the viewer itself draws is styled
+           inside its shadow root (see viewer.css), which is why there is so
+           little here: a host page cannot reach in, and this cannot leak out. */
+        html, body { margin: 0; padding: 0; height: 100%; background: #1a1a1a; }
+        gds-lens { display: block; width: 100%; height: 100%; }
+    </style>
+</head>
+<body>
+    <gds-lens></gds-lens>
+
+    <!-- Emscripten's output, loaded as a classic script for the
+         createGdstkModule global it defines. -->
+    <script src="gds-lens-engine.js"></script>
+    <!-- The embedder's ViewerHost. Must precede gds-lens.js, which reads
+         window.gdsLensHost as it starts. Defaults to the plain-page host; a
+         host that needs different services replaces this file, or sets
+         window.gdsLensHost itself and omits it. -->
+    <script src="gds-lens-host.js"></script>
+    <script src="gds-lens.js"></script>
+</body>
+</html>