@tileflow/dev 0.1.0-alpha.4 → 0.1.0-alpha.41

package/dist/inspector-observer.js

@@ -0,0 +1,95 @@
+// src/inspector/observer.ts
+function resourceAddress(input, base = "http://localhost") {
+  try {
+    const url = new URL(input.replace(/^(?:tileflow-pmtiles|pmtiles):\/\//u, ""), base);
+    if (!["http:", "https:"].includes(url.protocol)) return url.protocol;
+    return `${url.origin}${url.pathname}`.slice(0, 2048);
+  } catch {
+    return "(unavailable URL)";
+  }
+}
+function resourceKind(url, initiator = "") {
+  if (/\.(?:pbf|mvt|mlt)(?:$|\?)/iu.test(url)) return /glyph|font/iu.test(url) ? "Font" : "Tile";
+  if (/\.pmtiles(?:$|\?)/iu.test(url)) return "Archive";
+  if (/\/(?:\d+)\/(?:\d+)\/(?:\d+)(?:\.[a-z]+)?(?:$|\?)/iu.test(url)) return "Tile";
+  if (/sprite/iu.test(url)) return "Sprite";
+  if (/\.(?:woff2?|ttf|otf)(?:$|\?)/iu.test(url)) return "Font";
+  if (/\.(?:glb|gltf)(?:$|\?)/iu.test(url)) return "Model";
+  if (/\.json(?:$|\?)/iu.test(url)) return "JSON";
+  return initiator === "script" || /\.m?js(?:$|\?)/iu.test(url) ? "Script" : "Other";
+}
+function createPreviewObserver() {
+  let nextId = 0;
+  const seen = /* @__PURE__ */ new Set();
+  const limit = 2e3;
+  let map;
+  const observer = {
+    records: [],
+    revision: 0,
+    dropped: 0,
+    recording: true,
+    attach(value) {
+      map = value;
+      map.on("data", onData);
+      if (!map.loaded()) map.once("load", onLoad);
+    },
+    clear() {
+      observer.records.length = 0;
+      observer.dropped = 0;
+      observer.revision++;
+    },
+    dispose() {
+      performanceObserver?.disconnect();
+      map?.off("data", onData);
+      map?.off("load", onLoad);
+      seen.clear();
+    }
+  };
+  function onLoad() {
+    observer.mapReadyMs = performance.now();
+  }
+  function record(entry) {
+    if (!observer.recording) return;
+    const key = `${entry.name}|${entry.startTime}|${entry.duration}`;
+    if (seen.has(key)) return;
+    seen.add(key);
+    if (seen.size > limit * 2) seen.delete(seen.values().next().value);
+    const url = resourceAddress(entry.name, location.href);
+    if (/\/__(?:status|events|workbench|inspection)/u.test(url)) return;
+    const sizesAvailable = entry.decodedBodySize > 0 || entry.encodedBodySize > 0;
+    const status = entry.responseStatus;
+    const item = {
+      id: ++nextId,
+      url,
+      name: /\/\d+\/\d+\/\d+(?:\.[a-z]+)?$/iu.exec(url)?.[0].slice(1) || url.split("/").pop() || url,
+      kind: resourceKind(url, entry.initiatorType),
+      transport: "resource",
+      start: Number.isFinite(entry.startTime) ? Math.max(0, entry.startTime) : 0,
+      duration: Number.isFinite(entry.duration) && entry.duration >= 0 ? entry.duration : void 0,
+      status: status ? String(status) : "\u2014",
+      ...sizesAvailable ? { bytes: entry.encodedBodySize, transferred: entry.transferSize } : {}
+    };
+    if (entry.transferSize === 0 && sizesAvailable) item.status = "Cached";
+    observer.records.push(item);
+    if (observer.records.length > limit) {
+      observer.records.shift();
+      observer.dropped++;
+    }
+    observer.revision++;
+  }
+  function onData(event) {
+    const timings = event.resourceTiming;
+    for (const timing of timings || []) record(timing);
+  }
+  const performanceObserver = typeof PerformanceObserver === "undefined" ? void 0 : new PerformanceObserver((list) => {
+    for (const entry of list.getEntries()) record(entry);
+  });
+  performanceObserver?.observe({ type: "resource", buffered: true });
+  addEventListener("pagehide", observer.dispose, { once: true });
+  return observer;
+}
+export {
+  createPreviewObserver,
+  resourceAddress,
+  resourceKind
+};

package/dist/preview-assets-ATLLYY72.js

@@ -0,0 +1,103 @@
+import {
+  isPathWithin
+} from "./chunk-D4OE4ITL.js";
+
+// src/preview-assets.ts
+import { readFileSync } from "fs";
+import { createRequire } from "module";
+import { dirname, join } from "path";
+var localRequire = createRequire(import.meta.url);
+var localMapLibreAssets = /* @__PURE__ */ new Map();
+var localTileflowBrowserJavaScript;
+var localThreeCoreJavaScript;
+var localThreeModuleJavaScript;
+function getTileflowPreviewRuntimeResponse(path) {
+  if (path === "/__runtime/inspector-observer.js") {
+    return textAssetResponse(
+      readFileSync(new URL("../dist/inspector-observer.js", import.meta.url), "utf8"),
+      "text/javascript; charset=utf-8"
+    );
+  }
+  if (path === "/__runtime/maplibre-gl.mjs") {
+    return textAssetResponse(
+      getLocalMapLibreAsset("maplibre-gl.mjs"),
+      "text/javascript; charset=utf-8"
+    );
+  }
+  if (path === "/__runtime/maplibre-gl-worker.mjs") {
+    return textAssetResponse(
+      getLocalMapLibreAsset("maplibre-gl-worker.mjs"),
+      "text/javascript; charset=utf-8"
+    );
+  }
+  if (path === "/__runtime/maplibre-gl.css") {
+    return textAssetResponse(getLocalMapLibreAsset("maplibre-gl.css"), "text/css; charset=utf-8");
+  }
+  if (path === "/__runtime/tileflow-browser.js") {
+    return textAssetResponse(getLocalTileflowBrowserAsset(), "text/javascript; charset=utf-8");
+  }
+  if (path === "/__runtime/three.module.js") {
+    return textAssetResponse(getLocalThreeAsset("module"), "text/javascript; charset=utf-8");
+  }
+  if (path === "/__runtime/three.core.min.js") {
+    return textAssetResponse(getLocalThreeAsset("core"), "text/javascript; charset=utf-8");
+  }
+  if (path.startsWith("/__runtime/three-addons/")) {
+    return textAssetResponse(
+      getLocalThreeAddonAsset(path.slice("/__runtime/three-addons/".length)),
+      "text/javascript; charset=utf-8"
+    );
+  }
+  return void 0;
+}
+function getLocalMapLibreAsset(fileName) {
+  const cached = localMapLibreAssets.get(fileName);
+  if (cached !== void 0) return cached;
+  const source = readFileSync(localRequire.resolve(`maplibre-gl/dist/${fileName}`), "utf8");
+  localMapLibreAssets.set(fileName, source);
+  return source;
+}
+function getLocalTileflowBrowserAsset() {
+  if (localTileflowBrowserJavaScript !== void 0) return localTileflowBrowserJavaScript;
+  const packagePath = localRequire.resolve("@tileflow/core/package.json");
+  localTileflowBrowserJavaScript = readFileSync(
+    join(dirname(packagePath), "dist", "browser.js"),
+    "utf8"
+  );
+  return localTileflowBrowserJavaScript;
+}
+function getLocalThreeAsset(kind) {
+  if (kind === "core" && localThreeCoreJavaScript !== void 0) return localThreeCoreJavaScript;
+  if (kind === "module" && localThreeModuleJavaScript !== void 0)
+    return localThreeModuleJavaScript;
+  const commonJsPath = localRequire.resolve("three");
+  const source = readFileSync(
+    join(dirname(commonJsPath), kind === "core" ? "three.core.min.js" : "three.module.min.js"),
+    "utf8"
+  );
+  if (kind === "core") localThreeCoreJavaScript = source;
+  else localThreeModuleJavaScript = source;
+  return source;
+}
+function getLocalThreeAddonAsset(relativePath) {
+  if (!/^[A-Za-z0-9_./-]+\.js$/.test(relativePath) || relativePath.includes("..")) {
+    throw new Error("Invalid Three.js addon path.");
+  }
+  const commonJsPath = localRequire.resolve("three");
+  const addonRoot = join(dirname(dirname(commonJsPath)), "examples", "jsm");
+  const assetPath = join(addonRoot, relativePath);
+  if (!isPathWithin(addonRoot, assetPath)) throw new Error("Invalid Three.js addon path.");
+  return readFileSync(assetPath, "utf8");
+}
+function textAssetResponse(body, contentType) {
+  return new Response(body, {
+    headers: {
+      "Access-Control-Allow-Origin": "*",
+      "Cache-Control": "no-store",
+      "Content-Type": contentType
+    }
+  });
+}
+export {
+  getTileflowPreviewRuntimeResponse
+};

package/dist/preview.d.ts

@@ -0,0 +1,31 @@
+import { TileflowStyleFontFace, NormalizedTileflowCaptureScene } from '@tileflow/core';
+import { TileflowBuildCatalog } from '@tileflow/core/build';
+
+declare function renderTileflowPreviewHtml(preview: ResolvedTileflowPreview | undefined, basePath: string, initialStatus: unknown, isSemanticPreview: boolean, fontFaces?: readonly TileflowStyleFontFace[], fitViewport?: boolean, controls?: string): string;
+
+/** Reads a response without ever buffering more than the declared bound. */
+declare function readBoundedTileflowResponse(response: Response, maximumBytes: number): Promise<Uint8Array>;
+/** Reads and strictly decodes a bounded UTF-8 JSON response. */
+declare function readBoundedTileflowJsonResponse(response: Response, maximumBytes: number): Promise<unknown>;
+
+type TileflowPreviewSelection = {
+    map?: string;
+    scene?: string;
+    theme?: string;
+};
+type ResolvedTileflowPreview = {
+    camera: NormalizedTileflowCaptureScene['camera'];
+    label: string;
+    mapName: string;
+    themeName: string;
+    /** Every theme of a map preview, in declaration order. A scene owns its theme and omits this. */
+    themeNames?: readonly string[];
+    viewport?: NormalizedTileflowCaptureScene['viewport'];
+};
+declare class TileflowPreviewSelectionError extends Error {
+    readonly code: "PREVIEW_SELECTION_INVALID";
+    constructor(message: string);
+}
+declare function resolveTileflowPreview(project: TileflowBuildCatalog, selection?: TileflowPreviewSelection): ResolvedTileflowPreview;
+
+export { type ResolvedTileflowPreview, type TileflowPreviewSelection, TileflowPreviewSelectionError, readBoundedTileflowJsonResponse, readBoundedTileflowResponse, renderTileflowPreviewHtml, resolveTileflowPreview };