tileflow 0.1.0-alpha.21 → 0.1.0-alpha.23

package/dist/chunk-GPPOECR5.js

@@ -0,0 +1,16 @@
+// src/cli-version.ts
+import { readFileSync } from "fs";
+function isRootCliVersionRequest(arguments_) {
+  return arguments_.length === 1 && (arguments_[0] === "--version" || arguments_[0] === "-V");
+}
+function getCliVersion() {
+  const document = JSON.parse(
+    readFileSync(new URL("../package.json", import.meta.url), "utf8")
+  );
+  return document.version;
+}
+
+export {
+  isRootCliVersionRequest,
+  getCliVersion
+};

package/dist/chunk-JVTGXPGV.js

@@ -0,0 +1,382 @@
+import {
+  TilesetBuildError
+} from "./chunk-43VQMAQO.js";
+
+// src/tileset-build/recipe.ts
+import { createHash } from "crypto";
+import { readFileSync as readFileSync2 } from "fs";
+import { z } from "zod";
+import { serializeCanonicalJson } from "@tileflow/core";
+
+// src/tileset-build/crs.ts
+import { existsSync, readFileSync } from "fs";
+import proj4 from "proj4";
+var wgs84Definition = "+proj=longlat +datum=WGS84 +no_defs";
+var radiansPerDegree = Math.PI / 180;
+var coincidentDatumPattern = /etrs|european_terrestrial_reference_system|rgf_?(19)?93|reseau_geodesique_francais_1993|nad_?(19)?83|north_american_(datum_)?1983|gda_?(19)?94|gda_?2020|geocentric_datum_of_australia|nzgd_?2000|new_zealand_geodetic_datum_2000|sirgas|jgd_?20(00|11)|japanese_geodetic_datum_20(00|11)/u;
+function resolveCrs(statement, reproject) {
+  const { authority, definition, label } = statement;
+  if (definition === null) {
+    throw new TilesetBuildError(
+      "TF_TILESET_BUILD_CRS_UNKNOWN",
+      "crs",
+      `${label} does not state its coordinate reference system. Pass --source-crs EPSG:4326 if the coordinates are WGS84 longitude and latitude, or --source-crs <crs> --reproject if they are not. The build never guesses.`
+    );
+  }
+  const parsed = parseDefinition(definition, label);
+  const datum = String(parsed.datumCode ?? "none").toLowerCase();
+  const angularUnit = parsed.projName === "longlat" ? parsed.UNIT?.convert : void 0;
+  if (angularUnit !== void 0 && Math.abs(angularUnit - radiansPerDegree) > 1e-9) {
+    throw new TilesetBuildError(
+      "TF_TILESET_BUILD_CRS_UNSUPPORTED",
+      "crs",
+      `${label} measures coordinates in "${parsed.UNIT?.name}"; only degrees can be converted here. Reproject the data to WGS84 with another tool first.`
+    );
+  }
+  const greenwich = Math.abs(parsed.from_greenwich ?? 0) < 1e-12;
+  if (parsed.projName === "longlat" && datum === "wgs84" && greenwich) {
+    return { authority, label, reprojected: false, transform: null };
+  }
+  if (!reproject) {
+    throw new TilesetBuildError(
+      "TF_TILESET_BUILD_CRS_NOT_WGS84",
+      "crs",
+      `${label} is not WGS84 longitude and latitude. Add --reproject to convert it, or reproject the data yourself first. The build never reprojects without being asked.`
+    );
+  }
+  const datumType = parsed.datum?.datum_type;
+  const hasShift = datumType === 1 || datumType === 2 || datumType === 4 || definition.includes("+nadgrids=@null");
+  const coincident = (!hasShift || datumType === 4) && coincidentDatumPattern.test(datum);
+  if (!hasShift && !coincident) {
+    throw new TilesetBuildError(
+      "TF_TILESET_BUILD_DATUM_UNSUPPORTED",
+      "crs",
+      `${label} uses datum "${datum}", which has no known shift to WGS84 here; converting it would misplace features by up to hundreds of metres. Reproject with a tool that supports the datum, or pass a --source-crs proj string with +towgs84=.`
+    );
+  }
+  const converter = proj4(definition, wgs84Definition);
+  return {
+    authority,
+    label,
+    reprojected: true,
+    transform: (x, y) => converter.forward([x, y]),
+    ...coincident ? {
+      warning: `${label} uses datum "${datum}", treated as coincident with WGS84 (typically within 2 m).`
+    } : {}
+  };
+}
+function isInlineCrs(value) {
+  const trimmed = value.trim();
+  return /^epsg:\d{4,6}$/iu.test(trimmed) || isProjOrWkt(trimmed);
+}
+function isProjOrWkt(trimmed) {
+  return trimmed.startsWith("+") || /^[A-Z_]+\[/u.test(trimmed);
+}
+function portableCrs(value) {
+  if (isInlineCrs(value)) return value.trim();
+  return parseSourceCrsOption(value).definition;
+}
+function parseSourceCrsOption(value) {
+  const trimmed = value.trim();
+  const epsg = /^epsg:(\d{4,6})$/iu.exec(trimmed)?.[1];
+  if (epsg) {
+    const definition = epsgDefinition(Number(epsg));
+    if (!definition) {
+      throw new TilesetBuildError(
+        "TF_TILESET_BUILD_CRS_UNREADABLE",
+        "crs",
+        `EPSG:${epsg} has no built-in definition. Pass a proj string, WKT, or the path to a .prj file instead.`
+      );
+    }
+    return { authority: "option", definition, label: `EPSG:${epsg}` };
+  }
+  if (isProjOrWkt(trimmed)) {
+    return { authority: "option", definition: trimmed, label: "--source-crs" };
+  }
+  if (existsSync(trimmed)) {
+    return {
+      authority: "option",
+      definition: readFileSync(trimmed, "utf8").trim(),
+      label: "--source-crs"
+    };
+  }
+  throw new TilesetBuildError(
+    "TF_TILESET_BUILD_CRS_UNREADABLE",
+    "crs",
+    `Could not read --source-crs "${trimmed}". Expected EPSG:<code>, a proj string, WKT, or a .prj file path.`
+  );
+}
+function statementFromGeojsonCrs(member) {
+  const name = member?.properties?.name;
+  if (typeof name !== "string") {
+    throw new TilesetBuildError(
+      "TF_TILESET_BUILD_CRS_UNREADABLE",
+      "crs",
+      "The GeoJSON crs member is not a named CRS. Pass --source-crs to state it."
+    );
+  }
+  const code = /(?:epsg:(?::?[\d.]*:)?|ogc:(?:[\d.]*:)?crs)(\d+)/iu.exec(name)?.[1];
+  if (/crs:?84/iu.test(name) || code === "84" || code === "4326") {
+    return { authority: "declared", definition: wgs84Definition, label: `GeoJSON crs ${name}` };
+  }
+  const definition = code ? epsgDefinition(Number(code)) : null;
+  if (!definition) {
+    throw new TilesetBuildError(
+      "TF_TILESET_BUILD_CRS_UNREADABLE",
+      "crs",
+      `The GeoJSON crs "${name}" has no built-in definition. Pass --source-crs with a proj string, WKT, or .prj path, plus --reproject.`
+    );
+  }
+  return { authority: "declared", definition, label: `GeoJSON crs ${name}` };
+}
+function statementFromGeopackageSrs(layer, srs) {
+  if (!srs || srs.srsId === -1 || srs.srsId === 0) {
+    return {
+      authority: "declared",
+      definition: null,
+      label: `GeoPackage layer "${layer}"`
+    };
+  }
+  const epsg = srs.organization?.toUpperCase() === "EPSG" ? srs.organizationCode : null;
+  const label = epsg === null ? `GeoPackage layer "${layer}" (srs_id ${srs.srsId})` : `GeoPackage layer "${layer}" (EPSG:${epsg})`;
+  const pseudoMercator = epsg === 3857 || epsg === 3785 || epsg === 900913 || /^PROJCS\["[^"]*pseudo[ _-]?mercator/iu.test(srs.definition ?? "");
+  const exact = pseudoMercator ? epsgDefinition(3857) : epsg === 4326 ? wgs84Definition : null;
+  const known = epsg === null ? null : epsgDefinition(epsg);
+  return {
+    authority: "declared",
+    definition: exact ?? statedWkt(srs.definition) ?? known ?? statedWkt(srs.definition12063),
+    label
+  };
+}
+function statedWkt(value) {
+  const trimmed = value?.trim();
+  return trimmed && trimmed.toLowerCase() !== "undefined" ? trimmed : null;
+}
+var wgs84Statement = (authority, label) => ({ authority, definition: wgs84Definition, label });
+function epsgDefinition(code) {
+  if (code === 4326) return wgs84Definition;
+  if (code === 3857 || code === 900913) {
+    return "+proj=merc +a=6378137 +b=6378137 +lat_ts=0 +lon_0=0 +x_0=0 +y_0=0 +k=1 +units=m +nadgrids=@null +no_defs";
+  }
+  if (code === 4258)
+    return "+proj=longlat +ellps=GRS80 +datum=ETRS89 +towgs84=0,0,0,0,0,0,0 +no_defs";
+  if (code === 4269)
+    return "+proj=longlat +ellps=GRS80 +datum=NAD83 +towgs84=0,0,0,0,0,0,0 +no_defs";
+  const zone = code % 100;
+  if (code >= 32601 && code <= 32660) return `+proj=utm +zone=${zone} +datum=WGS84 +no_defs`;
+  if (code >= 32701 && code <= 32760) return `+proj=utm +zone=${zone} +south +datum=WGS84 +no_defs`;
+  if (code >= 25801 && code <= 25860 || code >= 26901 && code <= 26923) {
+    return `+proj=utm +zone=${zone} +ellps=GRS80 +towgs84=0,0,0,0,0,0,0 +units=m +no_defs`;
+  }
+  return null;
+}
+function parseDefinition(definition, label) {
+  try {
+    return new proj4.Proj(definition);
+  } catch {
+    throw new TilesetBuildError(
+      "TF_TILESET_BUILD_CRS_UNREADABLE",
+      "crs",
+      `${label} could not be parsed as a coordinate reference system. Pass --source-crs with a proj string, WKT, or .prj path.`
+    );
+  }
+}
+
+// src/tileset-build/recipe.ts
+var tilesetRecipeSchemaUrl = "https://tileflow.dev/schemas/tileset-recipe/v1.json";
+var maximumZoom = 16;
+var layerNamePattern = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,191}$/u;
+var maximumRecipeBytes = 1024 * 1024;
+var nonEmpty = z.string().min(1);
+var zoom = z.number().int().min(0).max(maximumZoom);
+var entryName = z.string().regex(layerNamePattern);
+var sourceSchema = z.strictObject({
+  crs: z.strictObject({
+    from: nonEmpty.refine(isInlineCrs, {
+      message: "must be EPSG:<code>, a proj string or WKT; a recipe cannot name a file"
+    }).optional(),
+    reproject: z.boolean().optional()
+  }).optional(),
+  csv: z.strictObject({ lat: nonEmpty.optional(), lon: nonEmpty.optional() }).optional(),
+  format: z.enum(["csv", "geojson", "geojsonseq", "geopackage", "gpx", "kml", "shapefile"]).optional(),
+  layer: nonEmpty.optional(),
+  zipEntry: nonEmpty.optional()
+});
+var layerSchema = z.strictObject({
+  featureId: z.strictObject({ field: nonEmpty, hash: z.boolean().optional() }).optional(),
+  fields: z.strictObject({ exclude: z.array(nonEmpty).optional(), include: z.array(nonEmpty).optional() }).refine((fields) => !(fields.exclude && fields.include), {
+    message: "include and exclude cannot be combined"
+  }).optional(),
+  maxzoom: z.union([z.literal("auto"), zoom]).optional(),
+  minzoom: zoom.optional(),
+  rank: z.strictObject({ by: nonEmpty, order: z.enum(["ascending", "descending"]).optional() }).optional(),
+  source: nonEmpty
+});
+var recipeObject = z.strictObject({
+  $schema: z.string().optional(),
+  layers: z.record(entryName, layerSchema),
+  metadata: z.strictObject({
+    attribution: nonEmpty.optional(),
+    description: nonEmpty.optional(),
+    name: nonEmpty.optional()
+  }).optional(),
+  sources: z.record(entryName, sourceSchema),
+  version: z.literal(1)
+});
+var recipeSchema = recipeObject.superRefine((recipe, context) => {
+  for (const key of ["sources", "layers"]) {
+    if (Object.keys(recipe[key]).length !== 1) {
+      context.addIssue({ code: "custom", message: "needs exactly one entry", path: [key] });
+    }
+  }
+  for (const [name, layer] of Object.entries(recipe.layers)) {
+    if (!Object.hasOwn(recipe.sources, layer.source)) {
+      context.addIssue({
+        code: "custom",
+        message: `names no source in "sources"`,
+        path: ["layers", name, "source"]
+      });
+    }
+    if (typeof layer.maxzoom === "number" && layer.maxzoom < (layer.minzoom ?? 0)) {
+      context.addIssue({
+        code: "custom",
+        message: "is below minzoom",
+        path: ["layers", name, "maxzoom"]
+      });
+    }
+  }
+});
+var present = (key, value) => value === void 0 ? {} : { [key]: value };
+function recipeFromSettings(settings, layer) {
+  const csv = { ...present("lat", settings.latColumn), ...present("lon", settings.lonColumn) };
+  const crs = {
+    ...settings.sourceCrs === void 0 ? {} : { from: portableCrs(settings.sourceCrs) },
+    ...settings.reproject ? { reproject: true } : {}
+  };
+  const fields = { ...present("exclude", settings.exclude), ...present("include", settings.include) };
+  const metadata = {
+    ...present("attribution", settings.attribution),
+    ...present("description", settings.description),
+    ...present("name", settings.name)
+  };
+  return {
+    $schema: tilesetRecipeSchemaUrl,
+    layers: {
+      [layer]: {
+        ...present("featureId", settings.featureId),
+        ...Object.keys(fields).length > 0 ? { fields } : {},
+        maxzoom: settings.maxzoom ?? "auto",
+        minzoom: settings.minzoom ?? 0,
+        ...settings.rankBy === void 0 ? {} : {
+          rank: {
+            by: settings.rankBy,
+            order: settings.rankAscending ? "ascending" : "descending"
+          }
+        },
+        source: layer
+      }
+    },
+    ...Object.keys(metadata).length > 0 ? { metadata } : {},
+    sources: {
+      [layer]: {
+        ...Object.keys(crs).length > 0 ? { crs } : {},
+        ...Object.keys(csv).length > 0 ? { csv } : {},
+        ...present("format", settings.format),
+        ...present("layer", settings.inputLayer),
+        ...present("zipEntry", settings.zipEntry)
+      }
+    },
+    version: 1
+  };
+}
+function settingsFromRecipe(recipe) {
+  const [layerName, layer] = Object.entries(recipe.layers)[0];
+  const source = recipe.sources[layer.source];
+  return {
+    ...present("attribution", recipe.metadata?.attribution),
+    ...present("description", recipe.metadata?.description),
+    ...present("exclude", layer.fields?.exclude),
+    ...present("featureId", layer.featureId),
+    ...present("format", source.format),
+    ...present("include", layer.fields?.include),
+    ...present("inputLayer", source.layer),
+    ...present("latColumn", source.csv?.lat),
+    layer: layerName,
+    ...present("lonColumn", source.csv?.lon),
+    ...typeof layer.maxzoom === "number" ? { maxzoom: layer.maxzoom } : {},
+    ...present("minzoom", layer.minzoom),
+    ...present("name", recipe.metadata?.name),
+    ...layer.rank?.order === "ascending" ? { rankAscending: true } : {},
+    ...present("rankBy", layer.rank?.by),
+    ...source.crs?.reproject ? { reproject: true } : {},
+    ...present("sourceCrs", source.crs?.from),
+    ...present("zipEntry", source.zipEntry)
+  };
+}
+function parseTilesetRecipe(text) {
+  let document;
+  try {
+    document = JSON.parse(text);
+  } catch {
+    throw new TilesetBuildError(
+      "TF_TILESET_BUILD_RECIPE_INVALID",
+      "recipe",
+      "The recipe is not valid JSON."
+    );
+  }
+  const parsed = recipeSchema.safeParse(document);
+  if (parsed.success) return parsed.data;
+  const issue = parsed.error.issues[0];
+  const location = issue.path.join(".");
+  throw new TilesetBuildError(
+    "TF_TILESET_BUILD_RECIPE_INVALID",
+    location ? `recipe.${location}` : "recipe",
+    `Invalid recipe${location ? ` at ${location}` : ""}: ${issue.message}.`
+  );
+}
+function readTilesetRecipe(path) {
+  let bytes;
+  try {
+    bytes = readFileSync2(path);
+  } catch {
+    throw new TilesetBuildError(
+      "TF_TILESET_BUILD_RECIPE_UNREADABLE",
+      "recipe",
+      `Could not read the recipe ${path}.`
+    );
+  }
+  if (bytes.length > maximumRecipeBytes) {
+    throw new TilesetBuildError(
+      "TF_TILESET_BUILD_RECIPE_INVALID",
+      "recipe",
+      `The recipe is larger than ${maximumRecipeBytes} bytes.`
+    );
+  }
+  return parseTilesetRecipe(bytes.toString("utf8"));
+}
+function tilesetRecipeJsonSchema() {
+  return {
+    $id: tilesetRecipeSchemaUrl,
+    ...z.toJSONSchema(recipeObject, { target: "draft-2020-12" })
+  };
+}
+function recipeHash(recipe) {
+  return `sha256:${createHash("sha256").update(serializeCanonicalJson(recipe)).digest("hex")}`;
+}
+
+export {
+  resolveCrs,
+  parseSourceCrsOption,
+  statementFromGeojsonCrs,
+  statementFromGeopackageSrs,
+  wgs84Statement,
+  tilesetRecipeSchemaUrl,
+  maximumZoom,
+  layerNamePattern,
+  recipeFromSettings,
+  settingsFromRecipe,
+  parseTilesetRecipe,
+  readTilesetRecipe,
+  tilesetRecipeJsonSchema,
+  recipeHash
+};