tileflow 0.1.0-alpha.22 → 0.1.0-alpha.23

package/dist/errors-C3VZMCM5.js

@@ -0,0 +1,20 @@
+import {
+  SampleComplete,
+  TilesetBuildError,
+  featureTooLarge,
+  featureTooManyBytes,
+  listChoices,
+  maximumFeatureBytes,
+  maximumFeaturePositions,
+  yieldToEventLoop
+} from "./chunk-43VQMAQO.js";
+export {
+  SampleComplete,
+  TilesetBuildError,
+  featureTooLarge,
+  featureTooManyBytes,
+  listChoices,
+  maximumFeatureBytes,
+  maximumFeaturePositions,
+  yieldToEventLoop
+};

package/dist/index.js

@@ -9,8 +9,8 @@ if (isRootCliVersionRequest(process.argv.slice(2))) {
   process.stdout.write(`${getCliVersion()}
 `);
 } else if (process.argv[2] === "tileset") {
-  const { runTilesetCli } = await import("./tileset-entry-ITUSGCM3.js");
+  const { runTilesetCli } = await import("./tileset-entry-V5RUQGZG.js");
   await runTilesetCli();
 } else {
-  await import("./cli-main-HRFGWUWR.js");
+  await import("./cli-main-K3PKVCIP.js");
 }

package/dist/inspect-source-5CD3AV5J.js

@@ -0,0 +1,227 @@
+import {
+  FeatureIngest,
+  FeatureSpool,
+  GeoPackageLayer,
+  SpoolDirectory,
+  ZippedKml,
+  ZippedShapefile,
+  checkContainerFormat,
+  checkInputSignature,
+  chooseCrsStatement,
+  chooseLayer,
+  csvColumnNames,
+  csvColumnsNameCoordinates,
+  detectFormat,
+  fileChunks,
+  isKmz,
+  isZip,
+  readCsv,
+  readGeojson,
+  readGeojsonSequence,
+  readGpx,
+  readKml,
+  readShapefile
+} from "./chunk-5U4J6E6Y.js";
+import {
+  recipeFromSettings,
+  resolveCrs
+} from "./chunk-JVTGXPGV.js";
+import {
+  SampleComplete,
+  TilesetBuildError
+} from "./chunk-43VQMAQO.js";
+import "./chunk-GPPOECR5.js";
+
+// src/tileset-build/inspect-source.ts
+import { mkdtempSync, rmSync, statSync } from "fs";
+import { tmpdir } from "os";
+import { join, resolve } from "path";
+var defaultSampleFeatures = 1e4;
+var maximumSampleCoordinates = 2e3;
+async function inspectTilesetSource(options) {
+  const input = resolve(options.input);
+  if (!statSync(input, { throwIfNoEntry: false })?.isFile()) {
+    throw new TilesetBuildError(
+      "TF_TILESET_BUILD_INPUT_MISSING",
+      "input",
+      `Input file not found: ${options.input}.`
+    );
+  }
+  const format = options.format ?? detectFormat(input);
+  const zipped = isZip(input);
+  const kmz = isKmz(input);
+  checkContainerFormat(format, zipped, kmz);
+  checkInputSignature(input, format, zipped ? "zip" : kmz ? "kmz" : null);
+  const base = { command: "tileset build --inspect", format, schemaVersion: 1 };
+  let zip = null;
+  let zippedKml = null;
+  let geopackage = null;
+  try {
+    zip = zipped ? await ZippedShapefile.open(input, options.zipEntry) : null;
+    zippedKml = kmz ? await ZippedKml.open(input, options.zipEntry) : null;
+    geopackage = format === "geopackage" ? GeoPackageLayer.open(input, options.inputLayer) : null;
+  } catch (error) {
+    if (error instanceof TilesetBuildError && error.choices) {
+      const option = error.path === "inputLayer" ? "inputLayer" : "zipEntry";
+      return { ...base, choices: { names: error.choices.slice(0, 1e3), option } };
+    }
+    throw error;
+  }
+  const temporary = mkdtempSync(join(tmpdir(), "tileflow-tileset-inspect-"));
+  try {
+    const shapefile = zip ? await zip.extractProjection(temporary) : input;
+    const statement = await chooseCrsStatement(format, shapefile, options, geopackage);
+    if (format === "csv" && !await csvColumnsNameCoordinates(input, options)) {
+      return {
+        ...base,
+        columns: await csvColumnNames(input),
+        crs: { label: statement.label, status: "unknown" }
+      };
+    }
+    const reading = coordinateProbe(statement);
+    if (zip) await zip.extractData(temporary);
+    const directory = new SpoolDirectory(temporary);
+    const ingest = new FeatureIngest(
+      new FeatureSpool(directory),
+      { exclude: null, include: null },
+      reading.transform
+    );
+    ingest.stopAfter = options.sampleFeatures ?? defaultSampleFeatures;
+    let complete = true;
+    try {
+      await readSample(format, input, shapefile, ingest, options, zippedKml, geopackage);
+    } catch (error) {
+      if (!(error instanceof SampleComplete)) throw error;
+      complete = false;
+    }
+    const layer = chooseLayer(options.layer, options.inputLayer, input);
+    const crs = reading.crs();
+    const recipe = recipeFromSettings(
+      { ...options, ...crs.status === "needs-reproject" ? { reproject: true } : {} },
+      layer
+    );
+    if (ingest.featureCount === 0) {
+      return {
+        ...base,
+        crs,
+        recipe,
+        sample: {
+          bounds: null,
+          complete,
+          coordinates: reading.coordinates(),
+          features: 0,
+          sourceBounds: reading.bounds()
+        }
+      };
+    }
+    const summary = ingest.finish();
+    return {
+      ...base,
+      crs,
+      fields: summary.fields,
+      geometryTypes: summary.geometryTypes,
+      recipe,
+      sample: {
+        bounds: crs.status === "wgs84" || crs.status === "needs-reproject" ? summary.bounds : null,
+        complete,
+        coordinates: reading.coordinates(),
+        features: summary.features,
+        sourceBounds: reading.bounds()
+      },
+      warnings: summary.warnings
+    };
+  } finally {
+    zip?.close();
+    zippedKml?.close();
+    geopackage?.close();
+    rmSync(temporary, { force: true, recursive: true });
+  }
+}
+async function readSample(format, input, shapefile, ingest, options, zippedKml, geopackage) {
+  switch (format) {
+    case "csv":
+      return readCsv(input, ingest, options);
+    case "geojson":
+      return readGeojson(input, ingest, () => {
+      });
+    case "geojsonseq":
+      return readGeojsonSequence(input, ingest);
+    case "geopackage":
+      return geopackage.read(ingest, options.sourceCrs === void 0);
+    case "gpx":
+      return readGpx(fileChunks(input), ingest);
+    case "kml":
+      return readKml(zippedKml ? zippedKml.chunks() : fileChunks(input), ingest);
+    case "shapefile":
+      return readShapefile(shapefile, ingest);
+  }
+}
+function coordinateProbe(statement) {
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  let outOfRange = false;
+  const coordinates = [];
+  let seen = 0;
+  let stride = 1;
+  let real = null;
+  let crs;
+  if (statement.definition === null) {
+    crs = { label: statement.label, status: "unknown" };
+  } else {
+    try {
+      const resolved = resolveCrs(statement, true);
+      real = resolved.transform;
+      crs = { label: resolved.label, status: resolved.transform ? "needs-reproject" : "wgs84" };
+    } catch (error) {
+      if (!(error instanceof TilesetBuildError)) throw error;
+      crs = {
+        label: statement.label,
+        problem: { code: error.code, message: error.message },
+        status: "unsupported"
+      };
+    }
+  }
+  const usable = crs.status === "wgs84" || crs.status === "needs-reproject";
+  const transform = (x, y) => {
+    if (x < minX) minX = x;
+    if (y < minY) minY = y;
+    if (x > maxX) maxX = x;
+    if (y > maxY) maxY = y;
+    if (seen % stride === 0) {
+      if (coordinates.length === maximumSampleCoordinates) {
+        for (let index = 0; index < coordinates.length / 2; index += 1) {
+          coordinates[index] = coordinates[index * 2];
+        }
+        coordinates.length /= 2;
+        stride *= 2;
+      }
+      if (seen % stride === 0) coordinates.push([x, y]);
+    }
+    seen += 1;
+    if (!usable) return [0, 0];
+    const [longitude, latitude] = real ? real(x, y) : [x, y];
+    if (!Number.isFinite(longitude) || !Number.isFinite(latitude) || Math.abs(longitude) > 180 || Math.abs(latitude) > 90) {
+      outOfRange = true;
+      return [0, 0];
+    }
+    return [longitude, latitude];
+  };
+  return {
+    coordinates: () => coordinates,
+    bounds: () => Number.isFinite(minX) ? [minX, minY, maxX, maxY] : null,
+    crs: () => outOfRange ? {
+      label: crs.label,
+      problem: {
+        code: "TF_TILESET_BUILD_COORDINATES_OUT_OF_RANGE",
+        message: `Some coordinates are not valid longitude and latitude under ${crs.label}. The stated CRS is probably wrong.`
+      },
+      status: "out-of-range"
+    } : crs,
+    transform
+  };
+}
+export {
+  inspectTilesetSource
+};

package/dist/recipe-3BPMNDPX.js

@@ -0,0 +1,23 @@
+import {
+  layerNamePattern,
+  maximumZoom,
+  parseTilesetRecipe,
+  readTilesetRecipe,
+  recipeFromSettings,
+  recipeHash,
+  settingsFromRecipe,
+  tilesetRecipeJsonSchema,
+  tilesetRecipeSchemaUrl
+} from "./chunk-JVTGXPGV.js";
+import "./chunk-43VQMAQO.js";
+export {
+  layerNamePattern,
+  maximumZoom,
+  parseTilesetRecipe,
+  readTilesetRecipe,
+  recipeFromSettings,
+  recipeHash,
+  settingsFromRecipe,
+  tilesetRecipeJsonSchema,
+  tilesetRecipeSchemaUrl
+};

package/dist/{tileset-entry-ITUSGCM3.js → tileset-entry-V5RUQGZG.js}

@@ -1,8 +1,10 @@
 import {
   createCliProgram,
+  isRestoreJsonCommand,
   loadAuthConfig,
+  parseRestoreJson,
   registerTilesetCommands
-} from "./chunk-5QK6JCLT.js";
+} from "./chunk-EXDH7EHK.js";
 
 // src/tileset-entry.ts
 import pc from "picocolors";
@@ -10,6 +12,7 @@ import { defaultTileflowApiUrl } from "@tileflow/dev/config";
 async function runTilesetCli() {
   const program = createCliProgram();
   registerTilesetCommands(program, { defaultApiUrl: defaultTileflowApiUrl, loadAuthConfig });
+  if (isRestoreJsonCommand(process.argv.slice(2))) return parseRestoreJson(program);
   try {
     await program.parseAsync();
   } catch (error) {

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "tileflow",
-  "version": "0.1.0-alpha.22",
+  "version": "0.1.0-alpha.23",
   "license": "Apache-2.0",
-  "description": "CLI-only tools for Tileflow config, capture, visual testing, and deploy.",
+  "description": "CLI-only tools for Tileflow config, capture, visual testing, tiling, and deploy.",
   "type": "module",
   "homepage": "https://tileflow.dev",
   "repository": {
@@ -25,6 +25,8 @@
   },
   "files": [
     "dist",
+    "schemas",
+    "REFERENCE.md",
     "LICENSE"
   ],
   "bin": {
@@ -38,16 +40,23 @@
     "@tileflow/capture": ">=0.1.0-alpha.38 <0.1.0-beta.0",
     "@tileflow/coordinates": ">=0.1.0-alpha.3 <0.1.0-beta.0",
     "@tileflow/coordinates-runtime": ">=0.1.0-alpha.6 <0.1.0-beta.0",
-    "@tileflow/core": ">=0.1.0-alpha.47 <0.1.0-beta.0",
-    "@tileflow/dev": ">=0.1.0-alpha.42 <0.1.0-beta.0",
-    "@tileflow/maps": ">=0.1.0-alpha.19 <0.1.0-beta.0",
+    "@tileflow/core": ">=0.1.0-alpha.48 <0.1.0-beta.0",
+    "@tileflow/dev": ">=0.1.0-alpha.43 <0.1.0-beta.0",
+    "@tileflow/maps": ">=0.1.0-alpha.20 <0.1.0-beta.0",
     "commander": "^15.0.0",
+    "fflate": "0.8.3",
     "hono": "4.13.14",
     "picocolors": "^1.1.1",
+    "pmtiles": "4.5.0",
+    "proj4": "2.22.0",
+    "yauzl": "3.4.0",
     "zod": "^4.6.7"
   },
   "devDependencies": {
+    "@mapbox/vector-tile": "3.0.0",
     "@types/pngjs": "6.0.5",
+    "@types/yauzl": "3.4.0",
+    "pbf": "5.1.2",
     "pngjs": "7.0.0"
   },
   "scripts": {

package/schemas/tileset-recipe.v1.json

@@ -0,0 +1,171 @@
+{
+  "$id": "https://tileflow.dev/schemas/tileset-recipe/v1.json",
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "type": "object",
+  "properties": {
+    "$schema": {
+      "type": "string"
+    },
+    "layers": {
+      "type": "object",
+      "propertyNames": {
+        "type": "string",
+        "pattern": "^[A-Za-z0-9][A-Za-z0-9._:-]{0,191}$"
+      },
+      "additionalProperties": {
+        "type": "object",
+        "properties": {
+          "featureId": {
+            "type": "object",
+            "properties": {
+              "field": {
+                "type": "string",
+                "minLength": 1
+              },
+              "hash": {
+                "type": "boolean"
+              }
+            },
+            "required": ["field"],
+            "additionalProperties": false
+          },
+          "fields": {
+            "type": "object",
+            "properties": {
+              "exclude": {
+                "type": "array",
+                "items": {
+                  "type": "string",
+                  "minLength": 1
+                }
+              },
+              "include": {
+                "type": "array",
+                "items": {
+                  "type": "string",
+                  "minLength": 1
+                }
+              }
+            },
+            "additionalProperties": false
+          },
+          "maxzoom": {
+            "anyOf": [
+              {
+                "type": "string",
+                "const": "auto"
+              },
+              {
+                "type": "integer",
+                "minimum": 0,
+                "maximum": 16
+              }
+            ]
+          },
+          "minzoom": {
+            "type": "integer",
+            "minimum": 0,
+            "maximum": 16
+          },
+          "rank": {
+            "type": "object",
+            "properties": {
+              "by": {
+                "type": "string",
+                "minLength": 1
+              },
+              "order": {
+                "type": "string",
+                "enum": ["ascending", "descending"]
+              }
+            },
+            "required": ["by"],
+            "additionalProperties": false
+          },
+          "source": {
+            "type": "string",
+            "minLength": 1
+          }
+        },
+        "required": ["source"],
+        "additionalProperties": false
+      }
+    },
+    "metadata": {
+      "type": "object",
+      "properties": {
+        "attribution": {
+          "type": "string",
+          "minLength": 1
+        },
+        "description": {
+          "type": "string",
+          "minLength": 1
+        },
+        "name": {
+          "type": "string",
+          "minLength": 1
+        }
+      },
+      "additionalProperties": false
+    },
+    "sources": {
+      "type": "object",
+      "propertyNames": {
+        "type": "string",
+        "pattern": "^[A-Za-z0-9][A-Za-z0-9._:-]{0,191}$"
+      },
+      "additionalProperties": {
+        "type": "object",
+        "properties": {
+          "crs": {
+            "type": "object",
+            "properties": {
+              "from": {
+                "type": "string",
+                "minLength": 1
+              },
+              "reproject": {
+                "type": "boolean"
+              }
+            },
+            "additionalProperties": false
+          },
+          "csv": {
+            "type": "object",
+            "properties": {
+              "lat": {
+                "type": "string",
+                "minLength": 1
+              },
+              "lon": {
+                "type": "string",
+                "minLength": 1
+              }
+            },
+            "additionalProperties": false
+          },
+          "format": {
+            "type": "string",
+            "enum": ["csv", "geojson", "geojsonseq", "geopackage", "gpx", "kml", "shapefile"]
+          },
+          "layer": {
+            "type": "string",
+            "minLength": 1
+          },
+          "zipEntry": {
+            "type": "string",
+            "minLength": 1
+          }
+        },
+        "additionalProperties": false
+      }
+    },
+    "version": {
+      "type": "number",
+      "const": 1
+    }
+  },
+  "required": ["layers", "sources", "version"],
+  "additionalProperties": false
+}