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

package/dist/build.d.ts

@@ -1,8 +1,8 @@
 import { T as TileflowCaptureScene, a as TileflowCaptureShot } from './capture-shot-ChPQvPyi.js';
-import { T as TileflowRenderedIconIdentity, a as TileflowIconCompositionV1, R as ResolvedTileflowMap, b as TileflowDataRequirementsV1, c as TileflowSourceRequirementsV1, d as TileflowMap, e as TileflowStyleOptions, f as TileflowInspectedStyle, g as TileflowPreparedMapAssets } from './icon-composition-CInvkr7s.js';
-export { h as TileflowDataCompatibilityIssue, i as TileflowDataFieldRequirement, j as TileflowDataFieldType, k as TileflowDataLayerRequirement, l as TileflowObservedDataContractV1, m as TileflowStyleInspection, n as TileflowStyleInspectionContribution, o as TileflowStyleInspectionLayer, p as TileflowStyleInspectionRenderOperation, q as collectMapLineage, r as inferTileflowDataRequirements, s as inferTileflowSourceRequirements, t as tileflowStyleInspectionSchemaVersion, v as validateTileflowDataCompatibility } from './icon-composition-CInvkr7s.js';
-import { M as MapLibreStyle, f as TileflowTimeOfDayVariants, T as TileflowRuntimeManifest } from './manifest-types-CcD4OQkJ.js';
-export { j as TileflowStyleFamily, k as createTileflowStyleFamily, l as expandTileflowFamilyTemplate, m as expandTileflowStyleFamily, n as materializeTileflowStyleFamily, p as parseTileflowStyleFamily, o as tileflowStyleFamilyLimits, w as withTileflowFamilyTemplate } from './manifest-types-CcD4OQkJ.js';
+import { T as TileflowRenderedIconIdentity, a as TileflowIconCompositionV1, R as ResolvedTileflowMap, b as TileflowDataRequirementsV1, c as TileflowSourceRequirementsV1, d as TileflowMap, e as TileflowStyleOptions, f as TileflowInspectedStyle, g as TileflowPreparedMapAssets } from './icon-composition-2nsUbE87.js';
+export { h as TileflowDataCompatibilityIssue, i as TileflowDataFieldRequirement, j as TileflowDataFieldType, k as TileflowDataLayerRequirement, l as TileflowObservedDataContractV1, m as TileflowStyleInspection, n as TileflowStyleInspectionContribution, o as TileflowStyleInspectionLayer, p as TileflowStyleInspectionRenderOperation, q as collectMapLineage, r as inferTileflowDataRequirements, s as inferTileflowSourceRequirements, t as tileflowStyleInspectionSchemaVersion, v as validateTileflowDataCompatibility } from './icon-composition-2nsUbE87.js';
+import { M as MapLibreStyle, f as TileflowTimeOfDayVariants, T as TileflowRuntimeManifest } from './manifest-types-U7JPDNAo.js';
+export { j as TileflowStyleFamily, k as createTileflowStyleFamily, l as expandTileflowFamilyTemplate, m as expandTileflowStyleFamily, n as materializeTileflowStyleFamily, p as parseTileflowStyleFamily, o as tileflowStyleFamilyLimits, w as withTileflowFamilyTemplate } from './manifest-types-U7JPDNAo.js';
 import { z } from 'zod';
 
 declare const tileflowMapRevisionSchemaVersion: 1;

package/dist/build.js

@@ -2181,6 +2181,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 },
@@ -11867,92 +11869,6 @@ function asRecord3(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
 
-// src/manifest-schema-classic.ts
-import { z as z3 } from "zod";
-
-// src/native-zod-object.ts
-import { z as z2 } from "zod";
-function strictNativeObject(shape) {
-  const object3 = new z2.core.$ZodObject({
-    type: "object",
-    shape,
-    catchall: z2.never()
-  });
-  return z2.lazy(() => object3);
-}
-
-// src/manifest-schema-classic.ts
-function classic(schema) {
-  return schema;
-}
-var classicManifestStringOperations = {
-  string: () => z3.string(),
-  minLength(schema, minimum2) {
-    return schema.min(
-      minimum2
-    );
-  },
-  maxLength(schema, maximum2) {
-    return schema.max(
-      maximum2
-    );
-  },
-  regex: (schema, pattern, message) => schema.regex(pattern, { message }),
-  refine: (schema, check, message) => classic(schema).refine(check, message)
-};
-var classicManifestSchemaOperations = {
-  ...classicManifestStringOperations,
-  number: (minimum2, maximum2) => z3.number().finite().min(minimum2).max(maximum2),
-  unknown: () => z3.unknown(),
-  optional: (schema) => classic(schema).optional(),
-  array: (schema) => z3.array(classic(schema)),
-  enum(values) {
-    return z3.enum(values);
-  },
-  literal: (value) => z3.literal(value),
-  union: (left, right) => z3.union([classic(left), classic(right)]),
-  tuplePair(left, right) {
-    return z3.tuple([classic(left), classic(right)]);
-  },
-  object(shape) {
-    return strictNativeObject(shape);
-  },
-  record(key, value) {
-    return z3.record(classic(key), classic(value));
-  },
-  superRefine: (schema, check) => classic(schema).superRefine(check),
-  pipe: (input, output) => classic(input).pipe(classic(output))
-};
-
-// src/portable-identity-schema.ts
-function createPortableIdentitySchemas(operations) {
-  const bounded2 = operations.maxLength(
-    operations.minLength(operations.string(), 1),
-    tileflowPortableIdMaximumLength
-  );
-  const pattern = operations.regex(
-    bounded2,
-    tileflowPortableIdPattern,
-    "Expected lowercase kebab-case beginning with a letter"
-  );
-  const tileflowPortableIdSchema2 = operations.refine(
-    pattern,
-    (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"
-  );
-  const tileflowThemeNameSchema2 = operations.refine(
-    tileflowPortableIdSchema2,
-    isTileflowThemeName,
-    "Expected a concrete theme name; system is browser-only"
-  );
-  return { tileflowPortableIdSchema: tileflowPortableIdSchema2, tileflowThemeNameSchema: tileflowThemeNameSchema2 };
-}
-
-// src/portable-identity.ts
-var schemas = createPortableIdentitySchemas(classicManifestStringOperations);
-var tileflowPortableIdSchema = schemas.tileflowPortableIdSchema;
-var tileflowThemeNameSchema = schemas.tileflowThemeNameSchema;
-
 // src/overlays.ts
 var tileflowOverlayPlacements = [
   "above-water",
@@ -11963,6 +11879,8 @@ var tileflowOverlayPlacements = [
   "above-labels"
 ];
 var tileflowHostedSourceLimit = 16;
+var tileflowInlineGeoJsonByteLimit = 512e3;
+var tileflowClusterMetadataKey = "tileflow:cluster";
 function isTileflowRemoveOperation(value) {
   return isPlainRecord3(value) && value.op === "remove" && Object.keys(value).length === 1;
 }
@@ -12001,6 +11919,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(
@@ -12025,8 +11947,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(
@@ -12054,8 +11985,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) : {},
@@ -12079,6 +12019,42 @@ 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 isSafeLocalPmtilesPath(value) {
   if (typeof value !== "string" || value.length > 512 || !value.endsWith(".pmtiles") || value.includes("\\") || /[\p{Cc}?#]/u.test(value)) {
     return false;
@@ -12119,6 +12095,92 @@ function isPlainRecord3(value) {
   return prototype === Object.prototype || prototype === null;
 }
 
+// src/manifest-schema-classic.ts
+import { z as z3 } from "zod";
+
+// src/native-zod-object.ts
+import { z as z2 } from "zod";
+function strictNativeObject(shape) {
+  const object3 = new z2.core.$ZodObject({
+    type: "object",
+    shape,
+    catchall: z2.never()
+  });
+  return z2.lazy(() => object3);
+}
+
+// src/manifest-schema-classic.ts
+function classic(schema) {
+  return schema;
+}
+var classicManifestStringOperations = {
+  string: () => z3.string(),
+  minLength(schema, minimum2) {
+    return schema.min(
+      minimum2
+    );
+  },
+  maxLength(schema, maximum2) {
+    return schema.max(
+      maximum2
+    );
+  },
+  regex: (schema, pattern, message) => schema.regex(pattern, { message }),
+  refine: (schema, check, message) => classic(schema).refine(check, message)
+};
+var classicManifestSchemaOperations = {
+  ...classicManifestStringOperations,
+  number: (minimum2, maximum2) => z3.number().finite().min(minimum2).max(maximum2),
+  unknown: () => z3.unknown(),
+  optional: (schema) => classic(schema).optional(),
+  array: (schema) => z3.array(classic(schema)),
+  enum(values) {
+    return z3.enum(values);
+  },
+  literal: (value) => z3.literal(value),
+  union: (left, right) => z3.union([classic(left), classic(right)]),
+  tuplePair(left, right) {
+    return z3.tuple([classic(left), classic(right)]);
+  },
+  object(shape) {
+    return strictNativeObject(shape);
+  },
+  record(key, value) {
+    return z3.record(classic(key), classic(value));
+  },
+  superRefine: (schema, check) => classic(schema).superRefine(check),
+  pipe: (input, output) => classic(input).pipe(classic(output))
+};
+
+// src/portable-identity-schema.ts
+function createPortableIdentitySchemas(operations) {
+  const bounded2 = operations.maxLength(
+    operations.minLength(operations.string(), 1),
+    tileflowPortableIdMaximumLength
+  );
+  const pattern = operations.regex(
+    bounded2,
+    tileflowPortableIdPattern,
+    "Expected lowercase kebab-case beginning with a letter"
+  );
+  const tileflowPortableIdSchema2 = operations.refine(
+    pattern,
+    (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"
+  );
+  const tileflowThemeNameSchema2 = operations.refine(
+    tileflowPortableIdSchema2,
+    isTileflowThemeName,
+    "Expected a concrete theme name; system is browser-only"
+  );
+  return { tileflowPortableIdSchema: tileflowPortableIdSchema2, tileflowThemeNameSchema: tileflowThemeNameSchema2 };
+}
+
+// src/portable-identity.ts
+var schemas = createPortableIdentitySchemas(classicManifestStringOperations);
+var tileflowPortableIdSchema = schemas.tileflowPortableIdSchema;
+var tileflowThemeNameSchema = schemas.tileflowThemeNameSchema;
+
 // src/boundary-areas/schema.ts
 var tileflowBoundaryClasses = [
   "country",
@@ -16771,7 +16833,30 @@ var hostedTilesetSourceSchema = z5.object({
     });
   }
 });
-var hostedSourcesSchema = z5.record(tileflowMapIdSchema, hostedTilesetSourceSchema).superRefine((sources, context) => {
+var geojsonFeatureCollectionSchema = z5.object({
+  features: z5.array(z5.record(z5.string(), z5.unknown())),
+  type: z5.literal("FeatureCollection")
+}).refine(
+  (data) => new TextEncoder().encode(JSON.stringify(data)).byteLength <= tileflowInlineGeoJsonByteLimit,
+  `Expected at most ${tileflowInlineGeoJsonByteLimit} bytes of inline GeoJSON`
+);
+var geojsonSourceSchema = z5.object({
+  attribution: z5.string().trim().min(1).max(4096).optional(),
+  cluster: z5.boolean().optional(),
+  clusterMaxZoom: z5.number().min(0).max(24).optional(),
+  clusterMinPoints: z5.number().int().min(2).optional(),
+  clusterProperties: z5.record(z5.string(), z5.tuple([z5.unknown(), z5.unknown()])).optional(),
+  clusterRadius: z5.number().positive().optional(),
+  data: z5.union([
+    geojsonFeatureCollectionSchema,
+    z5.string().refine((value) => value.startsWith("https://"), "Expected an https:// URL")
+  ]),
+  kind: z5.literal("geojson")
+}).strict();
+var hostedSourcesSchema = z5.record(
+  tileflowMapIdSchema,
+  z5.discriminatedUnion("kind", [hostedTilesetSourceSchema, geojsonSourceSchema])
+).superRefine((sources, context) => {
   if (Object.keys(sources).length > tileflowHostedSourceLimit) {
     context.addIssue({
       code: "too_big",
@@ -19561,6 +19646,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] : []
@@ -22170,6 +22256,7 @@ function normalizeRevisionCartography(input) {
     ...input,
     sources: Object.fromEntries(
       Object.entries(input.sources).sort(([left], [right]) => compareCodeUnits8(left, right)).map(([sourceId, source]) => {
+        if (source.kind === "geojson") return [sourceId, source];
         const { local: _local, ...logicalSource } = source;
         return [sourceId, logicalSource];
       })