@tileflow/core 0.1.0-alpha.47 → 0.1.0-alpha.48

package/dist/index.js

@@ -2252,7 +2252,13 @@ function mixTileflowColours(from, to, t) {
   const a = oklab(from);
   const b = oklab(to);
   if (!a || !b) return void 0;
-  return colourFromOklab(a.map((value, channel) => value + (b[channel] - value) * t));
+  const alpha2 = a[3] + (b[3] - a[3]) * t;
+  if (alpha2 <= 0) return "rgba(0, 0, 0, 0)";
+  const channels = a.slice(0, 3).map((value, channel) => {
+    const from2 = value * a[3];
+    return (from2 + (b[channel] * b[3] - from2) * t) / alpha2;
+  });
+  return colourFromOklab([...channels, alpha2]);
 }
 function oklab(colour) {
   const cached = oklabCache.get(colour);
@@ -5828,6 +5834,8 @@ var tileflowWorldLayerFields = Object.freeze({
     name: { type: "String" },
     "name_<lang>": { type: "String" },
     name_latin: { type: "String" },
+    network: { type: "String" },
+    official: { type: "Number" },
     oneway: { type: "Boolean" },
     outer_radius_m: { type: "Number", required: true },
     radius_m: { type: "Number", required: true },
@@ -14311,7 +14319,7 @@ function asRecord4(value) {
 }
 
 // src/overlays.ts
-init_portable_identity();
+init_portable_identity_rules();
 var tileflowOverlayPlacements = [
   "above-water",
   "below-roads",
@@ -14321,6 +14329,8 @@ var tileflowOverlayPlacements = [
   "above-labels"
 ];
 var tileflowHostedSourceLimit = 16;
+var tileflowInlineGeoJsonByteLimit = 512e3;
+var tileflowClusterMetadataKey = "tileflow:cluster";
 var tilesetIdPattern = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/u;
 function hostedTileset(options) {
   const attribution = options.attribution.trim();
@@ -14352,6 +14362,24 @@ function hostedTileset(options) {
     type
   });
 }
+function geojsonSource(options = {}) {
+  const data = options.data ?? { features: [], type: "FeatureCollection" };
+  if (typeof data === "string") {
+    if (!isHttpsUrl(data)) {
+      throw new Error("Tileflow GeoJSON source URLs must be absolute https:// URLs.");
+    }
+  } else if (!isPlainRecord3(data) || data.type !== "FeatureCollection" || !Array.isArray(data.features)) {
+    throw new Error("Tileflow GeoJSON source data must be a FeatureCollection or an https:// URL.");
+  }
+  assertClusterOptions(options);
+  const attribution = options.attribution?.trim();
+  return Object.freeze({
+    ...attribution ? { attribution } : {},
+    ...pickClusterOptions(options),
+    data: typeof data === "string" ? data : Object.freeze(cloneJson18(data)),
+    kind: "geojson"
+  });
+}
 function maplibreOverlay(options) {
   if (!isTileflowPortableId(options.source)) {
     throw new Error(`Invalid Tileflow overlay source ID: ${options.source}.`);
@@ -14389,6 +14417,109 @@ function maplibreOverlay(options) {
     source: options.source
   });
 }
+function clusterOverlay(options) {
+  const colors = options.colors ?? ["#2563eb", "#7c3aed", "#db2777"];
+  const radii = options.radii ?? [16, 22, 30];
+  const [low, high] = options.steps ?? [100, 750];
+  if (!(low > 0 && high > low) || !radii.every((radius) => radius > 0)) {
+    throw new Error("Tileflow cluster steps must increase and radii must be positive.");
+  }
+  const metadata = (role) => ({
+    [tileflowClusterMetadataKey]: {
+      expandOnClick: options.expandOnClick ?? true,
+      role
+    }
+  });
+  const step2 = (values) => [
+    "step",
+    ["get", "point_count"],
+    values[0],
+    low,
+    values[1],
+    high,
+    values[2]
+  ];
+  return maplibreOverlay({
+    layers: [
+      {
+        filter: ["has", "point_count"],
+        id: `${options.id}-clusters`,
+        metadata: metadata("cluster"),
+        paint: {
+          "circle-color": step2(colors),
+          "circle-radius": step2(radii),
+          "circle-stroke-color": "#ffffff",
+          "circle-stroke-width": 2
+        },
+        type: "circle"
+      },
+      {
+        filter: ["has", "point_count"],
+        id: `${options.id}-cluster-count`,
+        layout: {
+          "text-allow-overlap": true,
+          "text-field": ["get", "point_count_abbreviated"],
+          ...options.font ? { "text-font": [...options.font] } : {},
+          "text-ignore-placement": true,
+          "text-size": 13
+        },
+        metadata: metadata("count"),
+        paint: { "text-color": options.textColor ?? "#ffffff" },
+        type: "symbol"
+      },
+      {
+        filter: ["!", ["has", "point_count"]],
+        id: `${options.id}-points`,
+        metadata: metadata("point"),
+        paint: {
+          "circle-color": options.pointColor ?? colors[0],
+          "circle-radius": 6,
+          "circle-stroke-color": "#ffffff",
+          "circle-stroke-width": 1.5
+        },
+        type: "circle"
+      }
+    ],
+    placement: options.placement,
+    source: options.source
+  });
+}
+function heatmapOverlay(options) {
+  const colors = options.colors ?? [
+    [0, "rgba(33, 102, 172, 0)"],
+    [0.2, "#67a9cf"],
+    [0.4, "#d1e5f0"],
+    [0.6, "#fddbc7"],
+    [0.8, "#ef8a62"],
+    [1, "#b2182b"]
+  ];
+  if (colors.length < 2 || colors.some(([density], index) => {
+    const previous = colors[index - 1]?.[0] ?? -1;
+    return !(density >= 0 && density <= 1 && density > previous);
+  })) {
+    throw new Error("Tileflow heatmap colors need at least two increasing densities from 0 to 1.");
+  }
+  const paint = {
+    "heatmap-color": ["interpolate", ["linear"], ["heatmap-density"], ...colors.flat()],
+    "heatmap-intensity": options.intensity ?? 1,
+    "heatmap-opacity": options.opacity ?? 0.8,
+    "heatmap-radius": options.radius ?? 30,
+    "heatmap-weight": options.weight ?? 1
+  };
+  return maplibreOverlay({
+    layers: [
+      {
+        id: options.id,
+        ...options.maxZoom === void 0 ? {} : { maxzoom: options.maxZoom },
+        paint,
+        ...options.sourceLayer === void 0 ? {} : { "source-layer": options.sourceLayer },
+        type: "heatmap"
+      }
+    ],
+    placement: options.placement,
+    source: options.source
+  });
+}
 function remove() {
   return Object.freeze({ op: "remove" });
 }
@@ -14430,6 +14561,10 @@ function resolveTileflowHostedSources(mapId, sources, reservedSourceIds) {
         `Source ID "${sourceId}" conflicts with a Tileflow source.`
       );
     }
+    if (source.kind === "geojson") {
+      definitions[sourceId] = createTileflowGeoJsonSourceDefinition(source);
+      continue;
+    }
     const duplicate = tilesets.get(source.tileset);
     if (duplicate) {
       throw new TileflowOverlayCompilationError(
@@ -14454,8 +14589,17 @@ function resolveTileflowHostedSources(mapId, sources, reservedSourceIds) {
   }
   return { definitions, identities };
 }
+function createTileflowGeoJsonSourceDefinition(source) {
+  return {
+    ...source.attribution === void 0 ? {} : { attribution: source.attribution },
+    ...pickClusterOptions(source),
+    data: cloneJson18(source.data),
+    type: "geojson"
+  };
+}
 function insertTileflowOverlays(input) {
   const availableSources = new Set(input.sourceIds);
+  const labelFont = readTileflowLabelFont(input.basemapLayers);
   const identities = {};
   const groups = /* @__PURE__ */ new Map();
   const layerIds = new Set(
@@ -14483,8 +14627,17 @@ function insertTileflowOverlays(input) {
         );
       }
       layerIds.add(layer.id);
+      if (readClusterRole(layer) && input.sourceDefinitions?.[overlay.source]?.cluster !== true) {
+        throw new TileflowOverlayCompilationError(
+          "TF_OVERLAY_CLUSTER_SOURCE_INVALID",
+          `${path}.source`,
+          `Cluster overlay "${overlayId}" needs a GeoJSON source declared with cluster: true.`,
+          `Use geojsonSource({cluster: true}) for source "${overlay.source}".`
+        );
+      }
+      const label = readClusterRole(layer) === "count" ? withLabelFont(layer, labelFont, path) : layer;
       return {
-        ...cloneJson18(layer),
+        ...cloneJson18(label),
         source: overlay.source,
         metadata: {
           ...isPlainRecord3(layer.metadata) ? cloneJson18(layer.metadata) : {},
@@ -14508,6 +14661,74 @@ function insertTileflowOverlays(input) {
   }
   return { identities, layers: layers2 };
 }
+function readTileflowLabelFont(layers2) {
+  for (const layer of layers2) {
+    const font = isPlainRecord3(layer.layout) ? layer.layout["text-font"] : void 0;
+    if (Array.isArray(font) && font.length > 0 && font.every((face) => typeof face === "string" && !parseTileflowLineBackgroundFontStack(face))) {
+      return font;
+    }
+  }
+  return void 0;
+}
+function readClusterRole(layer) {
+  const metadata = isPlainRecord3(layer.metadata) ? layer.metadata : void 0;
+  const cluster = metadata?.[tileflowClusterMetadataKey];
+  return isPlainRecord3(cluster) ? cluster.role : void 0;
+}
+function withLabelFont(layer, font, path) {
+  const layout = layer.layout;
+  if (layout["text-font"] !== void 0) return layer;
+  if (!font) {
+    throw new TileflowOverlayCompilationError(
+      "TF_OVERLAY_FONT_UNAVAILABLE",
+      `${path}.font`,
+      `Cluster count layer "${layer.id}" has no label font to share.`,
+      "Pass font to clusterOverlay() with a stack the map declares."
+    );
+  }
+  return { ...layer, layout: { ...layout, "text-font": [...font] } };
+}
+function pickClusterOptions(source) {
+  return {
+    ...source.cluster === void 0 ? {} : { cluster: source.cluster },
+    ...source.clusterMaxZoom === void 0 ? {} : { clusterMaxZoom: source.clusterMaxZoom },
+    ...source.clusterMinPoints === void 0 ? {} : { clusterMinPoints: source.clusterMinPoints },
+    ...source.clusterProperties === void 0 ? {} : { clusterProperties: cloneJson18(source.clusterProperties) },
+    ...source.clusterRadius === void 0 ? {} : { clusterRadius: source.clusterRadius }
+  };
+}
+function assertClusterOptions(options) {
+  const { cluster, clusterMaxZoom, clusterMinPoints, clusterProperties, clusterRadius } = options;
+  if (cluster !== void 0 && typeof cluster !== "boolean") {
+    throw new Error("Tileflow GeoJSON cluster must be a boolean.");
+  }
+  if (clusterRadius !== void 0 && !(Number.isFinite(clusterRadius) && clusterRadius > 0)) {
+    throw new Error("Tileflow clusterRadius must be a positive number of pixels.");
+  }
+  if (clusterMaxZoom !== void 0 && !(Number.isFinite(clusterMaxZoom) && clusterMaxZoom >= 0 && clusterMaxZoom <= 24)) {
+    throw new Error("Tileflow clusterMaxZoom must be a zoom from 0 to 24.");
+  }
+  if (clusterMinPoints !== void 0 && !(Number.isInteger(clusterMinPoints) && clusterMinPoints >= 2)) {
+    throw new Error("Tileflow clusterMinPoints must be an integer of at least 2.");
+  }
+  if (!cluster && [clusterMaxZoom, clusterMinPoints, clusterProperties, clusterRadius].some(
+    (value) => value !== void 0
+  )) {
+    throw new Error("Tileflow cluster options require cluster: true.");
+  }
+  for (const [name, value] of Object.entries(clusterProperties ?? {})) {
+    if (!Array.isArray(value) || value.length !== 2) {
+      throw new Error(`Tileflow clusterProperties.${name} must be [operator, mapExpression].`);
+    }
+  }
+}
+function isHttpsUrl(value) {
+  try {
+    return new URL(value).protocol === "https:";
+  } catch {
+    return false;
+  }
+}
 function isSafeLocalPmtilesPath(value) {
   if (typeof value !== "string" || value.length > 512 || !value.endsWith(".pmtiles") || value.includes("\\") || /[\p{Cc}?#]/u.test(value)) {
     return false;
@@ -19639,7 +19860,30 @@ var hostedTilesetSourceSchema = z7.object({
     });
   }
 });
-var hostedSourcesSchema = z7.record(tileflowMapIdSchema, hostedTilesetSourceSchema).superRefine((sources, context) => {
+var geojsonFeatureCollectionSchema = z7.object({
+  features: z7.array(z7.record(z7.string(), z7.unknown())),
+  type: z7.literal("FeatureCollection")
+}).refine(
+  (data) => new TextEncoder().encode(JSON.stringify(data)).byteLength <= tileflowInlineGeoJsonByteLimit,
+  `Expected at most ${tileflowInlineGeoJsonByteLimit} bytes of inline GeoJSON`
+);
+var geojsonSourceSchema = z7.object({
+  attribution: z7.string().trim().min(1).max(4096).optional(),
+  cluster: z7.boolean().optional(),
+  clusterMaxZoom: z7.number().min(0).max(24).optional(),
+  clusterMinPoints: z7.number().int().min(2).optional(),
+  clusterProperties: z7.record(z7.string(), z7.tuple([z7.unknown(), z7.unknown()])).optional(),
+  clusterRadius: z7.number().positive().optional(),
+  data: z7.union([
+    geojsonFeatureCollectionSchema,
+    z7.string().refine((value) => value.startsWith("https://"), "Expected an https:// URL")
+  ]),
+  kind: z7.literal("geojson")
+}).strict();
+var hostedSourcesSchema = z7.record(
+  tileflowMapIdSchema,
+  z7.discriminatedUnion("kind", [hostedTilesetSourceSchema, geojsonSourceSchema])
+).superRefine((sources, context) => {
   if (Object.keys(sources).length > tileflowHostedSourceLimit) {
     context.addIssue({
       code: "too_big",
@@ -22531,6 +22775,7 @@ function compileSemanticStyleInternal(input, options, inspect, onReport) {
       basemapLayers,
       mapId: config.id,
       overlays: validateBoundaryChoroplethOverlays(config.id, config.overlays, boundaryAreas),
+      sourceDefinitions: hostedSources.definitions,
       sourceIds: [
         ...Object.keys(hostedSources.definitions),
         ...boundaryAreas ? [boundaryAreas.sourceId] : []
@@ -23854,6 +24099,24 @@ var operations = [
     name: "hosted-source",
     scope: "resource"
   },
+  {
+    api: "sources.<id> = geojsonSource({ data?, cluster?, clusterRadius?, ... })",
+    description: "Declare GeoJSON that clusters, or a source the application fills at runtime.",
+    name: "geojson-source",
+    scope: "resource"
+  },
+  {
+    api: "overlays.<id> = clusterOverlay({ id, source, placement })",
+    description: "Draw a clustering GeoJSON source: bubbles, counts, and separate points.",
+    name: "cluster-overlay",
+    scope: "resource"
+  },
+  {
+    api: "overlays.<id> = heatmapOverlay({ id, source, placement, weight? })",
+    description: "Draw point density from a GeoJSON source or a hosted vector tileset.",
+    name: "heatmap-overlay",
+    scope: "resource"
+  },
   {
     api: "overlays.<id> = maplibreOverlay({ source, placement, layers })",
     description: "Place one ordered group of validated MapLibre Style Layers.",
@@ -24296,8 +24559,18 @@ var tileflowAuthoringManifest = deepFreeze2({
       localResolution: "explicit-relative-pmtiles",
       maxPerMap: tileflowHostedSourceLimit
     },
+    geojsonSources: {
+      api: "geojsonSource({ data?, attribution?, cluster?, clusterRadius?, clusterMaxZoom?, clusterMinPoints?, clusterProperties? })",
+      data: "inline-feature-collection-or-https-url",
+      maxInlineBytes: tileflowInlineGeoJsonByteLimit,
+      maxPerMap: tileflowHostedSourceLimit
+    },
     overlays: {
       api: "maplibreOverlay({ source, placement, layers })",
+      helpers: [
+        "clusterOverlay({ id, source, placement })",
+        "heatmapOverlay({ id, source, placement })"
+      ],
       layers: "ordered-maplibre-style-layers-without-source",
       placement: tileflowOverlayPlacements,
       replacement: "atomic-by-overlay-id"
@@ -28049,6 +28322,7 @@ export {
   choroplethScale,
   classifyTileflowVisualProperty,
   clearTileflowManifestCache,
+  clusterOverlay,
   collectTileflowIconSetReferences,
   color,
   compareCodeUnits11 as compareCodeUnits,
@@ -28075,12 +28349,14 @@ export {
   expr,
   field,
   fixed,
+  geojsonSource,
   getTileflowAnalyticsApiUrl,
   getTileflowStyleFontFaces,
   hashTileflowFontBundleManifest,
   hashTileflowIconComposition,
   hashTileflowIconPackageManifest,
   hashTileflowRenderedIconPixels,
+  heatmapOverlay,
   hostedTileset,
   iconSet,
   inferTileflowAnalyticsFromStyleUrl,
@@ -28253,6 +28529,7 @@ export {
   tileflowIconsLockfileMaximumBytes,
   tileflowIconsLockfileName,
   tileflowIconsLockfileSchema,
+  tileflowInlineGeoJsonByteLimit,
   tileflowInsideRings,
   tileflowLandformClasses,
   tileflowLandmarkRegionOf,

package/dist/{manifest-types-CcD4OQkJ.d.ts → manifest-types-U7JPDNAo.d.ts}

@@ -87,6 +87,133 @@ declare const zoom: {
     step<T>(stops: readonly (readonly [number, T])[]): TileflowZoomValue<T>;
 };
 
+declare const tileflowOverlayPlacements: readonly ["above-water", "below-roads", "above-roads", "above-buildings", "below-labels", "above-labels"];
+declare const tileflowHostedSourceLimit: 16;
+/** Larger data belongs behind a URL or in runtime `dataSources`, not in every compiled style. */
+declare const tileflowInlineGeoJsonByteLimit: 512000;
+type TileflowOverlayPlacement = (typeof tileflowOverlayPlacements)[number];
+type TileflowHostedTilesetType = 'raster' | 'vector';
+type TileflowHostedTilesetSource = Readonly<{
+    attribution: string;
+    kind: 'hosted-tileset';
+    local: string;
+    tileset: string;
+    tileSize?: 256 | 512;
+    type: TileflowHostedTilesetType;
+}>;
+/**
+ * A GeoJSON FeatureCollection, the shape MapLibre clustering and `setData` accept. Features are
+ * plain objects because typed GeoJSON interfaces, such as `Feature<Point>`, have no index signature.
+ */
+type TileflowGeoJsonFeatureCollection = Readonly<{
+    features: readonly object[];
+    type: 'FeatureCollection';
+}>;
+/** MapLibre aggregate: `[operator, mapExpression]`, summed into each cluster's properties. */
+type TileflowClusterProperty = readonly [operator: unknown, map: unknown];
+/** Clustering options named as in the Mapbox and MapLibre source specifications. */
+type TileflowGeoJsonClusterOptions = Readonly<{
+    /** Group nearby points in the worker. Defaults to false. */
+    cluster?: boolean;
+    /** The last zoom that clusters; points are separate above it. MapLibre's default is 14. */
+    clusterMaxZoom?: number;
+    /** The fewest points that form a cluster. MapLibre's default is 2. */
+    clusterMinPoints?: number;
+    /** Aggregates kept on clusters, such as `{total: ['+', ['get', 'price']]}`. */
+    clusterProperties?: Readonly<Record<string, TileflowClusterProperty>>;
+    /** Cluster radius in CSS pixels. MapLibre's default is 50. */
+    clusterRadius?: number;
+}>;
+type TileflowGeoJsonSource = Readonly<TileflowGeoJsonClusterOptions & {
+    attribution?: string;
+    data: TileflowGeoJsonFeatureCollection | string;
+    kind: 'geojson';
+}>;
+type TileflowSource = TileflowGeoJsonSource | TileflowHostedTilesetSource;
+type TileflowMapLibreOverlayLayer = Readonly<Record<string, unknown> & {
+    id: string;
+    source?: never;
+    type: string;
+}>;
+type TileflowMapLibreOverlay = Readonly<{
+    kind: 'maplibre-overlay';
+    layers: readonly TileflowMapLibreOverlayLayer[];
+    placement: TileflowOverlayPlacement;
+    source: string;
+}>;
+type TileflowRemoveOperation = Readonly<{
+    op: 'remove';
+}>;
+type TileflowHostedSourceCollection = Readonly<Record<string, TileflowSource | TileflowRemoveOperation>>;
+type TileflowOverlayCollection = Readonly<Record<string, TileflowMapLibreOverlay | TileflowRemoveOperation>>;
+/** Bind one logical Team tileset to an explicit account-free local PMTiles archive. */
+declare function hostedTileset(options: {
+    attribution: string;
+    local: string;
+    tileset: string;
+    tileSize?: 256 | 512;
+    type?: TileflowHostedTilesetType;
+}): TileflowHostedTilesetSource;
+/**
+ * Declare a named GeoJSON source. Omit `data` for a source the application fills at runtime through
+ * a framework adapter's `dataSources`.
+ */
+declare function geojsonSource(options?: Readonly<TileflowGeoJsonClusterOptions & {
+    attribution?: string;
+    data?: TileflowGeoJsonFeatureCollection | string;
+}>): TileflowGeoJsonSource;
+/** Group one or more ordinary MapLibre layers around one named Tileflow source. */
+declare function maplibreOverlay(options: {
+    layers: readonly TileflowMapLibreOverlayLayer[];
+    placement: TileflowOverlayPlacement;
+    source: string;
+}): TileflowMapLibreOverlay;
+/**
+ * Draw a clustering GeoJSON source: sized bubbles, their counts, and the separate points. Layers are
+ * named `<id>-clusters`, `<id>-cluster-count` and `<id>-points`. The count uses the map's label font
+ * unless `font` names another. Framework adapters zoom into a clicked cluster.
+ */
+declare function clusterOverlay(options: {
+    /** Bubble colours by point count: the first applies below `steps[0]`. */
+    colors?: readonly [string, string, string];
+    /** Zoom in when a cluster is clicked or tapped. Defaults to true. */
+    expandOnClick?: boolean;
+    /** An exact text-font stack, for maps whose labels use another font. */
+    font?: readonly string[];
+    id: string;
+    placement: TileflowOverlayPlacement;
+    /** Colour of the separate points. */
+    pointColor?: string;
+    /** Bubble radii in pixels, matching `colors`. */
+    radii?: readonly [number, number, number];
+    source: string;
+    /** The two point counts where bubbles change size and colour. */
+    steps?: readonly [number, number];
+    textColor?: string;
+}): TileflowMapLibreOverlay;
+/**
+ * Draw point density from a GeoJSON source or a hosted vector tileset. `weight` is a number or a
+ * MapLibre expression; values above 1 make a point count for more than one.
+ */
+declare function heatmapOverlay(options: {
+    /** `[density, color]` stops from 0 to 1. Start transparent so empty areas stay clear. */
+    colors?: readonly (readonly [density: number, color: string])[];
+    id: string;
+    intensity?: unknown;
+    /** Above this zoom the layer is not drawn, for handing over to points or clusters. */
+    maxZoom?: number;
+    opacity?: unknown;
+    placement: TileflowOverlayPlacement;
+    radius?: unknown;
+    source: string;
+    /** The source-layer of a vector tileset. GeoJSON sources have none. */
+    sourceLayer?: string;
+    weight?: unknown;
+}): TileflowMapLibreOverlay;
+/** Remove one inherited keyed source or overlay. */
+declare function remove(): TileflowRemoveOperation;
+declare function isSafeLocalPmtilesPath(value: unknown): value is string;
+
 /** A color literal, semantic color token, color operation, expression, or zoom ramp. */
 type TileflowColorStyleValue = TileflowExpression<string> | TileflowThemeColorValue | TileflowZoomValue<TileflowThemeColorValue>;
 /** An image name, semantic image token, expression, or zoom ramp. */
@@ -1009,4 +1136,4 @@ type TileflowRuntimeManifest = {
     version: typeof tileflowRuntimeManifestVersion | typeof tileflowTimeOfDayManifestVersion | typeof tileflowFamilyManifestVersion;
 };
 
-export { type TileflowImageStyleValue as $, type TileflowLineStyle as A, type TileflowSymbolStyle as B, type TileflowRoadsModuleOptions as C, type TileflowRoadsModuleConfig as D, type TileflowLabelsModuleOptions as E, type TileflowLabelsModuleConfig as F, type TileflowPoiModuleOptions as G, type TileflowPoiModuleConfig as H, type MapLibreSprite as I, type TileflowAerodromeCodeDetail as J, type TileflowAlignment as K, type TileflowAnalytics as L, type MapLibreStyle as M, type TileflowAreaStyle as N, type TileflowBackgroundPaint as O, type TileflowCirclePaint as P, type TileflowColor as Q, type TileflowColorStyleValue as R, type TileflowExtrusionPaint as S, type TileflowRuntimeManifest as T, type TileflowFillPaint as U, type ValidationMessage as V, type TileflowIconAnchor as W, type TileflowIconLayout as X, type TileflowIconPaint as Y, type TileflowIconStyle as Z, type TileflowIconTextFit as _, type TileflowRuntimeColorScheme as a, type TileflowStyleValue as a$, type TileflowLabelDetail as a0, type TileflowLabelLanguage as a1, type TileflowLabelStyles as a2, type TileflowLayerRange as a3, type TileflowLight as a4, type TileflowLineCap as a5, type TileflowLineHatchStyle as a6, type TileflowLineJoin as a7, type TileflowLineLayout as a8, type TileflowLinePaint as a9, type TileflowRoadLayerStyle as aA, type TileflowRoadModifier as aB, type TileflowRoadOutline as aC, type TileflowRoadRestriction as aD, type TileflowRoadRoundaboutStyle as aE, type TileflowRoadServiceType as aF, type TileflowRoadShieldDetail as aG, type TileflowRoadShieldStyles as aH, type TileflowRoadSidewalkStyle as aI, type TileflowRoadStreetLightStyle as aJ, type TileflowRoadStructure as aK, type TileflowRoadTreatmentLayerStyle as aL, type TileflowRoadTreatmentLineStyle as aM, type TileflowRoadTreatmentStyle as aN, type TileflowRoadWeight as aO, type TileflowRuntimeCenterLike as aP, type TileflowRuntimeManifestMap as aQ, type TileflowRuntimeSource as aR, type TileflowRuntimeSourceValidation as aS, type TileflowRuntimeStyle as aT, type TileflowRuntimeStyleOptions as aU, type TileflowRuntimeViewOptions as aV, type TileflowSessionController as aW, type TileflowSessionGrantResponse as aX, type TileflowStringStyleValue as aY, type TileflowStructuralStyleValue as aZ, type TileflowStyleFontFace as a_, type TileflowLineStackStyle as aa, type TileflowManifestFetchOptions as ab, type TileflowManifestLoadOptions as ac, type TileflowMapMode as ad, type TileflowMapModeOptions as ae, type TileflowMarkerSymbolStyle as af, type TileflowMountainBikeScale as ag, type TileflowNumberInsetsStyleValue as ah, type TileflowNumberStyleValue as ai, type TileflowPlaceLabelClass as aj, type TileflowPoiCategory as ak, type TileflowPoiCategoryStyle as al, type TileflowPoiColorMode as am, type TileflowPoiDensity as an, type TileflowPoiPlacementOrder as ao, type TileflowPriorityOrder as ap, type TileflowProjection as aq, type TileflowResolvedRuntimeTheme as ar, type TileflowRoadAreaStyle as as, type TileflowRoadClass as at, type TileflowRoadClassStyle as au, type TileflowRoadCrossingStyle as av, type TileflowRoadDetail as aw, type TileflowRoadExtras as ax, type TileflowRoadHierarchy as ay, type TileflowRoadLabelDetail as az, type TileflowRuntimeManifestMapEntry as b, tileflowStyleFontFaceLimits as b$, type TileflowSymbolOverlap as b0, type TileflowSymbolPlacement as b1, type TileflowSymbolPlacementStyle as b2, type TileflowSymbolZOrder as b3, type TileflowTerrain as b4, type TileflowTerrainConfig as b5, type TileflowTerrainContourLabelStyle as b6, type TileflowTerrainContourLineStyle as b7, type TileflowTerrainContoursConfig as b8, type TileflowTerrainEncoding as b9, color as bA, createTileflowSessionController as bB, createTileflowSessionId as bC, defaultTileflowManifestUrl as bD, defaultTileflowRuntimeView as bE, fixed as bF, getTileflowAnalyticsApiUrl as bG, getTileflowStyleFontFaces as bH, inferTileflowAnalyticsFromStyleUrl as bI, isTileflowTimeOfDay as bJ, loadTileflowManifest as bK, mergeTileflowAnalytics as bL, nearestTileflowBlendTheme as bM, normalizeTileflowRuntimeCenter as bN, normalizeTileflowStaticImageSize as bO, normalizeTileflowUrl as bP, resolveTileflowAnalyticsRequestUrl as bQ, resolveTileflowManifestMap as bR, resolveTileflowMapMode as bS, resolveTileflowRuntimeStyle as bT, resolveTileflowRuntimeTheme as bU, resolveTileflowRuntimeThemeBlend as bV, resolveTileflowRuntimeView as bW, resolveTileflowStaticImageUrl as bX, shouldLoadTileflowManifest as bY, startTileflowSession as bZ, tileflowPoiCategories as b_, type TileflowTerrainHillshadeStyle as ba, type TileflowTerrainLayerRange as bb, type TileflowTerrainMode as bc, type TileflowTextAnchor as bd, type TileflowTextBackground as be, type TileflowTextJustify as bf, type TileflowTextLayout as bg, type TileflowTextPaint as bh, type TileflowTextStyle as bi, type TileflowThemeBlendSelection as bj, type TileflowThemeColorAlpha as bk, type TileflowThemeColorMix as bl, type TileflowThemeColorValue as bm, type TileflowThemeFontValue as bn, type TileflowThemeImageValue as bo, type TileflowThemeNumberValue as bp, type TileflowThemeSelection as bq, type TileflowThemeTokenCategory as br, type TileflowThemeValue as bs, type TileflowViewConfig as bt, type TileflowWaterLabelClass as bu, type TileflowZoomInterpolation as bv, type TileflowZoomValue as bw, type ValidationResult as bx, assertValidTileflowRuntimeSource as by, clearTileflowManifestCache as bz, type TileflowRuntimeManifestTheme as c, tileflowStyleFontFacesMetadataKey as c0, tileflowThemeBlendLimits as c1, tileflowThemeTokenCategories as c2, tileflowTimesOfDay as c3, token as c4, validateTileflowRuntimeSource as c5, validateTileflowThemeBlendSelection as c6, validateTileflowThemeSelection as c7, zoom as c8, type TileflowTypographyStyle as c9, type ResolvedTileflowTypography as ca, type TileflowAppearanceSelection as cb, type TileflowColorOverrides as cc, applyTileflowColorOverrides as cd, loadTileflowRuntimeAppearance as ce, loadTileflowStyleFamily as cf, normalizeTileflowSurfaceId as cg, prepareTileflowStyleFamilyForRendering as ch, resolveTileflowAppearance as ci, resolveTileflowFamilyResourceUrls as cj, resolveTileflowStyleResourceUrls as ck, type TileflowRuntimeSystemThemes as d, type TileflowTimeOfDay as e, type TileflowTimeOfDayVariants as f, tileflowRuntimeManifestLimits as g, tileflowRuntimeManifestVersion as h, tileflowTimeOfDayManifestVersion as i, type TileflowStyleFamily as j, createTileflowStyleFamily as k, expandTileflowFamilyTemplate as l, expandTileflowStyleFamily as m, materializeTileflowStyleFamily as n, tileflowStyleFamilyLimits as o, parseTileflowStyleFamily as p, type TileflowExpression as q, type TileflowFixedValue as r, type TileflowThemeTokenReference as s, tileflowFamilyManifestVersion as t, type TileflowThemeColorOperation as u, type TileflowBackgroundStyle as v, withTileflowFamilyTemplate as w, type TileflowCircleStyle as x, type TileflowExtrusionStyle as y, type TileflowFillStyle as z };
+export { type TileflowFillPaint as $, type TileflowExtrusionStyle as A, type TileflowFillStyle as B, type TileflowLineStyle as C, type TileflowSymbolStyle as D, tileflowHostedSourceLimit as E, tileflowInlineGeoJsonByteLimit as F, tileflowOverlayPlacements as G, type TileflowRoadsModuleOptions as H, type TileflowRoadsModuleConfig as I, type TileflowLabelsModuleOptions as J, type TileflowLabelsModuleConfig as K, type TileflowPoiModuleOptions as L, type MapLibreStyle as M, type TileflowPoiModuleConfig as N, type MapLibreSprite as O, type TileflowAerodromeCodeDetail as P, type TileflowAlignment as Q, type TileflowAnalytics as R, type TileflowAreaStyle as S, type TileflowRuntimeManifest as T, type TileflowBackgroundPaint as U, type ValidationMessage as V, type TileflowCirclePaint as W, type TileflowClusterProperty as X, type TileflowColor as Y, type TileflowColorStyleValue as Z, type TileflowExtrusionPaint as _, type TileflowRuntimeColorScheme as a, type TileflowRoadTreatmentLineStyle as a$, type TileflowGeoJsonClusterOptions as a0, type TileflowGeoJsonFeatureCollection as a1, type TileflowGeoJsonSource as a2, type TileflowHostedSourceCollection as a3, type TileflowHostedTilesetSource as a4, type TileflowHostedTilesetType as a5, type TileflowIconAnchor as a6, type TileflowIconLayout as a7, type TileflowIconPaint as a8, type TileflowIconStyle as a9, type TileflowPoiColorMode as aA, type TileflowPoiDensity as aB, type TileflowPoiPlacementOrder as aC, type TileflowPriorityOrder as aD, type TileflowProjection as aE, type TileflowRemoveOperation as aF, type TileflowResolvedRuntimeTheme as aG, type TileflowRoadAreaStyle as aH, type TileflowRoadClass as aI, type TileflowRoadClassStyle as aJ, type TileflowRoadCrossingStyle as aK, type TileflowRoadDetail as aL, type TileflowRoadExtras as aM, type TileflowRoadHierarchy as aN, type TileflowRoadLabelDetail as aO, type TileflowRoadLayerStyle as aP, type TileflowRoadModifier as aQ, type TileflowRoadOutline as aR, type TileflowRoadRestriction as aS, type TileflowRoadRoundaboutStyle as aT, type TileflowRoadServiceType as aU, type TileflowRoadShieldDetail as aV, type TileflowRoadShieldStyles as aW, type TileflowRoadSidewalkStyle as aX, type TileflowRoadStreetLightStyle as aY, type TileflowRoadStructure as aZ, type TileflowRoadTreatmentLayerStyle as a_, type TileflowIconTextFit as aa, type TileflowImageStyleValue as ab, type TileflowLabelDetail as ac, type TileflowLabelLanguage as ad, type TileflowLabelStyles as ae, type TileflowLayerRange as af, type TileflowLight as ag, type TileflowLineCap as ah, type TileflowLineHatchStyle as ai, type TileflowLineJoin as aj, type TileflowLineLayout as ak, type TileflowLinePaint as al, type TileflowLineStackStyle as am, type TileflowManifestFetchOptions as an, type TileflowManifestLoadOptions as ao, type TileflowMapLibreOverlayLayer as ap, type TileflowMapMode as aq, type TileflowMapModeOptions as ar, type TileflowMarkerSymbolStyle as as, type TileflowMountainBikeScale as at, type TileflowNumberInsetsStyleValue as au, type TileflowNumberStyleValue as av, type TileflowOverlayCollection as aw, type TileflowPlaceLabelClass as ax, type TileflowPoiCategory as ay, type TileflowPoiCategoryStyle as az, type TileflowRuntimeManifestMapEntry as b, hostedTileset as b$, type TileflowRoadTreatmentStyle as b0, type TileflowRoadWeight as b1, type TileflowRuntimeCenterLike as b2, type TileflowRuntimeManifestMap as b3, type TileflowRuntimeSource as b4, type TileflowRuntimeSourceValidation as b5, type TileflowRuntimeStyle as b6, type TileflowRuntimeStyleOptions as b7, type TileflowRuntimeViewOptions as b8, type TileflowSessionController as b9, type TileflowThemeColorAlpha as bA, type TileflowThemeColorMix as bB, type TileflowThemeColorValue as bC, type TileflowThemeFontValue as bD, type TileflowThemeImageValue as bE, type TileflowThemeNumberValue as bF, type TileflowThemeSelection as bG, type TileflowThemeTokenCategory as bH, type TileflowThemeValue as bI, type TileflowViewConfig as bJ, type TileflowWaterLabelClass as bK, type TileflowZoomInterpolation as bL, type TileflowZoomValue as bM, type ValidationResult as bN, assertValidTileflowRuntimeSource as bO, clearTileflowManifestCache as bP, clusterOverlay as bQ, color as bR, createTileflowSessionController as bS, createTileflowSessionId as bT, defaultTileflowManifestUrl as bU, defaultTileflowRuntimeView as bV, fixed as bW, geojsonSource as bX, getTileflowAnalyticsApiUrl as bY, getTileflowStyleFontFaces as bZ, heatmapOverlay as b_, type TileflowSessionGrantResponse as ba, type TileflowSource as bb, type TileflowStringStyleValue as bc, type TileflowStructuralStyleValue as bd, type TileflowStyleFontFace as be, type TileflowStyleValue as bf, type TileflowSymbolOverlap as bg, type TileflowSymbolPlacement as bh, type TileflowSymbolPlacementStyle as bi, type TileflowSymbolZOrder as bj, type TileflowTerrain as bk, type TileflowTerrainConfig as bl, type TileflowTerrainContourLabelStyle as bm, type TileflowTerrainContourLineStyle as bn, type TileflowTerrainContoursConfig as bo, type TileflowTerrainEncoding as bp, type TileflowTerrainHillshadeStyle as bq, type TileflowTerrainLayerRange as br, type TileflowTerrainMode as bs, type TileflowTextAnchor as bt, type TileflowTextBackground as bu, type TileflowTextJustify as bv, type TileflowTextLayout as bw, type TileflowTextPaint as bx, type TileflowTextStyle as by, type TileflowThemeBlendSelection as bz, type TileflowRuntimeManifestTheme as c, inferTileflowAnalyticsFromStyleUrl as c0, isSafeLocalPmtilesPath as c1, isTileflowTimeOfDay as c2, loadTileflowManifest as c3, maplibreOverlay as c4, mergeTileflowAnalytics as c5, nearestTileflowBlendTheme as c6, normalizeTileflowRuntimeCenter as c7, normalizeTileflowStaticImageSize as c8, normalizeTileflowUrl as c9, applyTileflowColorOverrides as cA, loadTileflowRuntimeAppearance as cB, loadTileflowStyleFamily as cC, normalizeTileflowSurfaceId as cD, prepareTileflowStyleFamilyForRendering as cE, resolveTileflowAppearance as cF, resolveTileflowFamilyResourceUrls as cG, resolveTileflowStyleResourceUrls as cH, remove as ca, resolveTileflowAnalyticsRequestUrl as cb, resolveTileflowManifestMap as cc, resolveTileflowMapMode as cd, resolveTileflowRuntimeStyle as ce, resolveTileflowRuntimeTheme as cf, resolveTileflowRuntimeThemeBlend as cg, resolveTileflowRuntimeView as ch, resolveTileflowStaticImageUrl as ci, shouldLoadTileflowManifest as cj, startTileflowSession as ck, tileflowPoiCategories as cl, tileflowStyleFontFaceLimits as cm, tileflowStyleFontFacesMetadataKey as cn, tileflowThemeBlendLimits as co, tileflowThemeTokenCategories as cp, tileflowTimesOfDay as cq, token as cr, validateTileflowRuntimeSource as cs, validateTileflowThemeBlendSelection as ct, validateTileflowThemeSelection as cu, zoom as cv, type TileflowTypographyStyle as cw, type ResolvedTileflowTypography as cx, type TileflowAppearanceSelection as cy, type TileflowColorOverrides as cz, type TileflowRuntimeSystemThemes as d, type TileflowTimeOfDay as e, type TileflowTimeOfDayVariants as f, tileflowRuntimeManifestLimits as g, tileflowRuntimeManifestVersion as h, tileflowTimeOfDayManifestVersion as i, type TileflowStyleFamily as j, createTileflowStyleFamily as k, expandTileflowFamilyTemplate as l, expandTileflowStyleFamily as m, materializeTileflowStyleFamily as n, tileflowStyleFamilyLimits as o, parseTileflowStyleFamily as p, type TileflowOverlayPlacement as q, type TileflowMapLibreOverlay as r, type TileflowExpression as s, tileflowFamilyManifestVersion as t, type TileflowFixedValue as u, type TileflowThemeTokenReference as v, withTileflowFamilyTemplate as w, type TileflowThemeColorOperation as x, type TileflowBackgroundStyle as y, type TileflowCircleStyle as z };

package/dist/manifest.d.ts

@@ -1,6 +1,6 @@
 import { z } from 'zod';
-import { T as TileflowRuntimeManifest } from './manifest-types-CcD4OQkJ.js';
-export { a as TileflowRuntimeColorScheme, b as TileflowRuntimeManifestMapEntry, c as TileflowRuntimeManifestTheme, d as TileflowRuntimeSystemThemes, e as TileflowTimeOfDay, f as TileflowTimeOfDayVariants, t as tileflowFamilyManifestVersion, g as tileflowRuntimeManifestLimits, h as tileflowRuntimeManifestVersion, i as tileflowTimeOfDayManifestVersion } from './manifest-types-CcD4OQkJ.js';
+import { T as TileflowRuntimeManifest } from './manifest-types-U7JPDNAo.js';
+export { a as TileflowRuntimeColorScheme, b as TileflowRuntimeManifestMapEntry, c as TileflowRuntimeManifestTheme, d as TileflowRuntimeSystemThemes, e as TileflowTimeOfDay, f as TileflowTimeOfDayVariants, t as tileflowFamilyManifestVersion, g as tileflowRuntimeManifestLimits, h as tileflowRuntimeManifestVersion, i as tileflowTimeOfDayManifestVersion } from './manifest-types-U7JPDNAo.js';
 
 declare const tileflowRuntimeManifestSchema: z.ZodType<TileflowRuntimeManifest>;
 declare function parseTileflowRuntimeManifest(input: unknown): TileflowRuntimeManifest;