@tileflow/dev 0.1.0-alpha.3 → 0.1.0-alpha.31

package/dist/chunk-KDFTE4Q5.js

@@ -0,0 +1,156 @@
+// src/diagnostic-sanitization.ts
+function sanitizeDiagnosticSecrets(value) {
+  return value.replace(/([a-z][a-z0-9+.-]*:\/\/)[^\s/@:]+:[^\s/@]+@/gi, "$1[redacted]@").replace(/\bBearer\s+[^\s,;]+/gi, "Bearer [redacted]").replace(/\btf_(?:live|cli|test)_[A-Za-z0-9_-]{8,}\b/gi, "tf_[redacted]").replace(/\b(?:sk_(?:live|test)|rk_(?:live|test)|whsec)_[A-Za-z0-9_-]+\b/g, "[redacted]").replace(
+    /([?&](?:access_token|api_key|key|password|secret|signature|token)=)[^&#\s]+/gi,
+    "$1[redacted]"
+  );
+}
+
+// src/style-validation.ts
+import { validateStyleMin } from "@maplibre/maplibre-gl-style-spec";
+var TileflowStyleValidationError = class extends Error {
+  code = "STYLE_INVALID";
+  issues;
+  phase = "style-validation";
+  constructor(issues) {
+    super("Compiled Tileflow styles are not valid MapLibre styles.");
+    this.name = "TileflowStyleValidationError";
+    this.issues = normalizeIssues(issues);
+  }
+};
+var maxIssues = 32;
+var maxMessageLength = 300;
+var maxPathLength = 300;
+function assertValidTileflowStyle(style, map) {
+  const issues = validateTileflowStyle(style, map);
+  if (issues.length > 0) throw new TileflowStyleValidationError(issues);
+}
+function validateTileflowStyle(style, map) {
+  const jsonIssues = [];
+  collectJsonIssues(
+    style,
+    `maps.${sanitizePathSegment(map)}.style`,
+    map,
+    jsonIssues,
+    /* @__PURE__ */ new Set()
+  );
+  if (jsonIssues.length > 0) return normalizeIssues(jsonIssues);
+  const semanticIssues = validateStyleMin(style).map(
+    (issue) => createSemanticIssue(style, map, issue.message)
+  );
+  return normalizeIssues(semanticIssues);
+}
+function normalizeTileflowStyleValidationIssues(issues) {
+  return normalizeIssues(issues);
+}
+function createSemanticIssue(style, map, rawMessage) {
+  const normalized = rawMessage.replace(/[\r\n]+/g, " ").trim();
+  const separator = normalized.indexOf(":");
+  const rawPath = separator >= 0 ? normalized.slice(0, separator).trim() : "";
+  const detail = separator >= 0 ? normalized.slice(separator + 1).trim() : normalized;
+  return {
+    map,
+    message: boundText(sanitizeDiagnosticSecrets(sanitizeUrls(detail)), maxMessageLength),
+    path: boundText(stableStylePath(style, map, rawPath), maxPathLength)
+  };
+}
+function stableStylePath(style, map, rawPath) {
+  const fallback = `maps.${sanitizePathSegment(map)}.style`;
+  if (!rawPath) return fallback;
+  const path = rawPath.replace(/layers\[(\d+)]/g, (_match, index) => {
+    const layer = style.layers[Number(index)];
+    const id = typeof layer?.id === "string" && layer.id ? layer.id : index;
+    return `layers.${sanitizePathSegment(id)}`;
+  });
+  return `${fallback}.${path}`;
+}
+function sanitizePathSegment(value) {
+  let sanitized = "";
+  let replacing = false;
+  for (const character of value) {
+    const codePoint = character.codePointAt(0) ?? 0;
+    const isAsciiLetter = codePoint >= 65 && codePoint <= 90 || codePoint >= 97 && codePoint <= 122;
+    const isDigit = codePoint >= 48 && codePoint <= 57;
+    const shouldReplace = !isAsciiLetter && !isDigit && character !== "-" && character !== "_";
+    if (shouldReplace) {
+      if (!replacing) sanitized += "-";
+      replacing = true;
+    } else {
+      sanitized += character;
+      replacing = false;
+    }
+  }
+  return sanitized.slice(0, 128) || "(unknown)";
+}
+function collectJsonIssues(value, path, map, issues, ancestors) {
+  if (issues.length >= maxIssues) return;
+  if (value === null || typeof value === "string" || typeof value === "boolean") return;
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) addJsonIssue(map, path, "non-finite number", issues);
+    return;
+  }
+  if (typeof value !== "object") {
+    addJsonIssue(map, path, typeof value, issues);
+    return;
+  }
+  if (ancestors.has(value)) {
+    addJsonIssue(map, path, "cyclic object", issues);
+    return;
+  }
+  ancestors.add(value);
+  if (Array.isArray(value)) {
+    value.forEach((item, index) => {
+      const layerId = path.endsWith(".layers") && item && typeof item === "object" && !Array.isArray(item) ? item.id : void 0;
+      const childPath = typeof layerId === "string" && layerId ? `${path}.${sanitizePathSegment(layerId)}` : `${path}[${index}]`;
+      collectJsonIssues(item, childPath, map, issues, ancestors);
+    });
+  } else {
+    for (const [key, item] of Object.entries(value)) {
+      collectJsonIssues(item, `${path}.${sanitizePathSegment(key)}`, map, issues, ancestors);
+    }
+  }
+  ancestors.delete(value);
+}
+function addJsonIssue(map, path, type, issues) {
+  issues.push({
+    map,
+    message: `Expected a recursive JSON value; found ${type}.`,
+    path: boundText(path, maxPathLength)
+  });
+}
+function normalizeIssues(issues) {
+  const normalized = issues.map((issue) => ({
+    map: boundText(sanitizePathSegment(issue.map), 128),
+    message: boundText(
+      sanitizeDiagnosticSecrets(issue.message.replace(/[\r\n]+/g, " ").trim()),
+      maxMessageLength
+    ),
+    path: boundText(issue.path.replaceAll("\\", "/"), maxPathLength)
+  }));
+  normalized.sort(
+    (left, right) => left.path < right.path ? -1 : left.path > right.path ? 1 : left.message < right.message ? -1 : left.message > right.message ? 1 : 0
+  );
+  return normalized.filter(
+    (issue, index) => index === 0 || issue.path !== normalized[index - 1]?.path || issue.message !== normalized[index - 1]?.message
+  ).slice(0, maxIssues);
+}
+function sanitizeUrls(message) {
+  return message.replace(/https?:\/\/[^\s'"<>]+/gi, (value) => {
+    try {
+      return new URL(value.replace(/[),.;]+$/, "")).origin;
+    } catch {
+      return "(resource URL)";
+    }
+  });
+}
+function boundText(value, limit) {
+  return value.length <= limit ? value : `${value.slice(0, limit - 1)}\u2026`;
+}
+
+export {
+  sanitizeDiagnosticSecrets,
+  TileflowStyleValidationError,
+  assertValidTileflowStyle,
+  validateTileflowStyle,
+  normalizeTileflowStyleValidationIssues
+};