@tileflow/core 0.1.0-alpha.33 → 0.1.0-alpha.35

package/dist/runtime.d.ts

@@ -1 +1 @@
-export { z as TileflowAnalytics, $ as TileflowManifestFetchOptions, a0 as TileflowManifestLoadOptions, a1 as TileflowMapMode, a2 as TileflowMapModeOptions, ae as TileflowResolvedRuntimeTheme, aB as TileflowRuntimeCenterLike, a as TileflowRuntimeColorScheme, T as TileflowRuntimeManifest, aC as TileflowRuntimeManifestMap, b as TileflowRuntimeManifestMapEntry, c as TileflowRuntimeManifestTheme, aD as TileflowRuntimeSource, aE as TileflowRuntimeSourceValidation, aF as TileflowRuntimeStyle, aG as TileflowRuntimeStyleOptions, d as TileflowRuntimeSystemThemes, aH as TileflowRuntimeViewOptions, aI as TileflowSessionController, aJ as TileflowSessionGrantResponse, aM as TileflowStyleFontFace, b5 as TileflowThemeBlendSelection, bc as TileflowThemeSelection, bk as assertValidTileflowRuntimeSource, bl as clearTileflowManifestCache, bn as createTileflowSessionController, bo as createTileflowSessionId, bp as defaultTileflowManifestUrl, bq as defaultTileflowRuntimeView, bs as getTileflowAnalyticsApiUrl, bt as getTileflowStyleFontFaces, bu as inferTileflowAnalyticsFromStyleUrl, bv as loadTileflowManifest, bw as mergeTileflowAnalytics, bx as nearestTileflowBlendTheme, by as normalizeTileflowRuntimeCenter, bz as normalizeTileflowStaticImageSize, bX as normalizeTileflowSurfaceId, bA as normalizeTileflowUrl, bB as resolveTileflowAnalyticsRequestUrl, bC as resolveTileflowManifestMap, bD as resolveTileflowMapMode, bE as resolveTileflowRuntimeStyle, bF as resolveTileflowRuntimeTheme, bG as resolveTileflowRuntimeThemeBlend, bH as resolveTileflowRuntimeView, bI as resolveTileflowStaticImageUrl, bJ as shouldLoadTileflowManifest, bK as startTileflowSession, bM as tileflowStyleFontFaceLimits, bN as tileflowStyleFontFacesMetadataKey, bO as tileflowThemeBlendLimits, bR as validateTileflowRuntimeSource, bS as validateTileflowThemeBlendSelection, bT as validateTileflowThemeSelection } from './manifest-types-E7m23eXL.js';
+export { C as TileflowAnalytics, a2 as TileflowManifestFetchOptions, a3 as TileflowManifestLoadOptions, a4 as TileflowMapMode, a5 as TileflowMapModeOptions, ai as TileflowResolvedRuntimeTheme, aG as TileflowRuntimeCenterLike, a as TileflowRuntimeColorScheme, T as TileflowRuntimeManifest, aH as TileflowRuntimeManifestMap, b as TileflowRuntimeManifestMapEntry, c as TileflowRuntimeManifestTheme, aI as TileflowRuntimeSource, aJ as TileflowRuntimeSourceValidation, aK as TileflowRuntimeStyle, aL as TileflowRuntimeStyleOptions, d as TileflowRuntimeSystemThemes, aM as TileflowRuntimeViewOptions, aN as TileflowSessionController, aO as TileflowSessionGrantResponse, aR as TileflowStyleFontFace, ba as TileflowThemeBlendSelection, bh as TileflowThemeSelection, e as TileflowTimeOfDay, f as TileflowTimeOfDayVariants, bp as assertValidTileflowRuntimeSource, bq as clearTileflowManifestCache, bs as createTileflowSessionController, bt as createTileflowSessionId, bu as defaultTileflowManifestUrl, bv as defaultTileflowRuntimeView, bx as getTileflowAnalyticsApiUrl, by as getTileflowStyleFontFaces, bz as inferTileflowAnalyticsFromStyleUrl, bA as isTileflowTimeOfDay, bB as loadTileflowManifest, bC as mergeTileflowAnalytics, bD as nearestTileflowBlendTheme, bE as normalizeTileflowRuntimeCenter, bF as normalizeTileflowStaticImageSize, c2 as normalizeTileflowSurfaceId, bG as normalizeTileflowUrl, bH as resolveTileflowAnalyticsRequestUrl, bI as resolveTileflowManifestMap, bJ as resolveTileflowMapMode, bK as resolveTileflowRuntimeStyle, bL as resolveTileflowRuntimeTheme, bM as resolveTileflowRuntimeThemeBlend, bN as resolveTileflowRuntimeView, bO as resolveTileflowStaticImageUrl, bP as shouldLoadTileflowManifest, bQ as startTileflowSession, bS as tileflowStyleFontFaceLimits, bT as tileflowStyleFontFacesMetadataKey, bU as tileflowThemeBlendLimits, bW as tileflowTimesOfDay, bY as validateTileflowRuntimeSource, bZ as validateTileflowThemeBlendSelection, b_ as validateTileflowThemeSelection } from './manifest-types-Bzxon3dx.js';

package/dist/runtime.js

@@ -29,12 +29,70 @@ var init_portable_identity_rules = __esm({
   }
 });
 
+// src/time-of-day.ts
+function isTileflowTimeOfDay(value) {
+  return typeof value === "string" && tileflowTimesOfDay.includes(value);
+}
+function validateTileflowTimeOfDayVariants(variants, themes) {
+  const issues = [];
+  const owners = /* @__PURE__ */ new Map();
+  const families = Object.entries(variants);
+  for (const [family, moments] of families) {
+    if (!isTileflowThemeName(family) || !Object.hasOwn(themes, family)) {
+      issues.push({ path: [family], message: "Time-of-day family must name an existing theme" });
+    }
+    if (!Object.values(moments).includes(family)) {
+      issues.push({ path: [family], message: "A family must include its own theme in its presets" });
+    }
+    for (const [moment, name] of Object.entries(moments)) {
+      if (name === void 0) continue;
+      if (!isTileflowTimeOfDay(moment) || !isTileflowThemeName(name) || !Object.hasOwn(themes, name)) {
+        issues.push({
+          path: [family, moment],
+          message: "Expected a supported moment and an existing theme"
+        });
+      }
+      const owner = owners.get(name);
+      if (owner !== void 0 && owner !== family) {
+        issues.push({
+          path: [family, moment],
+          message: `Theme "${name}" already belongs to family "${owner}"`
+        });
+      }
+      owners.set(name, family);
+    }
+  }
+  return issues;
+}
+function resolveTileflowTimeOfDayTheme(variants, theme, timeOfDay) {
+  if (timeOfDay === void 0 || variants === void 0) return theme;
+  if (!isTileflowTimeOfDay(timeOfDay)) throw new TypeError("Expected day, dawn, dusk, or night");
+  const family = Object.hasOwn(variants, theme) ? variants[theme] : Object.values(variants).find((moments) => Object.values(moments).includes(theme));
+  if (!family) return theme;
+  const result = family[timeOfDay];
+  if (result === void 0) {
+    throw new Error(
+      `Theme "${theme}" does not offer timeOfDay="${timeOfDay}". Available: ${Object.keys(family).join(", ")}.`
+    );
+  }
+  return result;
+}
+var tileflowTimesOfDay;
+var init_time_of_day = __esm({
+  "src/time-of-day.ts"() {
+    "use strict";
+    init_portable_identity_rules();
+    tileflowTimesOfDay = ["day", "dawn", "dusk", "night"];
+  }
+});
+
 // src/manifest-types.ts
-var tileflowRuntimeManifestVersion, tileflowRuntimeManifestLimits;
+var tileflowRuntimeManifestVersion, tileflowTimeOfDayManifestVersion, tileflowRuntimeManifestLimits;
 var init_manifest_types = __esm({
   "src/manifest-types.ts"() {
     "use strict";
     tileflowRuntimeManifestVersion = 1;
+    tileflowTimeOfDayManifestVersion = 2;
     tileflowRuntimeManifestLimits = Object.freeze({ maximumBytes: 1024 * 1024 });
   }
 });
@@ -103,6 +161,24 @@ var init_model = __esm({
   }
 });
 
+// src/time-of-day-schema.ts
+function createTileflowTimeOfDaySchema(operations, themeName) {
+  return operations.record(
+    themeName,
+    operations.object({
+      day: operations.optional(themeName),
+      dawn: operations.optional(themeName),
+      dusk: operations.optional(themeName),
+      night: operations.optional(themeName)
+    })
+  );
+}
+var init_time_of_day_schema = __esm({
+  "src/time-of-day-schema.ts"() {
+    "use strict";
+  }
+});
+
 // src/manifest-schema.ts
 function createTileflowRuntimeManifestSchema(primitives, operations, identities = createPortableIdentitySchemas(operations)) {
   const { tileflowPortableIdSchema: tileflowPortableIdSchema2, tileflowThemeNameSchema: tileflowThemeNameSchema2 } = identities;
@@ -158,12 +234,24 @@ function createTileflowRuntimeManifestSchema(primitives, operations, identities
         })
       ),
       themes: operations.record(tileflowThemeNameSchema2, manifestThemeSchema),
+      timeOfDay: operations.optional(
+        createTileflowTimeOfDaySchema(operations, tileflowThemeNameSchema2)
+      ),
       usageMode: operations.optional(operations.literal("session")),
       view: operations.optional(viewSchema),
       worldGeneration: operations.optional(operations.literal("v1"))
     }),
     (entry, context) => {
       const names = Object.keys(entry.themes);
+      if (entry.timeOfDay) {
+        for (const issue of validateTileflowTimeOfDayVariants(entry.timeOfDay, entry.themes)) {
+          context.addIssue({
+            code: "custom",
+            message: issue.message,
+            path: ["timeOfDay", ...issue.path]
+          });
+        }
+      }
       if (names.length === 0) {
         context.addIssue({
           code: "custom",
@@ -217,10 +305,23 @@ function createTileflowRuntimeManifestSchema(primitives, operations, identities
     operations.object({
       apiUrl: operations.optional(apiOriginSchema),
       maps: operations.record(tileflowPortableIdSchema2, manifestMapSchema),
-      version: operations.literal(tileflowRuntimeManifestVersion)
+      version: operations.union(
+        operations.literal(tileflowRuntimeManifestVersion),
+        operations.literal(2)
+      )
     }),
     (manifest, context) => {
       const mapCount = Object.keys(manifest.maps).length;
+      if (manifest.version === 1) {
+        for (const [name, map] of Object.entries(manifest.maps)) {
+          if (map.timeOfDay !== void 0)
+            context.addIssue({
+              code: "custom",
+              message: "timeOfDay requires manifest version 2",
+              path: ["maps", name, "timeOfDay"]
+            });
+        }
+      }
       if (mapCount === 0) {
         context.addIssue({ code: "custom", message: "Expected at least one map", path: ["maps"] });
       }
@@ -333,6 +434,8 @@ var init_manifest_schema = __esm({
     init_portable_identity_schema();
     init_runtime_view_schema();
     init_model();
+    init_time_of_day();
+    init_time_of_day_schema();
   }
 });
 
@@ -387,6 +490,7 @@ var init_manifest_schema_classic = __esm({
         return z2.enum(values);
       },
       literal: (value) => z2.literal(value),
+      union: (left, right) => z2.union([classic(left), classic(right)]),
       tuplePair(left, right) {
         return z2.tuple([classic(left), classic(right)]);
       },
@@ -422,7 +526,8 @@ __export(manifest_exports, {
   safeParseTileflowRuntimeManifest: () => safeParseTileflowRuntimeManifest,
   tileflowRuntimeManifestLimits: () => tileflowRuntimeManifestLimits,
   tileflowRuntimeManifestSchema: () => tileflowRuntimeManifestSchema,
-  tileflowRuntimeManifestVersion: () => tileflowRuntimeManifestVersion
+  tileflowRuntimeManifestVersion: () => tileflowRuntimeManifestVersion,
+  tileflowTimeOfDayManifestVersion: () => tileflowTimeOfDayManifestVersion
 });
 function parseTileflowRuntimeManifest(input) {
   return tileflowRuntimeManifestSchema.parse(input);
@@ -451,6 +556,8 @@ var init_manifest = __esm({
 
 // src/runtime.ts
 init_portable_identity_rules();
+init_time_of_day();
+init_time_of_day();
 var defaultTileflowManifestUrl = "/tileflow/manifest.json";
 var defaultTileflowRuntimeView = Object.freeze({
   bearing: 0,
@@ -532,7 +639,8 @@ function resolveTileflowRuntimeStyle(options) {
     const theme = resolveTileflowRuntimeTheme(
       options.manifestMap,
       options.theme,
-      options.colorScheme
+      options.colorScheme,
+      options.timeOfDay
     );
     return {
       analytics: {
@@ -549,7 +657,7 @@ function resolveTileflowRuntimeStyle(options) {
   }
   return null;
 }
-function resolveTileflowRuntimeTheme(map, selection, colorScheme) {
+function resolveTileflowRuntimeTheme(map, selection, colorScheme, timeOfDay) {
   let name;
   if (selection === void 0) {
     name = map.defaultTheme;
@@ -571,6 +679,8 @@ function resolveTileflowRuntimeTheme(map, selection, colorScheme) {
       `Tileflow resolved invalid theme ${JSON.stringify(name)} for map "${map.name}"; expected a concrete portable theme name.`
     );
   }
+  if (Object.hasOwn(map.themes, name))
+    name = resolveTileflowTimeOfDayTheme(map.timeOfDay, name, timeOfDay);
   const theme = Object.hasOwn(map.themes, name) ? map.themes[name] : void 0;
   if (!theme) {
     const available = Object.keys(map.themes).sort().join(", ");
@@ -1106,6 +1216,7 @@ function resolveTileflowManifestMap(manifest, mapName) {
     defaultTheme: entry.defaultTheme,
     ...entry.environment ? { environment: entry.environment } : {},
     ...entry.systemThemes ? { systemThemes: { ...entry.systemThemes } } : {},
+    ...entry.timeOfDay ? { timeOfDay: entry.timeOfDay } : {},
     themes: entry.themes,
     usageMode: entry.usageMode,
     view: entry.view,
@@ -1123,7 +1234,12 @@ function resolveTileflowStaticImageUrl(input) {
   const apiUrl = normalizeTileflowUrl(input.manifestMap.apiUrl ?? "https://api.tileflow.dev");
   const mapId = encodeURIComponent(input.manifestMap.mapId);
   const url = new URL(`/maps/${mapId}/static.png`, apiUrl);
-  const theme = resolveTileflowRuntimeTheme(input.manifestMap, input.theme, input.colorScheme);
+  const theme = resolveTileflowRuntimeTheme(
+    input.manifestMap,
+    input.theme,
+    input.colorScheme,
+    input.timeOfDay
+  );
   url.searchParams.set("center", input.center.join(","));
   url.searchParams.set("theme", theme.name);
   url.searchParams.set("zoom", String(input.zoom));
@@ -1291,6 +1407,7 @@ export {
   getTileflowAnalyticsApiUrl,
   getTileflowStyleFontFaces,
   inferTileflowAnalyticsFromStyleUrl,
+  isTileflowTimeOfDay,
   loadTileflowManifest,
   mergeTileflowAnalytics,
   nearestTileflowBlendTheme,
@@ -1311,6 +1428,7 @@ export {
   tileflowStyleFontFaceLimits,
   tileflowStyleFontFacesMetadataKey,
   tileflowThemeBlendLimits,
+  tileflowTimesOfDay,
   validateTileflowRuntimeSource,
   validateTileflowThemeBlendSelection,
   validateTileflowThemeSelection

package/docs/application-tile-reading.md

@@ -74,6 +74,9 @@ state on the map.
 - **Requests.** `transformRequest` rewrites each request as a MapLibre map's option does. Pass the
   map's own so tile reads follow the same rules. The browser's HTTP cache applies as for any
   request.
+- **Archives.** A source served from a Tileflow PMTiles archive (a `tileflow-pmtiles://` address)
+  is read through Core's PMTiles protocol, sharing the archives the page's map has opened. A
+  `fetch` of your own replaces both.
 
 The reader has no DOM dependency, so it also runs in a module worker: post the tile address and
 zooms to the worker and create the reader there. `decodeTileflowVectorTile(bytes, {layers})`

package/docs/authoring-model.md

@@ -89,7 +89,8 @@ TypeScript imports.
 
 `icons` is an intentional exception to implicit array composition: omission inherits the exact
 parent array, any declaration replaces it atomically, and `[]` disables map icons. Compose with a
-spread when the child should keep a parent's directories. `fonts` and `glyphs` are mutually
+spread when the child should keep a parent's directories. `models`, the directories of a map's own
+3D models, follows the same rule. `fonts` and `glyphs` are mutually
 exclusive text providers; declaring either atomically replaces an inherited provider of either
 kind. Unknown keys and former compatibility shapes are rejected.
 
@@ -214,6 +215,10 @@ surveyed isoline. `water({bathymetryLabels: {}})` separately opts into numeric m
 from each polygon's absolute minimum band depth. Existing maps gain neither detail by default, and
 sources without bathymetry bindings omit both requested layers. These labels describe coarse band
 floors, not measured survey soundings, and must not be presented as hydrographic sounding data.
+An explicitly selected Bathymetry source can instead declare `vectorLayers.contours: true` to use
+real contour lines and their `depth` values. Its optional named seafloor and water features have
+separate `water.bathymetryLandforms` and `water.bathymetryWaterNames` styles, with the language
+selected by `labels(...)`. See [the marine source contract](data-is-separate-from-design.md#declare-contour-and-name-layers).
 
 `addresses` renders the standard OpenMapTiles `housenumber` points at detailed zooms and exposes a
 single semantic `labels` style. `landforms` renders the standard `mountain_peak` classes (`peak`,