@tileflow/dev 0.1.0-alpha.3 → 0.1.0-alpha.31

package/dist/preview-assets-MVUJJ5XR.js

@@ -0,0 +1,148 @@
+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;
+var localPmtilesJavaScript;
+var localFflateJavaScript;
+function getTileflowPreviewRuntimeResponse(path) {
+  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 === "/__runtime/pmtiles.js") {
+    return textAssetResponse(getLocalPmtilesAsset(), "text/javascript; charset=utf-8");
+  }
+  if (path === "/__runtime/fflate.js") {
+    return textAssetResponse(getLocalFflateAsset(), "text/javascript; charset=utf-8");
+  }
+  if (path === "/__runtime/three-addons/libs/draco/gltf/draco_decoder.wasm") {
+    return binaryAssetResponse(
+      getLocalThreeAddonBinaryAsset("libs/draco/gltf/draco_decoder.wasm"),
+      "application/wasm"
+    );
+  }
+  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 getLocalThreeAddonBinaryAsset(relativePath) {
+  if (!/^[A-Za-z0-9_./-]+\.wasm$/.test(relativePath) || relativePath.includes("..")) {
+    throw new Error("Invalid Three.js binary 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 binary addon path.");
+  return readFileSync(assetPath);
+}
+function getLocalPmtilesAsset() {
+  if (localPmtilesJavaScript !== void 0) return localPmtilesJavaScript;
+  const packagePath = localRequire.resolve("pmtiles/package.json");
+  localPmtilesJavaScript = readFileSync(
+    join(dirname(packagePath), "dist", "esm", "index.js"),
+    "utf8"
+  );
+  return localPmtilesJavaScript;
+}
+function getLocalFflateAsset() {
+  if (localFflateJavaScript !== void 0) return localFflateJavaScript;
+  const commonJsPath = localRequire.resolve("fflate");
+  localFflateJavaScript = readFileSync(
+    join(dirname(dirname(commonJsPath)), "esm", "browser.js"),
+    "utf8"
+  );
+  return localFflateJavaScript;
+}
+function textAssetResponse(body, contentType) {
+  return new Response(body, {
+    headers: {
+      "Access-Control-Allow-Origin": "*",
+      "Cache-Control": "no-store",
+      "Content-Type": contentType
+    }
+  });
+}
+function binaryAssetResponse(body, contentType) {
+  return new Response(new Uint8Array(body), {
+    headers: {
+      "Access-Control-Allow-Origin": "*",
+      "Cache-Control": "no-store",
+      "Content-Type": contentType
+    }
+  });
+}
+export {
+  getTileflowPreviewRuntimeResponse
+};

package/dist/preview.d.ts

@@ -0,0 +1,71 @@
+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[]): string;
+
+type TileflowLandmarkAxisConvention = 'ENU_Z_UP' | 'EUN_Y_UP' | 'EUS_Y_UP';
+type TileflowLandmarkArchive = {
+    bytes: number;
+    id: string;
+    sha256: string;
+    url: string;
+};
+type TileflowLandmarkModel = {
+    archive: TileflowLandmarkArchive;
+    archiveId: string;
+    axisConvention: TileflowLandmarkAxisConvention;
+    bytes: number;
+    key: string;
+    minzoom: number;
+    sha256: string;
+    x: number;
+    y: number;
+    z: number;
+};
+type TileflowLandmark = {
+    bounds: [number, number, number, number];
+    center: [number, number];
+    id: string;
+    models: TileflowLandmarkModel[];
+    priority: number;
+};
+type TileflowLandmarkManifestV2 = {
+    archives: TileflowLandmarkArchive[];
+    id: string;
+    landmarks: TileflowLandmark[];
+    maximumCachedModels: number;
+    maximumVisibleModels: number;
+    minzoom: number;
+    schemaVersion: 2;
+};
+/** 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>;
+/**
+ * Validates the browser preview's bounded v2 PMTiles landmark contract. Keep this function
+ * self-contained: the preview serializes it into its isolated browser document.
+ */
+declare function normalizeTileflowLandmarkManifest(candidate: unknown, manifestUrl: string): TileflowLandmarkManifestV2;
+
+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 TileflowLandmark, type TileflowLandmarkArchive, type TileflowLandmarkAxisConvention, type TileflowLandmarkManifestV2, type TileflowLandmarkModel, type TileflowPreviewSelection, TileflowPreviewSelectionError, normalizeTileflowLandmarkManifest, readBoundedTileflowJsonResponse, readBoundedTileflowResponse, renderTileflowPreviewHtml, resolveTileflowPreview };