@tileflow/core 0.1.0-alpha.20 → 0.1.0-alpha.21

package/dist/recipe.js

@@ -0,0 +1,577 @@
+// src/cartography/contributions.ts
+var tileflowLayerTargetPattern = /^[A-Za-z0-9_-]+(?:\.[A-Za-z0-9_-]+)*$/;
+var tileflowCompilerMetadataKeys = Object.freeze({
+  owner: "tileflow:compiler-owner",
+  slot: "tileflow:compiler-slot",
+  target: "tileflow:compiler-target"
+});
+
+// src/cartography/domains.ts
+var tileflowLayerDomains = [
+  "addresses",
+  "land",
+  "terrain",
+  "landforms",
+  "water",
+  "nautical",
+  "roads",
+  "transit",
+  "aeroways",
+  "buildings",
+  "vegetation",
+  "boundaries",
+  "labels",
+  "poi"
+];
+
+// src/cartography/expression-operators.ts
+var mapLibreExpressionOperators = /* @__PURE__ */ new Set([
+  "!",
+  "!=",
+  "%",
+  "*",
+  "+",
+  "-",
+  "/",
+  "<",
+  "<=",
+  "==",
+  ">",
+  ">=",
+  "^",
+  "abs",
+  "accumulated",
+  "acos",
+  "all",
+  "any",
+  "array",
+  "asin",
+  "at",
+  "atan",
+  "boolean",
+  "case",
+  "ceil",
+  "coalesce",
+  "collator",
+  "concat",
+  "cos",
+  "distance",
+  "downcase",
+  "e",
+  "elevation",
+  "error",
+  "feature-state",
+  "filter-<",
+  "filter-<=",
+  "filter-==",
+  "filter->",
+  "filter->=",
+  "filter-has",
+  "filter-has-id",
+  "filter-id-<",
+  "filter-id-<=",
+  "filter-id-==",
+  "filter-id->",
+  "filter-id->=",
+  "filter-id-in",
+  "filter-in-large",
+  "filter-in-small",
+  "filter-type-==",
+  "filter-type-in",
+  "floor",
+  "format",
+  "geometry-type",
+  "get",
+  "global-state",
+  "has",
+  "heatmap-density",
+  "id",
+  "image",
+  "in",
+  "index-of",
+  "interpolate",
+  "interpolate-hcl",
+  "interpolate-lab",
+  "is-supported-script",
+  "join",
+  "length",
+  "let",
+  "line-progress",
+  "literal",
+  "ln",
+  "ln2",
+  "log10",
+  "log2",
+  "match",
+  "max",
+  "min",
+  "number",
+  "number-format",
+  "object",
+  "pi",
+  "properties",
+  "resolved-locale",
+  "rgb",
+  "rgba",
+  "round",
+  "sin",
+  "slice",
+  "split",
+  "sqrt",
+  "step",
+  "string",
+  "tan",
+  "to-boolean",
+  "to-color",
+  "to-number",
+  "to-rgba",
+  "to-string",
+  "typeof",
+  "upcase",
+  "var",
+  "within",
+  "zoom"
+]);
+function isMapLibreExpressionOperator(value) {
+  return typeof value === "string" && mapLibreExpressionOperators.has(value);
+}
+
+// src/cartography/values.ts
+function toMapLibreStyleValue(value) {
+  if (isTileflowExpression(value)) {
+    return cloneJson(value.value);
+  }
+  if (isTileflowZoomValue(value)) {
+    if (value.interpolation === "step") {
+      const [[, firstValue], ...rest] = value.stops;
+      return [
+        "step",
+        ["zoom"],
+        cloneJson(firstValue),
+        ...rest.flatMap(([stop, stopValue]) => [stop, cloneJson(stopValue)])
+      ];
+    }
+    const interpolation = value.interpolation === "exponential" ? ["exponential", value.base] : [value.interpolation];
+    return [
+      "interpolate",
+      interpolation,
+      ["zoom"],
+      ...value.stops.flatMap(([stop, stopValue]) => [stop, cloneJson(stopValue)])
+    ];
+  }
+  if (isTileflowThemeValueNode(value)) {
+    throw new Error("Tileflow theme values must be resolved before MapLibre style compilation.");
+  }
+  return cloneJson(value);
+}
+function isTileflowExpression(value) {
+  return isRecord(value) && value.kind === "expression" && Array.isArray(value.value);
+}
+function isTileflowZoomValue(value) {
+  return isRecord(value) && value.kind === "zoom" && Array.isArray(value.stops);
+}
+function isTileflowThemeValueNode(value) {
+  return isRecord(value) && (value.kind === "theme-token" || value.kind === "theme-fixed" || value.kind === "theme-color");
+}
+function cloneJson(value) {
+  const serialized = JSON.stringify(value);
+  if (serialized === void 0) {
+    throw new Error("Tileflow style values must be JSON-serializable.");
+  }
+  return JSON.parse(serialized);
+}
+function isRecord(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+
+// src/modules/addresses/index.ts
+function addresses(options = {}) {
+  return { type: "addresses", ...cloneJson2(options) };
+}
+function cloneJson2(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+
+// src/modules/aeroways/index.ts
+function aeroways(options = {}) {
+  return { type: "aeroways", ...cloneJson3(options) };
+}
+function cloneJson3(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+
+// src/modules/boundaries/index.ts
+function boundaries(options = {}) {
+  return { type: "boundaries", ...cloneJson4(options) };
+}
+function cloneJson4(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+
+// src/modules/buildings/index.ts
+function buildings(options = {}) {
+  return { type: "buildings", ...cloneJson5(options) };
+}
+function cloneJson5(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+
+// src/modules/roads/index.ts
+var highwayRoadClasses = ["motorway", "trunk"];
+var arterialRoadClasses = ["primary", "secondary", "tertiary"];
+var majorRoadClasses = [...highwayRoadClasses, ...arterialRoadClasses];
+var majorRoadClassSet = new Set(majorRoadClasses);
+function roads(options = {}) {
+  return { type: "roads", ...cloneJson6(options) };
+}
+function cloneJson6(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+
+// src/modules/labels/index.ts
+function labels(options = {}) {
+  return { type: "labels", ...cloneJson7(options) };
+}
+function cloneJson7(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+
+// src/modules/land/index.ts
+function land(options = {}) {
+  return { type: "land", ...cloneJson8(options) };
+}
+function cloneJson8(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+
+// src/modules/landforms/index.ts
+function landforms(options = {}) {
+  return { type: "landforms", ...cloneJson9(options) };
+}
+function cloneJson9(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+
+// src/modules/nautical/index.ts
+function nautical(options = {}) {
+  return { type: "nautical", ...cloneJson10(options) };
+}
+function cloneJson10(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+
+// src/modules/poi/index.ts
+var tileflowPoiImageRoles = Object.freeze({
+  "arts-entertainment": { fallback: "culture", token: "poi.arts-entertainment" },
+  education: { fallback: "education", token: "poi.education" },
+  "food-drink": { fallback: "food", token: "poi.food-drink" },
+  landmark: { fallback: "culture", token: "poi.landmark" },
+  lodging: { fallback: "lodging", token: "poi.lodging" },
+  medical: { fallback: "health", token: "poi.medical" },
+  "park-nature": { fallback: "services", token: "poi.park-nature" },
+  "public-services": { fallback: "services", token: "poi.public-services" },
+  religion: { fallback: "culture", token: "poi.religion" },
+  retail: { fallback: "shopping", token: "poi.retail" },
+  "sport-leisure": { fallback: "culture", token: "poi.sport-leisure" },
+  transport: { fallback: "major-transit", token: "poi.transport" },
+  "visitor-amenity": { fallback: "services", token: "poi.visitor-amenity" }
+});
+function poi(options = {}) {
+  return { type: "poi", ...cloneJson11(options) };
+}
+function cloneJson11(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+
+// src/modules/transit/index.ts
+function transit(options = {}) {
+  return { type: "transit", ...cloneJson12(options) };
+}
+function cloneJson12(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+
+// src/modules/vegetation/index.ts
+function vegetation(options = {}) {
+  return { type: "vegetation", ...cloneJson13(options) };
+}
+function cloneJson13(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+
+// src/modules/water/index.ts
+function water(options = {}) {
+  return { type: "water", ...cloneJson14(options) };
+}
+function cloneJson14(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+
+// src/cartography/streets-recipe.ts
+var tileflowStreetsDefaultModules = {
+  addresses: addresses(),
+  aeroways: aeroways(),
+  boundaries: boundaries(),
+  buildings: buildings(),
+  labels: labels(),
+  land: land(),
+  landforms: landforms(),
+  nautical: nautical(),
+  poi: poi({ icons: true }),
+  roads: roads({
+    modifiers: {
+      construction: {
+        surface: {
+          casing: { dash: [2, 1], opacity: 0.62 },
+          fill: { dash: [2, 1], opacity: 0.68 }
+        }
+      },
+      expressway: { widthScale: 1.06 },
+      indoor: {
+        surface: {
+          casing: { dash: [1, 1], opacity: 0.28 },
+          fill: { dash: [1, 1], opacity: 0.42 }
+        }
+      },
+      ramp: { widthScale: 0.72 },
+      unpaved: {
+        surface: {
+          casing: { dash: [2, 1], opacity: 0.72 },
+          fill: { dash: [2, 1], opacity: 0.82 }
+        }
+      }
+    },
+    restrictions: {
+      access: {
+        surface: {
+          casing: { dash: [1.5, 1], opacity: 0.48 },
+          fill: { dash: [1.5, 1], opacity: 0.52 }
+        }
+      }
+    },
+    serviceTypes: {
+      alley: { widthScale: 0.82 },
+      crossover: { widthScale: 0.62 },
+      driveway: { widthScale: 0.76 },
+      parkingAisle: { widthScale: 0.62 },
+      yard: { widthScale: 0.7 }
+    }
+  }),
+  transit: transit(),
+  vegetation: vegetation({ mode: "3d" }),
+  water: water()
+};
+var tileflowStreetsRecipe = Object.freeze({
+  id: "streets",
+  version: 1,
+  modules: Object.freeze(tileflowStreetsDefaultModules)
+});
+var tileflowStreetsModuleNames = Object.freeze(
+  Object.keys(tileflowStreetsDefaultModules).sort()
+);
+
+// src/cartography/module-effects.ts
+var tileflowModuleEffects = /* @__PURE__ */ Symbol.for("@tileflow/core/module-effects/v1");
+function semanticField(name) {
+  return { kind: "tileflow-semantic-field", name };
+}
+function semanticLayer(name) {
+  return { kind: "tileflow-semantic-layer", name };
+}
+function patchModuleLayer(owner, target, patch, options = {}) {
+  return {
+    kind: "patch",
+    owner: requireModuleOwner(owner),
+    patch: cloneJson15(patch),
+    ...options.requires ? { requires: options.requires.map(requireLayerDomain) } : {},
+    target: requireTarget(owner, target)
+  };
+}
+function addModuleLayer(owner, target, layer, placement, options = {}) {
+  const semanticPlacement = "before" in placement ? { before: requireTarget(owner, placement.before) } : { after: requireTarget(owner, placement.after) };
+  return {
+    kind: "add",
+    layer: cloneJson15(layer),
+    owner: requireModuleOwner(owner),
+    placement: semanticPlacement,
+    ...options.requires ? { requires: options.requires.map(requireLayerDomain) } : {},
+    target: requireTarget(owner, target)
+  };
+}
+function removeModuleLayer(owner, target, options = {}) {
+  return {
+    kind: "remove",
+    owner: requireModuleOwner(owner),
+    ...options.requires ? { requires: options.requires.map(requireLayerDomain) } : {},
+    target: requireTarget(owner, target)
+  };
+}
+function internalModuleEffects(effects) {
+  return { [tileflowModuleEffects]: effects.map(cloneJson15) };
+}
+function getResolvedModuleEffects(input) {
+  return input[tileflowModuleEffects] ?? [];
+}
+function requireModuleOwner(owner) {
+  if (!tileflowStreetsModuleNames.includes(owner)) {
+    throw new Error(`Unknown Tileflow module effect owner: ${String(owner)}`);
+  }
+  return owner;
+}
+function requireLayerDomain(domain) {
+  if (!tileflowLayerDomains.includes(domain)) {
+    throw new Error(`Unknown Tileflow layer domain: ${String(domain)}`);
+  }
+  return domain;
+}
+function requireTarget(owner, target) {
+  if (!tileflowLayerTargetPattern.test(target)) {
+    throw new Error(`Tileflow module effect requires a portable semantic target: ${target}`);
+  }
+  if (target !== owner && !target.startsWith(`${owner}.`)) {
+    throw new Error(`Tileflow module effect target ${target} must belong to owner ${owner}.`);
+  }
+  return target;
+}
+function cloneJson15(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+
+// src/themes/visual-semantics.ts
+var visualNumberProperties = /* @__PURE__ */ new Set([
+  "angle",
+  "base",
+  "blur",
+  "crownScale",
+  "dash",
+  "exaggeration",
+  "fadeDuration",
+  "gapWidth",
+  "haloBlur",
+  "haloWidth",
+  "height",
+  "heightScale",
+  "illuminationDirection",
+  "intensity",
+  "letterSpacing",
+  "lineHeight",
+  "maxAngle",
+  "maxWidth",
+  "miterLimit",
+  "offset",
+  "opacity",
+  "padding",
+  "patternWidths",
+  "radius",
+  "radialOffset",
+  "rotate",
+  "roundLimit",
+  "size",
+  "spacing",
+  "strokeOpacity",
+  "strokeWidth",
+  "textFitPadding",
+  "translate",
+  "width",
+  "widthScale",
+  "background-emissive-strength",
+  "background-opacity",
+  "circle-blur",
+  "circle-emissive-strength",
+  "circle-opacity",
+  "circle-radius",
+  "circle-stroke-opacity",
+  "circle-stroke-width",
+  "circle-translate",
+  "color-relief-opacity",
+  "fill-emissive-strength",
+  "fill-extrusion-ambient-occlusion-ground-attenuation",
+  "fill-extrusion-ambient-occlusion-ground-radius",
+  "fill-extrusion-ambient-occlusion-intensity",
+  "fill-extrusion-ambient-occlusion-radius",
+  "fill-extrusion-base",
+  "fill-extrusion-emissive-strength",
+  "fill-extrusion-flood-light-ground-attenuation",
+  "fill-extrusion-flood-light-ground-radius",
+  "fill-extrusion-flood-light-intensity",
+  "fill-extrusion-flood-light-wall-radius",
+  "fill-extrusion-height",
+  "fill-extrusion-opacity",
+  "fill-extrusion-translate",
+  "fill-extrusion-vertical-scale",
+  "fill-opacity",
+  "fill-translate",
+  "heatmap-intensity",
+  "heatmap-opacity",
+  "heatmap-radius",
+  "heatmap-weight",
+  "hillshade-exaggeration",
+  "hillshade-emissive-strength",
+  "hillshade-illumination-direction",
+  "icon-emissive-strength",
+  "icon-halo-blur",
+  "icon-halo-width",
+  "icon-opacity",
+  "icon-occlusion-opacity",
+  "icon-offset",
+  "icon-padding",
+  "icon-size",
+  "icon-text-fit-padding",
+  "icon-translate",
+  "line-blur",
+  "line-dasharray",
+  "line-emissive-strength",
+  "line-gap-width",
+  "line-miter-limit",
+  "line-opacity",
+  "line-offset",
+  "line-round-limit",
+  "line-translate",
+  "line-width",
+  "raster-brightness-max",
+  "raster-brightness-min",
+  "raster-contrast",
+  "raster-emissive-strength",
+  "raster-fade-duration",
+  "raster-hue-rotate",
+  "raster-opacity",
+  "raster-saturation",
+  "text-emissive-strength",
+  "text-halo-blur",
+  "text-halo-width",
+  "text-letter-spacing",
+  "text-line-height",
+  "text-max-angle",
+  "text-max-width",
+  "text-offset",
+  "text-occlusion-opacity",
+  "text-opacity",
+  "text-padding",
+  "text-radial-offset",
+  "text-rotate",
+  "text-size",
+  "text-translate",
+  "symbol-spacing"
+]);
+function classifyTileflowVisualProperty(property, value) {
+  if (property === "color" || property === "colors" || property.endsWith("Color") || property.endsWith("Colors") || property.endsWith("-color") || property.endsWith("-colors")) {
+    return "color";
+  }
+  if (property === "font" || property === "fallbacks" || property.endsWith("-font")) return "font";
+  if (property === "image" || property === "pattern" || property.endsWith("-image") || property.endsWith("-pattern")) {
+    return "image";
+  }
+  return visualNumberProperties.has(property) ? "number" : void 0;
+}
+export {
+  addModuleLayer,
+  classifyTileflowVisualProperty,
+  internalModuleEffects as defineModuleEffects,
+  getResolvedModuleEffects,
+  isMapLibreExpressionOperator,
+  patchModuleLayer,
+  removeModuleLayer,
+  semanticField,
+  semanticLayer,
+  toMapLibreStyleValue
+};