@tileflow/dev 0.1.0-alpha.17 → 0.1.0-alpha.19

package/dist/chunk-ZRI6PNFL.js

@@ -0,0 +1,211 @@
+import {
+  sanitizeDiagnosticSecrets
+} from "./chunk-KDFTE4Q5.js";
+
+// src/validation.ts
+import { realpathSync } from "fs";
+import { isAbsolute, relative, resolve, sep, win32 } from "path";
+import { compareCodeUnits } from "@tileflow/core";
+var tileflowCommandDocumentSchemaVersion = 1;
+function createTileflowCommandSummary(input) {
+  return {
+    schemaVersion: tileflowCommandDocumentSchemaVersion,
+    command: normalizeCommandField(input.command, "command"),
+    ok: input.ok,
+    phase: normalizePhase(input.phase, "command"),
+    code: normalizeCode(input.code, input.ok ? "COMMAND_OK" : "COMMAND_FAILED"),
+    path: boundText(input.path ?? "", 300),
+    severity: input.severity,
+    message: boundText(input.message.replace(/[\r\n]+/gu, " ").trim(), 300),
+    suggestion: boundText(input.suggestion.replace(/[\r\n]+/gu, " ").trim(), 300)
+  };
+}
+function createTileflowStructuredDiagnostics(error, cwd, defaults) {
+  const inheritedCode = optionalField(error, "code");
+  const inheritedPhase = optionalField(error, "phase") ?? optionalNestedField(error, "phase");
+  const issues = getIssues(error);
+  const candidates = issues.length ? issues : [
+    {
+      message: error instanceof Error ? error.message : "The Tileflow command failed.",
+      path: ""
+    }
+  ];
+  const diagnostics = candidates.map((issue) => {
+    const phase = normalizePhase(issue.phase ?? inheritedPhase, defaults.phase);
+    const code = normalizeCode(issue.code ?? inheritedCode, defaults.code);
+    const severity = normalizeSeverity(issue.severity ?? issue.level, defaults.severity ?? "error");
+    return {
+      phase,
+      code,
+      path: boundText(sanitizePath(issue.path ?? "", cwd), 300),
+      severity,
+      message: boundText(sanitizeMessage(issue.message, cwd), 300),
+      suggestion: issue.suggestion ? boundText(sanitizeMessage(issue.suggestion, cwd), 300) : suggestionForDiagnostic(code, phase)
+    };
+  });
+  diagnostics.sort(compareDiagnostics);
+  return diagnostics.filter(
+    (diagnostic, index) => index === 0 || JSON.stringify(diagnostic) !== JSON.stringify(diagnostics[index - 1])
+  ).slice(0, 32);
+}
+function createTileflowCommandFailureDocument(command, error, cwd, defaults) {
+  const diagnostics = createTileflowStructuredDiagnostics(error, cwd, defaults);
+  const primary = diagnostics[0] ?? {
+    phase: normalizePhase(defaults.phase, "command"),
+    code: normalizeCode(defaults.code, "COMMAND_FAILED"),
+    path: "",
+    severity: defaults.severity ?? "error",
+    message: "The Tileflow command failed.",
+    suggestion: "Review the command input and run it again."
+  };
+  return {
+    schemaVersion: tileflowCommandDocumentSchemaVersion,
+    command: normalizeCommandField(command, "command"),
+    ok: false,
+    phase: primary.phase,
+    code: primary.code,
+    path: primary.path,
+    severity: primary.severity,
+    message: primary.message,
+    suggestion: primary.suggestion,
+    diagnostics
+  };
+}
+function serializeTileflowCommandDocument(value) {
+  return `${JSON.stringify(value, null, 2)}
+`;
+}
+function getIssues(error) {
+  if (!error || typeof error !== "object") return [];
+  const containers = [];
+  for (const key of ["diagnostics", "messages", "issues"]) {
+    const value = error[key];
+    if (Array.isArray(value)) containers.push(value);
+  }
+  const details = error.details;
+  if (details && typeof details === "object") {
+    const diagnostics = details.diagnostics;
+    if (Array.isArray(diagnostics)) containers.push(diagnostics);
+  }
+  return containers.flatMap(
+    (container) => container.flatMap((entry) => {
+      if (!entry || typeof entry !== "object") return [];
+      const candidate = entry;
+      if (typeof candidate.message !== "string") return [];
+      return [
+        {
+          ...typeof candidate.code === "string" ? { code: candidate.code } : {},
+          ...typeof candidate.level === "string" ? { level: candidate.level } : {},
+          message: candidate.message,
+          ...typeof candidate.path === "string" ? { path: candidate.path } : {},
+          ...typeof candidate.phase === "string" ? { phase: candidate.phase } : {},
+          ...typeof candidate.severity === "string" ? { severity: candidate.severity } : {},
+          ...typeof candidate.suggestion === "string" ? { suggestion: candidate.suggestion } : {}
+        }
+      ];
+    })
+  );
+}
+function sanitizeMessage(value, cwd) {
+  let sanitized = value;
+  for (const root of localPathAliases(cwd)) sanitized = sanitized.replaceAll(root, ".");
+  sanitized = sanitized.replace(/[\r\n]+/gu, " ").trim();
+  sanitized = sanitized.replace(/https?:\/\/[^\s'")<>]+/giu, (url) => {
+    try {
+      return new URL(url.replace(/[),.;]+$/u, "")).origin;
+    } catch {
+      return "(resource URL)";
+    }
+  });
+  sanitized = sanitized.replace(/(^|[\s'"(])[A-Za-z]:[\\/][^\s'")]+/gu, "$1(external path)");
+  sanitized = sanitized.replace(/(^|[\s'"(])(?:\\\\|\/\/)[^\s'")]+/gu, "$1(external path)");
+  sanitized = sanitized.replace(/(^|[\s'"(])\/[^\s'")]+/gu, "$1(external path)");
+  return sanitizeDiagnosticSecrets(sanitized);
+}
+function sanitizePath(value, cwd) {
+  if (!value) return "";
+  if (win32.isAbsolute(value) && !isAbsolute(value)) return "(external)";
+  if (!isAbsolute(value)) return sanitizeDiagnosticSecrets(value.replaceAll("\\", "/"));
+  const local = relative(canonicalPath(cwd), canonicalPath(value)).replaceAll(sep, "/");
+  return local.startsWith("../") || local === ".." ? "(external)" : local || ".";
+}
+function localPathAliases(path) {
+  return [.../* @__PURE__ */ new Set([resolve(path), canonicalPath(path)])].sort(
+    (left, right) => right.length - left.length
+  );
+}
+function canonicalPath(path) {
+  try {
+    return realpathSync.native(resolve(path));
+  } catch {
+    return resolve(path);
+  }
+}
+function suggestionForDiagnostic(code, phase) {
+  if (code === "INVALID_TARGET" || phase === "command-validation") {
+    return "Use a documented command option and run the command again.";
+  }
+  if (phase === "config-load") {
+    return "Check the config path and its installed imports, then run the command again.";
+  }
+  if (phase === "config-validation" || code === "CONFIG_INVALID") {
+    return "Edit the reported config path to match the Tileflow config reference, then validate again.";
+  }
+  if (phase.includes("icon") || code.includes("ICON")) {
+    return "Fix the reported icon input and run validation again.";
+  }
+  if (phase.includes("font") || code.includes("FONT") || code.includes("GLYPH")) {
+    return "Fix the reported font or glyph input and run validation again.";
+  }
+  if (phase === "style-validation" || code === "STYLE_INVALID") {
+    return "Adjust the reported semantic map value and run validation again.";
+  }
+  if (phase === "hosted-validation" || code === "HOSTED_INCOMPATIBLE") {
+    return "Use a supported Hosted input or validate with the local target.";
+  }
+  if (phase === "config-inspection") {
+    return "Resolve the reported config diagnostic before inspecting the map again.";
+  }
+  return "Review the reported path and run the command again.";
+}
+function compareDiagnostics(left, right) {
+  return diagnosticSeverityRank(left.severity) - diagnosticSeverityRank(right.severity) || compareCodeUnits(left.path, right.path) || compareCodeUnits(left.phase, right.phase) || compareCodeUnits(left.code, right.code) || compareCodeUnits(left.message, right.message) || compareCodeUnits(left.suggestion, right.suggestion);
+}
+function diagnosticSeverityRank(severity) {
+  return severity === "error" ? 0 : severity === "warning" ? 1 : 2;
+}
+function normalizeSeverity(value, fallback) {
+  return value === "error" || value === "info" || value === "warning" ? value : fallback;
+}
+function normalizeCode(value, fallback) {
+  const normalized = sanitizeDiagnosticSecrets(value ?? fallback).toUpperCase().replace(/[^A-Z0-9_]/gu, "_").slice(0, 64);
+  return normalized || fallback;
+}
+function normalizePhase(value, fallback) {
+  const normalized = sanitizeDiagnosticSecrets(value ?? fallback).toLowerCase().replace(/[^a-z0-9-]/gu, "-").slice(0, 64);
+  return normalized || fallback;
+}
+function normalizeCommandField(value, fallback) {
+  const normalized = sanitizeDiagnosticSecrets(value).toLowerCase().replace(/[^a-z0-9 ._-]/gu, "").trim().slice(0, 64);
+  return normalized || fallback;
+}
+function optionalField(value, key) {
+  if (!value || typeof value !== "object") return void 0;
+  const field = value[key];
+  return typeof field === "string" && field.trim() ? field : void 0;
+}
+function optionalNestedField(value, key) {
+  if (!value || typeof value !== "object") return void 0;
+  return optionalField(value.details, key);
+}
+function boundText(value, limit) {
+  return value.length <= limit ? value : `${value.slice(0, limit - 1)}\u2026`;
+}
+
+export {
+  tileflowCommandDocumentSchemaVersion,
+  createTileflowCommandSummary,
+  createTileflowStructuredDiagnostics,
+  createTileflowCommandFailureDocument,
+  serializeTileflowCommandDocument
+};

package/dist/config.d.ts

@@ -0,0 +1,33 @@
+import { TileflowMap, ValidationMessage } from '@tileflow/core';
+import { TileflowBuildCatalog } from '@tileflow/core/build';
+
+declare const defaultTileflowApiUrl = "https://api.tileflow.dev";
+declare const defaultTileflowConfigPath = "tileflow.config.ts";
+declare const defaultTileflowManifestPath = "public/tileflow/manifest.json";
+type LoadTileflowConfigOptions = {
+    cwd?: string;
+    fresh?: boolean;
+};
+type LoadedTileflowConfig = {
+    /** Tooling-only authoring definitions retained for resolved-config provenance. Never serialize. */
+    authoringMaps: Record<string, TileflowMap>;
+    /** Absolute executable config path. Asset directories resolve from its parent directory. */
+    configFile: string;
+    inputFiles: string[];
+    project: TileflowBuildCatalog;
+};
+declare class TileflowValidationError extends Error {
+    readonly code: "CONFIG_INVALID";
+    readonly messages: ValidationMessage[];
+    readonly phase: "config-validation";
+    constructor(messages: ValidationMessage[]);
+}
+declare function loadTileflowConfig(configPath?: string, options?: LoadTileflowConfigOptions): Promise<TileflowBuildCatalog>;
+declare function loadTileflowConfigWithInputs(configPath?: string, options?: LoadTileflowConfigOptions): Promise<LoadedTileflowConfig>;
+declare function loadValidTileflowConfig(configPath?: string, options?: LoadTileflowConfigOptions): Promise<TileflowBuildCatalog>;
+declare function loadValidTileflowConfigWithInputs(configPath?: string, options?: LoadTileflowConfigOptions): Promise<LoadedTileflowConfig>;
+declare function assertValidTileflowConfig(project: TileflowBuildCatalog): void;
+declare function getTileflowMapNames(project: TileflowBuildCatalog): string[];
+declare function getFirstTileflowMapName(project: TileflowBuildCatalog): string;
+
+export { type LoadTileflowConfigOptions, type LoadedTileflowConfig, TileflowValidationError, assertValidTileflowConfig, defaultTileflowApiUrl, defaultTileflowConfigPath, defaultTileflowManifestPath, getFirstTileflowMapName, getTileflowMapNames, loadTileflowConfig, loadTileflowConfigWithInputs, loadValidTileflowConfig, loadValidTileflowConfigWithInputs };

package/dist/config.js

@@ -0,0 +1,27 @@
+import {
+  TileflowValidationError,
+  assertValidTileflowConfig,
+  defaultTileflowApiUrl,
+  defaultTileflowConfigPath,
+  defaultTileflowManifestPath,
+  getFirstTileflowMapName,
+  getTileflowMapNames,
+  loadTileflowConfig,
+  loadTileflowConfigWithInputs,
+  loadValidTileflowConfig,
+  loadValidTileflowConfigWithInputs
+} from "./chunk-BKHIZ7H2.js";
+import "./chunk-D4OE4ITL.js";
+export {
+  TileflowValidationError,
+  assertValidTileflowConfig,
+  defaultTileflowApiUrl,
+  defaultTileflowConfigPath,
+  defaultTileflowManifestPath,
+  getFirstTileflowMapName,
+  getTileflowMapNames,
+  loadTileflowConfig,
+  loadTileflowConfigWithInputs,
+  loadValidTileflowConfig,
+  loadValidTileflowConfigWithInputs
+};

package/dist/fonts.d.ts

@@ -0,0 +1,47 @@
+import { TileflowFontBundleManifest, MapLibreStyle } from '@tileflow/core';
+import { TileflowEffectiveFontSourceIdentity, TileflowBuildStyles, TileflowBuildCatalog } from '@tileflow/core/build';
+import { TileflowBuildAsset } from './icons.js';
+
+type TileflowFontCompilationTarget = 'hosted' | 'local';
+type TileflowFontCompilationIssue = {
+    message: string;
+    path: string;
+};
+declare class TileflowFontCompilationError extends Error {
+    readonly code: "FONT_INVALID";
+    readonly issues: readonly TileflowFontCompilationIssue[];
+    readonly phase: "font-compilation";
+    constructor(issues: readonly TileflowFontCompilationIssue[]);
+}
+type PreparedTileflowStyleFonts = {
+    assets: TileflowBuildAsset[];
+    bundles: Record<string, CompiledTileflowFontBundle>;
+    sourceIdentities: Record<string, TileflowEffectiveFontSourceIdentity[]>;
+    styles: TileflowBuildStyles;
+    watchPaths: string[];
+};
+type CompiledTileflowFontBundle = {
+    contentHash: string;
+    files: TileflowBuildAsset[];
+    manifest: TileflowFontBundleManifest;
+};
+type PrepareTileflowStyleFontsOptions = {
+    assetBaseUrl: string;
+    baseDirectory?: string;
+    cwd: string;
+    target: TileflowFontCompilationTarget;
+};
+/** Resolve only mutable local font directories so failed builds can still be watched. */
+declare function getTileflowFontWatchPaths(project: TileflowBuildCatalog, cwd: string, baseDirectory?: string): Promise<string[]>;
+/**
+ * Prepare every map's ordered local font provider.
+ *
+ * OpenType full names are the canonical IDs consumed by `text-font`. Directories are applied from
+ * left to right, so a later directory replaces an earlier face only when that exact ID matches.
+ */
+declare function prepareTileflowStyleFonts(project: TileflowBuildCatalog, inputStyles: Readonly<Record<string, Readonly<Record<string, MapLibreStyle>>>>, options: PrepareTileflowStyleFontsOptions): Promise<PreparedTileflowStyleFonts>;
+/** Replace provisional local/preflight URLs with one exact Hosted bundle base URL. */
+declare function bindTileflowStyleFontBundle(style: MapLibreStyle, bundle: CompiledTileflowFontBundle, publicBaseUrl: string): MapLibreStyle;
+declare function replaceTileflowStyleFontSources(style: MapLibreStyle, replace: (source: string) => string): MapLibreStyle;
+
+export { type CompiledTileflowFontBundle, type PrepareTileflowStyleFontsOptions, type PreparedTileflowStyleFonts, TileflowFontCompilationError, type TileflowFontCompilationIssue, type TileflowFontCompilationTarget, bindTileflowStyleFontBundle, getTileflowFontWatchPaths, prepareTileflowStyleFonts, replaceTileflowStyleFontSources };

package/dist/fonts.js

@@ -0,0 +1,16 @@
+import {
+  TileflowFontCompilationError,
+  bindTileflowStyleFontBundle,
+  getTileflowFontWatchPaths,
+  prepareTileflowStyleFonts,
+  replaceTileflowStyleFontSources
+} from "./chunk-VEB43KDS.js";
+import "./chunk-BL3FK4GO.js";
+import "./chunk-D4OE4ITL.js";
+export {
+  TileflowFontCompilationError,
+  bindTileflowStyleFontBundle,
+  getTileflowFontWatchPaths,
+  prepareTileflowStyleFonts,
+  replaceTileflowStyleFontSources
+};

package/dist/icons.d.ts

@@ -0,0 +1,136 @@
+import { TileflowIconPackageFileName, TileflowIconPackageManifest } from '@tileflow/core';
+import { TileflowBuildCatalog, TileflowPreparedMapAssets, TileflowEffectiveIconSourceIdentity } from '@tileflow/core/build';
+
+type TileflowBuildAsset = {
+    contentType: string;
+    fileName: string;
+    source: string | Uint8Array;
+};
+/** Executable authoring input before local sources have been resolved into runtime URLs. */
+type TileflowSourceCatalog = TileflowBuildCatalog;
+declare const preparedTileflowBuildCatalog: unique symbol;
+/** A validated catalog paired with build-owned portable assets. */
+type PreparedTileflowBuildCatalog = TileflowBuildCatalog & {
+    readonly [preparedTileflowBuildCatalog]: true;
+};
+type PreparedTileflowCatalog = {
+    assets: TileflowBuildAsset[];
+    baseDirectory: string;
+    cwd: string;
+    mapAssets: Record<string, TileflowPreparedMapAssets>;
+    mapIconSources: Record<string, readonly TileflowEffectiveIconSourceIdentity[]>;
+    project: PreparedTileflowBuildCatalog;
+    sourceProject: TileflowSourceCatalog;
+    watchPaths: string[];
+};
+type TileflowIconCompilationTarget = 'hosted' | 'local';
+type TileflowIconCompilationIssue = {
+    message: string;
+    path: string;
+};
+type CompiledTileflowIconPackageFile = {
+    contentType: 'application/json' | 'image/png';
+    fileName: TileflowIconPackageFileName;
+    source: Uint8Array;
+};
+type CompiledTileflowIconPackage = {
+    contentHash: string;
+    files: CompiledTileflowIconPackageFile[];
+    manifest: TileflowIconPackageManifest;
+};
+type TileflowMapIconPackageBinding = {
+    iconIds: readonly string[];
+    label: string;
+    mapName: string;
+    packageHash: string;
+};
+type CompileTileflowIconPackagesResult = {
+    bindings: TileflowMapIconPackageBinding[];
+    packages: CompiledTileflowIconPackage[];
+    sourceIdentities: Record<string, readonly TileflowEffectiveIconSourceIdentity[]>;
+    watchPaths: string[];
+};
+type InspectTileflowIconCatalogsOptions = {
+    baseDirectory?: string;
+    cwd: string;
+    mapNames?: readonly string[];
+};
+type TileflowIconCatalogSourceFormat = 'jpeg' | 'png' | 'svg' | 'webp';
+type TileflowIconCatalogAtlasRectangle = {
+    height: number;
+    width: number;
+    x: number;
+    y: number;
+};
+type TileflowIconCatalogRenderedDensity = {
+    atlas: TileflowIconCatalogAtlasRectangle;
+    height: number;
+    pixelRatio: 1 | 2;
+    pixelSha256: string;
+    width: number;
+};
+type TileflowIconCatalogIcon = {
+    id: string;
+    rendered: {
+        oneX: TileflowIconCatalogRenderedDensity;
+        twoX: TileflowIconCatalogRenderedDensity;
+    };
+    source: {
+        byteLength: number;
+        dimensions: {
+            height: number;
+            width: number;
+        } | null;
+        format: TileflowIconCatalogSourceFormat;
+        path: string;
+    };
+};
+type TileflowIconCatalog = {
+    compiledPackage: CompiledTileflowIconPackage;
+    directories: string[];
+    icons: TileflowIconCatalogIcon[];
+    insideWorkingTree: boolean;
+    replacements: TileflowIconReplacement[];
+};
+type TileflowIconReplacement = {
+    id: string;
+    replaced: string;
+    winner: string;
+};
+type TileflowIconCatalogMap = {
+    name: string;
+    icons: {
+        directories: string[];
+        iconIds: string[];
+        kind: 'directories';
+        label: string;
+        packageHash: string;
+    } | {
+        kind: 'none';
+    };
+};
+type TileflowIconCatalogInspection = {
+    catalogs: TileflowIconCatalog[];
+    maps: TileflowIconCatalogMap[];
+};
+declare class TileflowIconCompilationError extends Error {
+    readonly code: "ICON_INVALID";
+    readonly issues: TileflowIconCompilationIssue[];
+    readonly phase: "icon-compilation";
+    constructor(issues: TileflowIconCompilationIssue[]);
+}
+declare const iconFileExtensions: Set<string>;
+declare function compileTileflowIconPackages(project: TileflowBuildCatalog, options: {
+    baseDirectory?: string;
+    cwd: string;
+    target: TileflowIconCompilationTarget;
+}): Promise<CompileTileflowIconPackagesResult>;
+declare function inspectTileflowIconCatalogs(project: TileflowBuildCatalog, options: InspectTileflowIconCatalogsOptions): Promise<TileflowIconCatalogInspection>;
+declare function prepareTileflowCatalogIcons(project: TileflowBuildCatalog, options: {
+    assetBaseUrl: string;
+    baseDirectory?: string;
+    cwd: string;
+}): Promise<PreparedTileflowCatalog>;
+declare function getTileflowIconWatchPaths(project: TileflowBuildCatalog, cwd: string, baseDirectory?: string): Promise<string[]>;
+
+export { type CompileTileflowIconPackagesResult, type CompiledTileflowIconPackage, type CompiledTileflowIconPackageFile, type InspectTileflowIconCatalogsOptions, type PreparedTileflowBuildCatalog, type PreparedTileflowCatalog, type TileflowBuildAsset, type TileflowIconCatalog, type TileflowIconCatalogAtlasRectangle, type TileflowIconCatalogIcon, type TileflowIconCatalogInspection, type TileflowIconCatalogMap, type TileflowIconCatalogRenderedDensity, type TileflowIconCatalogSourceFormat, TileflowIconCompilationError, type TileflowIconCompilationIssue, type TileflowIconCompilationTarget, type TileflowIconReplacement, type TileflowMapIconPackageBinding, type TileflowSourceCatalog, compileTileflowIconPackages, getTileflowIconWatchPaths, iconFileExtensions, inspectTileflowIconCatalogs, prepareTileflowCatalogIcons };

package/dist/icons.js

@@ -0,0 +1,17 @@
+import {
+  TileflowIconCompilationError,
+  compileTileflowIconPackages,
+  getTileflowIconWatchPaths,
+  iconFileExtensions,
+  inspectTileflowIconCatalogs,
+  prepareTileflowCatalogIcons
+} from "./chunk-BALG4DSG.js";
+import "./chunk-BL3FK4GO.js";
+export {
+  TileflowIconCompilationError,
+  compileTileflowIconPackages,
+  getTileflowIconWatchPaths,
+  iconFileExtensions,
+  inspectTileflowIconCatalogs,
+  prepareTileflowCatalogIcons
+};