@tileflow/static 0.1.0-alpha.2 → 0.1.0-alpha.21

package/dist/chunk-KPT7PASB.js

@@ -0,0 +1,122 @@
+import {
+  normalizeStaticOverlay,
+  roundNumber
+} from "./chunk-MGQCHCU3.js";
+
+// src/overlays.ts
+function line(input) {
+  return normalizeStaticOverlay({ ...input, type: "line" });
+}
+function circle(input) {
+  return normalizeStaticOverlay({ ...input, type: "circle" });
+}
+function marker(input) {
+  return normalizeStaticOverlay({ ...input, type: "marker" });
+}
+function polygon(input) {
+  return normalizeStaticOverlay({ ...input, type: "polygon" });
+}
+function compileStaticOverlays(overlays, options = {}) {
+  if (options.longitudeOffsets !== void 0 && (options.longitudeOffsets.length !== overlays.length || options.longitudeOffsets.some(
+    (offset) => !Number.isInteger(offset) || Math.abs(offset) > 360 || offset % 360 !== 0
+  ))) {
+    throw new Error(
+      "Static overlay longitude offsets must contain one -360, 0, or 360 per overlay"
+    );
+  }
+  const sources = {};
+  const layers = [];
+  for (const [index, overlay] of overlays.entries()) {
+    const longitudeOffset = options.longitudeOffsets?.[index] ?? 0;
+    const id = safeLayerId(`overlay-${index + 1}-${overlay.id ?? overlay.type}`);
+    const sourceId = `${id}-source`;
+    if (overlay.type === "line") {
+      sources[sourceId] = {
+        data: feature("LineString", shiftLongitudes(overlay.coordinates, longitudeOffset)),
+        type: "geojson"
+      };
+      layers.push({
+        id,
+        layout: { "line-cap": "round", "line-join": "round" },
+        paint: {
+          "line-color": overlay.color,
+          "line-opacity": overlay.opacity,
+          "line-width": overlay.width
+        },
+        source: sourceId,
+        type: "line"
+      });
+      continue;
+    }
+    if (overlay.type === "polygon") {
+      sources[sourceId] = {
+        data: feature("Polygon", shiftLongitudes(overlay.coordinates, longitudeOffset)),
+        type: "geojson"
+      };
+      layers.push({
+        id,
+        paint: {
+          "fill-color": overlay.fill,
+          "fill-opacity": overlay.opacity
+        },
+        source: sourceId,
+        type: "fill"
+      });
+      if (overlay.stroke && overlay.strokeWidth > 0) {
+        layers.push({
+          id: `${id}-stroke`,
+          layout: { "line-cap": "round", "line-join": "round" },
+          paint: {
+            "line-color": overlay.stroke,
+            "line-width": overlay.strokeWidth
+          },
+          source: sourceId,
+          type: "line"
+        });
+      }
+      continue;
+    }
+    sources[sourceId] = {
+      data: feature("Point", shiftLongitudes(overlay.coordinate, longitudeOffset)),
+      type: "geojson"
+    };
+    layers.push({
+      id,
+      paint: {
+        "circle-color": overlay.color,
+        "circle-opacity": overlay.type === "circle" ? overlay.opacity : 1,
+        "circle-radius": overlay.radius,
+        "circle-stroke-color": overlay.strokeColor ?? overlay.color,
+        "circle-stroke-width": overlay.strokeWidth
+      },
+      source: sourceId,
+      type: "circle"
+    });
+  }
+  return { layers, sources };
+}
+function shiftLongitudes(value, offset) {
+  if (!Array.isArray(value)) return value;
+  if (value.length === 2 && typeof value[0] === "number" && typeof value[1] === "number") {
+    return [roundNumber(value[0] + offset), value[1]];
+  }
+  return value.map((entry) => shiftLongitudes(entry, offset));
+}
+function feature(type, coordinates) {
+  return {
+    geometry: { coordinates, type },
+    properties: {},
+    type: "Feature"
+  };
+}
+function safeLayerId(value) {
+  return value.replace(/[^a-zA-Z0-9_-]/g, "-").slice(0, 80);
+}
+
+export {
+  line,
+  circle,
+  marker,
+  polygon,
+  compileStaticOverlays
+};

package/dist/chunk-MGQCHCU3.js

@@ -0,0 +1,228 @@
+// src/canonical.ts
+function stableStringify(value) {
+  return JSON.stringify(sortJson(value));
+}
+function roundNumber(value) {
+  return Number(value.toFixed(6));
+}
+function stripUndefined(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return value;
+  }
+  return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== void 0));
+}
+function jsonByteLength(value) {
+  return new TextEncoder().encode(JSON.stringify(value)).length;
+}
+async function hashStableValue(value) {
+  const bytes = new TextEncoder().encode(stableStringify(value));
+  const digest = await crypto.subtle.digest("SHA-256", bytes);
+  return base64Url(new Uint8Array(digest));
+}
+function isSafeHttpUrl(value) {
+  try {
+    const url = new URL(value);
+    return ["http:", "https:"].includes(url.protocol) && !url.username && !url.password && !url.hash;
+  } catch {
+    return false;
+  }
+}
+function sortJson(value) {
+  if (Array.isArray(value)) {
+    return value.map(sortJson);
+  }
+  if (value && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, entry]) => [key, sortJson(entry)])
+    );
+  }
+  return value;
+}
+function base64Url(bytes) {
+  let binary = "";
+  for (const byte of bytes) {
+    binary += String.fromCharCode(byte);
+  }
+  return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
+}
+
+// src/scene-contract.ts
+import { z } from "zod";
+var staticSceneSchemaVersion = 1;
+var MAX_OVERLAY_LATITUDE = 85.051129;
+var staticSceneLimits = {
+  maxDimension: 1280,
+  maxGeoJsonBytes: 96e3,
+  maxOverlays: 24,
+  maxPathCoordinates: 2e3,
+  maxPhysicalPixels: 1280 * 1280,
+  minDimension: 64
+};
+var coordinateSchema = z.tuple([z.number().finite(), z.number().finite()]).refine(([lng, lat]) => lng >= -180 && lng <= 180 && lat >= -90 && lat <= 90, {
+  message: "Expected [lng, lat] within world bounds"
+});
+var overlayCoordinateSchema = coordinateSchema.refine(
+  ([, latitude]) => Math.abs(latitude) <= MAX_OVERLAY_LATITUDE,
+  {
+    message: `Static overlay latitude must be within \xB1${MAX_OVERLAY_LATITUDE}\xB0`
+  }
+);
+var colorSchema = z.string().regex(/^#(?:[0-9a-fA-F]{3}|[0-9a-fA-F]{6})$/, {
+  message: "Expected a hex color like #C6A15B"
+});
+var portableIdSchema = z.string().min(1).max(64).regex(/^[a-z][a-z0-9-]{0,63}$/u, {
+  message: "Expected lowercase kebab-case beginning with a letter"
+}).refine(
+  (name) => !["constructor", "prototype"].includes(name) && !/^(?:AUX|CON|NUL|PRN|COM[1-9]|LPT[1-9])$/i.test(name),
+  "Expected a portable identifier that is not a reserved filename or prototype key"
+);
+var concreteThemeSchema = portableIdSchema.refine((value) => value !== "system", {
+  message: 'Static maps require a concrete theme; "system" is browser-only'
+});
+var sizeSchema = z.object({
+  dpr: z.literal(1).optional(),
+  height: z.number().int().min(staticSceneLimits.minDimension).max(staticSceneLimits.maxDimension),
+  width: z.number().int().min(staticSceneLimits.minDimension).max(staticSceneLimits.maxDimension)
+}).refine(
+  (size) => size.width * size.height * (size.dpr ?? 1) <= staticSceneLimits.maxPhysicalPixels,
+  {
+    message: "Static map exceeds the maximum render pixel budget"
+  }
+);
+var centerCameraSchema = z.object({
+  bearing: z.number().finite().min(-180).max(180).optional(),
+  center: coordinateSchema,
+  type: z.literal("center"),
+  zoom: z.number().finite().min(0).max(22)
+});
+var boundsCameraSchema = z.object({
+  bearing: z.number().finite().min(-180).max(180).optional(),
+  bounds: z.tuple([z.number().finite(), z.number().finite(), z.number().finite(), z.number().finite()]).refine(
+    ([west, south, east, north]) => west >= -180 && west <= 180 && east >= -180 && east <= 180 && south >= -90 && south <= 90 && north >= -90 && north <= 90 && west !== east && south !== north,
+    { message: "Expected bounds as [west, south, east, north]" }
+  ),
+  padding: z.number().int().min(0).max(256).optional(),
+  type: z.literal("bounds")
+}).refine((camera) => camera.bounds[3] > camera.bounds[1], {
+  message: "Bounds north must be greater than south"
+});
+var staticPaddingSchema = z.object({
+  bottom: z.number().int().nonnegative(),
+  left: z.number().int().nonnegative(),
+  right: z.number().int().nonnegative(),
+  top: z.number().int().nonnegative()
+}).strict();
+var autoPaddingInputSchema = z.union([
+  z.number().int().nonnegative(),
+  z.object({
+    bottom: z.number().int().nonnegative().optional(),
+    left: z.number().int().nonnegative().optional(),
+    right: z.number().int().nonnegative().optional(),
+    top: z.number().int().nonnegative().optional()
+  }).strict()
+]);
+var autoCameraSchema = z.object({
+  bearing: z.number().finite().min(-180).max(180).optional(),
+  maxZoom: z.number().finite().min(0).max(22).optional(),
+  padding: autoPaddingInputSchema.optional(),
+  type: z.literal("auto")
+});
+var lineOverlaySchema = z.object({
+  color: colorSchema.default("#C6A15B"),
+  coordinates: z.array(overlayCoordinateSchema).min(2).max(staticSceneLimits.maxPathCoordinates),
+  id: z.string().trim().min(1).max(64).optional(),
+  opacity: z.number().finite().min(0).max(1).default(1),
+  type: z.literal("line"),
+  width: z.number().finite().min(0.5).max(32).default(4)
+});
+var circleOverlaySchema = z.object({
+  color: colorSchema.default("#C6A15B"),
+  coordinate: overlayCoordinateSchema,
+  id: z.string().trim().min(1).max(64).optional(),
+  opacity: z.number().finite().min(0).max(1).default(1),
+  radius: z.number().finite().min(1).max(64).default(6),
+  strokeColor: colorSchema.optional(),
+  strokeWidth: z.number().finite().min(0).max(16).default(0),
+  type: z.literal("circle")
+});
+var markerOverlaySchema = z.object({
+  color: colorSchema.default("#C6A15B"),
+  coordinate: overlayCoordinateSchema,
+  id: z.string().trim().min(1).max(64).optional(),
+  radius: z.number().finite().min(2).max(64).default(8),
+  strokeColor: colorSchema.default("#ffffff"),
+  strokeWidth: z.number().finite().min(0).max(16).default(2),
+  type: z.literal("marker")
+});
+var polygonRingSchema = z.array(overlayCoordinateSchema).min(4).max(staticSceneLimits.maxPathCoordinates).refine(
+  (ring) => {
+    const first = ring[0];
+    const last = ring[ring.length - 1];
+    return Boolean(first && last && first[0] === last[0] && first[1] === last[1]);
+  },
+  { message: "Polygon rings must end at their starting coordinate" }
+);
+var polygonOverlaySchema = z.object({
+  coordinates: z.array(polygonRingSchema).min(1).max(16),
+  fill: colorSchema.default("#C6A15B"),
+  id: z.string().trim().min(1).max(64).optional(),
+  opacity: z.number().finite().min(0).max(1).default(0.28),
+  stroke: colorSchema.optional(),
+  strokeWidth: z.number().finite().min(0).max(16).default(0),
+  type: z.literal("polygon")
+});
+var staticOverlaySchema = z.discriminatedUnion("type", [
+  lineOverlaySchema,
+  circleOverlaySchema,
+  markerOverlaySchema,
+  polygonOverlaySchema
+]);
+var staticSceneSchema = z.object({
+  camera: z.discriminatedUnion("type", [centerCameraSchema, boundsCameraSchema, autoCameraSchema]),
+  map: portableIdSchema,
+  overlays: z.array(staticOverlaySchema).max(staticSceneLimits.maxOverlays).default([]),
+  size: sizeSchema,
+  theme: concreteThemeSchema
+});
+
+// src/overlay-normalization.ts
+function normalizeStaticOverlay(overlay) {
+  const parsed = staticOverlaySchema.parse(overlay);
+  const normalized = stripUndefined({ ...parsed });
+  if ("coordinate" in normalized) {
+    normalized.coordinate = normalizeStaticCoordinate(normalized.coordinate);
+  }
+  if ("coordinates" in normalized) {
+    normalized.coordinates = normalizeStaticCoordinates(normalized.coordinates);
+  }
+  return normalized;
+}
+function normalizeStaticCoordinate(coordinate) {
+  return [roundNumber(coordinate[0]), roundNumber(coordinate[1])];
+}
+function normalizeStaticCoordinates(value) {
+  if (!Array.isArray(value)) {
+    return value;
+  }
+  if (value.length === 2 && typeof value[0] === "number" && typeof value[1] === "number") {
+    return normalizeStaticCoordinate(value);
+  }
+  return value.map(normalizeStaticCoordinates);
+}
+
+export {
+  stableStringify,
+  roundNumber,
+  stripUndefined,
+  jsonByteLength,
+  hashStableValue,
+  isSafeHttpUrl,
+  staticSceneSchemaVersion,
+  MAX_OVERLAY_LATITUDE,
+  staticSceneLimits,
+  staticPaddingSchema,
+  staticOverlaySchema,
+  staticSceneSchema,
+  normalizeStaticOverlay,
+  normalizeStaticCoordinate
+};