@tileflow/dev 0.1.0-alpha.2 → 0.1.0-alpha.21

package/dist/index.js

@@ -1,314 +1,188 @@
-// src/index.ts
 import {
-  createManifest,
-  createStyleFromProject,
-  validateConfig
-} from "@tileflow/core";
-import { existsSync } from "fs";
-import { mkdir, writeFile } from "fs/promises";
-import { resolve } from "path";
-import { createJiti } from "jiti";
-var defaultTileflowApiUrl = "https://api.tileflow.dev";
-var defaultTileflowConfigPath = "tileflow.config.ts";
-var defaultTileflowManifestPath = "public/tileflow/manifest.json";
-var defaultTileflowTileset = "world";
-var TileflowValidationError = class extends Error {
-  messages;
-  constructor(messages) {
-    super("Invalid Tileflow config");
-    this.name = "TileflowValidationError";
-    this.messages = messages;
-  }
-};
-async function loadTileflowConfig(configPath = defaultTileflowConfigPath, options = {}) {
-  const cwd = options.cwd ?? process.cwd();
-  const resolvedPath = resolve(cwd, configPath);
-  if (!existsSync(resolvedPath)) {
-    throw new Error(`Config not found: ${configPath}`);
-  }
-  const jiti = createJiti(import.meta.url, {
-    fsCache: false,
-    moduleCache: !options.fresh
-  });
-  const imported = await jiti.import(resolvedPath, { default: true });
-  return asTileflowProjectConfig(imported);
-}
-async function loadValidTileflowConfig(configPath = defaultTileflowConfigPath, options = {}) {
-  const project = await loadTileflowConfig(configPath, options);
-  assertValidTileflowConfig(project);
-  return project;
-}
-function assertValidTileflowConfig(project) {
-  const result = validateConfig(project);
-  if (!result.valid) {
-    throw new TileflowValidationError(result.messages);
-  }
-}
-function asTileflowProjectConfig(input) {
-  if (input && typeof input === "object" && "maps" in input && typeof input.maps === "object") {
-    return input;
-  }
-  return {
-    tilesets: {
-      [defaultTileflowTileset]: {
-        id: defaultTileflowTileset,
-        name: "World"
-      }
-    },
-    maps: {
-      main: input
-    }
-  };
-}
-function getTileflowMapNames(project) {
-  return Object.keys(project.maps);
-}
-function getFirstTileflowMapName(project) {
-  const [mapName] = getTileflowMapNames(project);
-  if (!mapName) {
-    throw new Error("Tileflow config must define at least one map.");
-  }
-  return mapName;
-}
-function getTileflowStyleMapName(path) {
-  const fileName = path.split("/").pop() ?? "";
-  return fileName.replace(/\.json$/, "");
-}
-function createTileflowManifest(project, options = {}) {
-  return createManifest(project, options);
-}
-function createTileflowStyle(project, mapName, options = {}) {
-  return createStyleFromProject(project, mapName, options);
-}
-async function createTileflowBuildArtifacts(options = {}) {
-  const project = await loadValidTileflowConfig(
-    options.config ?? defaultTileflowConfigPath,
-    {
-      cwd: options.cwd,
-      fresh: true
-    }
-  );
-  const styleOptions = { tileBaseUrl: options.tileBaseUrl };
-  const styles = Object.fromEntries(
-    getTileflowMapNames(project).map((mapName) => [
-      mapName,
-      createStyleFromProject(project, mapName, styleOptions)
-    ])
-  );
-  return {
-    manifest: createManifest(project, {
-      styleBaseUrl: options.styleBaseUrl,
-      tileBaseUrl: options.tileBaseUrl
-    }),
-    styles
-  };
-}
-async function writeTileflowBuildArtifacts(options) {
-  const cwd = options.cwd ?? process.cwd();
-  const outDir = resolve(cwd, options.outDir);
-  const stylesDir = resolve(outDir, "styles");
-  const artifacts = await createTileflowBuildArtifacts(options);
-  await mkdir(stylesDir, { recursive: true });
-  for (const [mapName, style] of Object.entries(artifacts.styles)) {
-    await writeFile(
-      resolve(stylesDir, `${mapName}.json`),
-      `${JSON.stringify(style, null, 2)}
-`,
-      "utf8"
-    );
-  }
-  await writeFile(
-    resolve(outDir, "manifest.json"),
-    `${JSON.stringify(artifacts.manifest, null, 2)}
-`,
-    "utf8"
-  );
-  return artifacts;
-}
-function createTileflowDevRequestHandler(options = {}) {
-  const basePath = normalizeTileflowBasePath(options.basePath);
-  const configPath = options.config ?? defaultTileflowConfigPath;
-  const cwd = options.cwd ?? process.cwd();
-  const tileBaseUrl = options.tileBaseUrl ?? defaultTileflowApiUrl;
-  return async function handleTileflowDevRequest(request) {
-    if (request.method !== "GET" && request.method !== "HEAD") {
-      return jsonResponse({ error: "Method not allowed" }, 405);
-    }
-    const url = new URL(request.url);
-    const path = stripTileflowBasePath(url.pathname, basePath);
-    if (path === null) {
-      return jsonResponse({ error: "Not found" }, 404);
-    }
-    try {
-      if (path === "/" || path === "") {
-        const project = await loadValidTileflowConfig(configPath, {
-          cwd,
-          fresh: true
-        });
-        return htmlResponse(
-          previewHtml(getFirstTileflowMapName(project), basePath)
-        );
-      }
-      if (path === "/manifest.json") {
-        const project = await loadValidTileflowConfig(configPath, {
-          cwd,
-          fresh: true
-        });
-        const styleBaseUrl = options.styleBaseUrl ?? `${url.origin}${basePath}`;
-        return jsonResponse(
-          createManifest(project, {
-            styleBaseUrl,
-            tileBaseUrl
-          })
-        );
-      }
-      if (path === "/style.json") {
-        const project = await loadValidTileflowConfig(configPath, {
-          cwd,
-          fresh: true
-        });
-        return jsonResponse(
-          createStyleFromProject(project, getFirstTileflowMapName(project), {
-            tileBaseUrl
-          })
-        );
-      }
-      if (path.startsWith("/styles/")) {
-        const project = await loadValidTileflowConfig(configPath, {
-          cwd,
-          fresh: true
-        });
-        const mapName = getTileflowStyleMapName(path);
-        if (!project.maps[mapName]) {
-          return jsonResponse({ error: `Unknown map: ${mapName}` }, 404);
-        }
-        return jsonResponse(
-          createStyleFromProject(project, mapName, {
-            tileBaseUrl
-          })
-        );
-      }
-      return jsonResponse({ error: "Not found" }, 404);
-    } catch (error) {
-      options.onError?.(error);
-      return tileflowErrorResponse(error);
-    }
-  };
-}
-function normalizeTileflowBasePath(value = "") {
-  const trimmed = value.trim().replace(/^\/+|\/+$/g, "");
-  return trimmed ? `/${trimmed}` : "";
-}
-function stripTileflowBasePath(pathname, basePath) {
-  if (!basePath) {
-    return pathname;
-  }
-  if (pathname === basePath) {
-    return "/";
-  }
-  if (pathname.startsWith(`${basePath}/`)) {
-    return pathname.slice(basePath.length);
-  }
-  return null;
-}
-function tileflowErrorResponse(error) {
-  if (error instanceof TileflowValidationError) {
-    return jsonResponse(
-      {
-        error: error.message,
-        messages: error.messages
-      },
-      400
-    );
-  }
-  const message = error instanceof Error ? error.message : "Unknown error";
-  return jsonResponse({ error: message }, 500);
-}
-function jsonResponse(body, status = 200) {
-  return new Response(`${JSON.stringify(body, null, 2)}
-`, {
-    headers: {
-      "Access-Control-Allow-Origin": "*",
-      "Cache-Control": "no-store",
-      "Content-Type": "application/json; charset=utf-8"
-    },
-    status
-  });
-}
-function htmlResponse(body, status = 200) {
-  return new Response(body, {
-    headers: {
-      "Access-Control-Allow-Origin": "*",
-      "Cache-Control": "no-store",
-      "Content-Type": "text/html; charset=utf-8"
-    },
-    status
-  });
-}
-function previewHtml(mapName, basePath) {
-  const styleUrl = `${basePath}/styles/${mapName}.json`;
-  return `<!doctype html>
-<html lang="en">
-  <head>
-    <meta charset="utf-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1" />
-    <title>Tileflow Preview</title>
-    <link rel="preconnect" href="https://fonts.googleapis.com" />
-    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
-    <link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;600;700&display=swap" rel="stylesheet" />
-    <link rel="stylesheet" href="https://unpkg.com/maplibre-gl@latest/dist/maplibre-gl.css" />
-    <style>
-      html, body, #map { height: 100%; margin: 0; }
-      body { font-family: Inter, ui-sans-serif, system-ui, sans-serif; }
-      .badge {
-        position: fixed;
-        left: 16px;
-        top: 16px;
-        z-index: 1;
-        border-radius: 8px;
-        background: rgba(246, 247, 243, 0.92);
-        border: 1px solid rgba(60, 64, 67, 0.12);
-        color: #3C4043;
-        padding: 10px 12px;
-        box-shadow: 0 10px 40px rgba(0, 0, 0, 0.12);
-      }
-    </style>
-  </head>
-  <body>
-    <div class="badge">Tileflow preview</div>
-    <div id="map"></div>
-    <script type="module">
-      import maplibregl from "https://unpkg.com/maplibre-gl@latest/dist/maplibre-gl.js";
-
-      const map = new maplibregl.Map({
-        container: "map",
-        style: "${styleUrl}",
-        center: [-3.7038, 40.4168],
-        zoom: 12
-      });
-
-      map.addControl(new maplibregl.NavigationControl(), "top-right");
-    </script>
-  </body>
-</html>`;
-}
+  TileflowConfigInspectionError,
+  inspectLoadedTileflowConfig,
+  inspectTileflowConfig,
+  inspectTileflowFeatures,
+  sanitizeTileflowInspectableValue
+} from "./chunk-MKPSQSMX.js";
+import {
+  createTileflowCommandFailureDocument,
+  createTileflowCommandSummary,
+  createTileflowStructuredDiagnostics,
+  serializeTileflowCommandDocument,
+  tileflowCommandDocumentSchemaVersion
+} from "./chunk-LNCTVFUD.js";
+import {
+  TileflowPreviewSelectionError,
+  normalizeTileflowLandmarkManifest,
+  readBoundedTileflowJsonResponse,
+  readBoundedTileflowResponse,
+  renderTileflowPreviewHtml,
+  resolveTileflowPreview
+} from "./chunk-MIGBHCXX.js";
+import {
+  createTileflowArtifactStatus,
+  createTileflowComparisonRequestHandler,
+  createTileflowDevRequestHandler,
+  createTileflowNodeRequest,
+  getTileflowRequestPath,
+  getTileflowStyleInspectionSelection,
+  getTileflowStyleSelection,
+  isTileflowRequestUrl,
+  tileflowComparisonSchemaVersion,
+  writeTileflowNodeResponse
+} from "./chunk-KH7CMHT3.js";
+import {
+  TileflowHostedManifestOverwriteError,
+  TileflowLocalTilesetProductionError,
+  assertNoLocalTilesetsForProduction,
+  assertTileflowSelfHostedManifestTarget,
+  createTileflowArtifactDiagnostics,
+  createTileflowArtifactPlan,
+  createTileflowArtifactSession,
+  createTileflowBuildArtifacts,
+  createTileflowBuildProvenance,
+  createTileflowManifest,
+  createTileflowStyle,
+  createTileflowStyles,
+  disposeTileflowBuildArtifacts,
+  getTileflowArtifactFiles,
+  getTileflowWatchPaths,
+  isTileflowArtifactInputPath,
+  prepareTileflowLocalTilesets,
+  refreshTileflowArtifactSession,
+  tileflowArtifactInventoryFileName,
+  tileflowArtifactPlanSchemaVersion,
+  tileflowArtifactSessionSchemaVersion,
+  writeTileflowArtifactPlan,
+  writeTileflowBuildArtifacts
+} from "./chunk-XTRHREXO.js";
+import {
+  inspectTileflowPmtiles,
+  inspectTileflowPmtilesForLocalUse
+} from "./chunk-ONYQNLNA.js";
+import {
+  TileflowFontCompilationError,
+  bindTileflowStyleFontBundle,
+  getTileflowAssetBasePath,
+  getTileflowAssetFileName,
+  getTileflowFontWatchPaths,
+  joinTileflowPublicUrl,
+  normalizeTileflowBasePath,
+  prepareTileflowStyleFonts,
+  replaceTileflowStyleFontSources,
+  resolveTileflowArtifactPublicUrls
+} from "./chunk-RSBV4L2Y.js";
+import {
+  TileflowIconCompilationError,
+  compileTileflowIconPackages,
+  getTileflowIconWatchPaths,
+  iconFileExtensions,
+  inspectTileflowIconCatalogs,
+  prepareTileflowCatalogIcons
+} from "./chunk-CENQR5Q2.js";
+import "./chunk-BL3FK4GO.js";
+import {
+  TileflowStyleValidationError,
+  assertValidTileflowStyle,
+  sanitizeDiagnosticSecrets,
+  validateTileflowStyle
+} from "./chunk-KDFTE4Q5.js";
+import {
+  TileflowValidationError,
+  assertValidTileflowConfig,
+  defaultTileflowApiUrl,
+  defaultTileflowConfigPath,
+  defaultTileflowManifestPath,
+  getFirstTileflowMapName,
+  getTileflowMapNames,
+  loadTileflowConfig,
+  loadTileflowConfigWithInputs,
+  loadValidTileflowConfig,
+  loadValidTileflowConfigWithInputs
+} from "./chunk-6MGFMKG3.js";
+import "./chunk-D4OE4ITL.js";
 export {
+  TileflowConfigInspectionError,
+  TileflowFontCompilationError,
+  TileflowHostedManifestOverwriteError,
+  TileflowIconCompilationError,
+  TileflowLocalTilesetProductionError,
+  TileflowPreviewSelectionError,
+  TileflowStyleValidationError,
   TileflowValidationError,
-  asTileflowProjectConfig,
+  assertNoLocalTilesetsForProduction,
+  assertTileflowSelfHostedManifestTarget,
   assertValidTileflowConfig,
+  assertValidTileflowStyle,
+  bindTileflowStyleFontBundle,
+  compileTileflowIconPackages,
+  createTileflowArtifactDiagnostics,
+  createTileflowArtifactPlan,
+  createTileflowArtifactSession,
+  createTileflowArtifactStatus,
   createTileflowBuildArtifacts,
+  createTileflowBuildProvenance,
+  createTileflowCommandFailureDocument,
+  createTileflowCommandSummary,
+  createTileflowComparisonRequestHandler,
   createTileflowDevRequestHandler,
   createTileflowManifest,
+  createTileflowNodeRequest,
+  createTileflowStructuredDiagnostics,
   createTileflowStyle,
+  createTileflowStyles,
   defaultTileflowApiUrl,
   defaultTileflowConfigPath,
   defaultTileflowManifestPath,
-  defaultTileflowTileset,
+  disposeTileflowBuildArtifacts,
   getFirstTileflowMapName,
+  getTileflowArtifactFiles,
+  getTileflowAssetBasePath,
+  getTileflowAssetFileName,
+  getTileflowFontWatchPaths,
+  getTileflowIconWatchPaths,
   getTileflowMapNames,
-  getTileflowStyleMapName,
+  getTileflowRequestPath,
+  getTileflowStyleInspectionSelection,
+  getTileflowStyleSelection,
+  getTileflowWatchPaths,
+  iconFileExtensions,
+  inspectLoadedTileflowConfig,
+  inspectTileflowConfig,
+  inspectTileflowFeatures,
+  inspectTileflowIconCatalogs,
+  inspectTileflowPmtiles,
+  inspectTileflowPmtilesForLocalUse,
+  isTileflowArtifactInputPath,
+  isTileflowRequestUrl,
+  joinTileflowPublicUrl,
   loadTileflowConfig,
+  loadTileflowConfigWithInputs,
   loadValidTileflowConfig,
+  loadValidTileflowConfigWithInputs,
   normalizeTileflowBasePath,
-  writeTileflowBuildArtifacts
+  normalizeTileflowLandmarkManifest,
+  prepareTileflowCatalogIcons,
+  prepareTileflowLocalTilesets,
+  prepareTileflowStyleFonts,
+  readBoundedTileflowJsonResponse,
+  readBoundedTileflowResponse,
+  refreshTileflowArtifactSession,
+  renderTileflowPreviewHtml,
+  replaceTileflowStyleFontSources,
+  resolveTileflowArtifactPublicUrls,
+  resolveTileflowPreview,
+  sanitizeDiagnosticSecrets,
+  sanitizeTileflowInspectableValue,
+  serializeTileflowCommandDocument,
+  tileflowArtifactInventoryFileName,
+  tileflowArtifactPlanSchemaVersion,
+  tileflowArtifactSessionSchemaVersion,
+  tileflowCommandDocumentSchemaVersion,
+  tileflowComparisonSchemaVersion,
+  validateTileflowStyle,
+  writeTileflowArtifactPlan,
+  writeTileflowBuildArtifacts,
+  writeTileflowNodeResponse
 };

package/dist/inspect.d.ts

@@ -0,0 +1,149 @@
+import { TileflowThemeAuditDiagnostic, TileflowThemeColorScheme } from '@tileflow/core';
+import { LoadTileflowConfigOptions, LoadedTileflowConfig } from './config.js';
+import { TileflowCommandSummary, TileflowStructuredDiagnostic } from './validation.js';
+import { TileflowPreparedMapAssets, TileflowBuildCatalog } from '@tileflow/core/build';
+
+type TileflowFeatureInspectionOptions = {
+    apiBaseUrl?: string;
+    center: readonly [number, number];
+    fetch?: typeof fetch;
+    height?: number;
+    limit?: number;
+    properties?: readonly string[];
+    /** Build-owned assets required to compile the selected map exactly. */
+    preparedAssets?: TileflowPreparedMapAssets;
+    signal?: AbortSignal;
+    sourceLayers: readonly string[];
+    timeoutMs?: number;
+    width?: number;
+    zoom: number;
+};
+type TileflowInspectedProperty = boolean | number | string;
+type TileflowInspectedFeature = {
+    sourceLayer: string;
+    id: number | null;
+    geometry: {
+        type: string;
+        center: [number, number];
+        bounds: [number, number, number, number];
+    };
+    properties: Record<string, TileflowInspectedProperty>;
+};
+type TileflowFeatureInspection = {
+    schemaVersion: 1;
+    map: string;
+    camera: {
+        center: [number, number];
+        zoom: number;
+        viewport: {
+            width: number;
+            height: number;
+        };
+    };
+    source: {
+        id: string;
+        origin: string;
+        tileJsonPath: string | null;
+        tileOrigins: string[];
+        version: string | null;
+    };
+    sourceLayers: string[];
+    properties: string[];
+    tileZoom: number;
+    tilesRead: number;
+    scannedFeatures: number;
+    truncated: boolean;
+    features: TileflowInspectedFeature[];
+};
+declare function inspectTileflowFeatures(project: TileflowBuildCatalog, mapName: string, input: TileflowFeatureInspectionOptions): Promise<TileflowFeatureInspection>;
+
+type TileflowConfigInspectionOptions = LoadTileflowConfigOptions & {
+    config?: string;
+    map?: string;
+};
+type TileflowMapLineageInspection = {
+    depth: number;
+    declaredPaths: string[];
+    id: string;
+    version: number;
+};
+type TileflowMapMergeProvenance = {
+    declared: boolean;
+    inherited: boolean;
+    operation: 'defined' | 'overridden';
+    path: string;
+    /** Stable root-to-leaf lineage depth; disambiguates repeated map ids. */
+    sourceDepth: number;
+    sourceMap: string;
+};
+type TileflowResolvedMapInspection = {
+    id: string;
+    lineage: TileflowMapLineageInspection[];
+    provenance: TileflowMapMergeProvenance[];
+    resolved: Record<string, unknown>;
+    themeContract: TileflowThemeContractInspection;
+};
+type TileflowThemeDifferenceInspection = {
+    from: unknown;
+    path: string;
+    to: unknown;
+};
+type TileflowThemeInspection = {
+    colorScheme: TileflowThemeColorScheme;
+    differencesFromDefault: TileflowThemeDifferenceInspection[];
+    id: string;
+    isDefault: boolean;
+    lighting: Record<string, unknown>;
+    name: string;
+    systemFor: TileflowThemeColorScheme[];
+    tokens: {
+        color: Record<string, string>;
+        font: Record<string, string>;
+        image: Record<string, string>;
+        number: Record<string, number>;
+    };
+    typography: Record<string, unknown>;
+    version: number;
+};
+type TileflowThemeContractInspection = {
+    audit: TileflowThemeAuditDiagnostic[];
+    defaultTheme: string;
+    systemThemes?: {
+        dark: string;
+        light: string;
+    };
+    themes: Record<string, TileflowThemeInspection>;
+    tokenSchema: {
+        color: string[];
+        font: string[];
+        image: string[];
+        number: string[];
+    };
+};
+type TileflowConfigInspection = TileflowCommandSummary & {
+    command: 'inspect';
+    ok: true;
+    maps: TileflowResolvedMapInspection[];
+    diagnostics: TileflowStructuredDiagnostic[];
+};
+/** Resolve a config once and expose only deterministic, secret-free authoring information. */
+declare function inspectTileflowConfig(options?: TileflowConfigInspectionOptions): Promise<TileflowConfigInspection>;
+declare function inspectLoadedTileflowConfig(loaded: LoadedTileflowConfig, options: {
+    cwd: string;
+    map?: string;
+}): TileflowConfigInspection;
+declare class TileflowConfigInspectionError extends Error {
+    readonly code: string;
+    readonly phase: "config-inspection";
+    readonly issues: Array<{
+        code: string;
+        message: string;
+        path: string;
+        phase: string;
+    }>;
+    constructor(code: string, message: string, path: string);
+}
+/** Sanitize a deterministic JSON-like authoring value for machine-facing CLI output. */
+declare function sanitizeTileflowInspectableValue(value: unknown, cwd: string): unknown;
+
+export { type TileflowConfigInspection, TileflowConfigInspectionError, type TileflowConfigInspectionOptions, type TileflowFeatureInspection, type TileflowFeatureInspectionOptions, type TileflowInspectedFeature, type TileflowInspectedProperty, type TileflowMapLineageInspection, type TileflowMapMergeProvenance, type TileflowResolvedMapInspection, type TileflowThemeContractInspection, type TileflowThemeDifferenceInspection, type TileflowThemeInspection, inspectLoadedTileflowConfig, inspectTileflowConfig, inspectTileflowFeatures, sanitizeTileflowInspectableValue };

package/dist/inspect.js

@@ -0,0 +1,18 @@
+import {
+  TileflowConfigInspectionError,
+  inspectLoadedTileflowConfig,
+  inspectTileflowConfig,
+  inspectTileflowFeatures,
+  sanitizeTileflowInspectableValue
+} from "./chunk-MKPSQSMX.js";
+import "./chunk-LNCTVFUD.js";
+import "./chunk-KDFTE4Q5.js";
+import "./chunk-6MGFMKG3.js";
+import "./chunk-D4OE4ITL.js";
+export {
+  TileflowConfigInspectionError,
+  inspectLoadedTileflowConfig,
+  inspectTileflowConfig,
+  inspectTileflowFeatures,
+  sanitizeTileflowInspectableValue
+};