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

package/dist/manifest.d.ts

@@ -0,0 +1,3 @@
+import 'zod';
+export { d as TileflowRuntimeColorScheme, e as TileflowRuntimeManifest, n as TileflowRuntimeManifestMapEntry, o as TileflowRuntimeManifestTheme, s as TileflowRuntimeSystemThemes, K as parseTileflowRuntimeManifest, S as safeParseTileflowRuntimeManifest, W as tileflowRuntimeManifestLimits, X as tileflowRuntimeManifestSchema, Y as tileflowRuntimeManifestVersion } from './runtime-C4MtSzkB.js';
+import './types-DlUGI6LC.js';

package/dist/manifest.js

@@ -0,0 +1,229 @@
+// src/manifest.ts
+import { z as z2 } from "zod";
+
+// src/portable-identity.ts
+import { z } from "zod";
+
+// src/portable-identity-rules.ts
+var tileflowPortableIdMaximumLength = 64;
+var tileflowPortableIdPattern = /^[a-z][a-z0-9-]{0,63}$/u;
+function isTileflowPortableId(value) {
+  return typeof value === "string" && value.length <= tileflowPortableIdMaximumLength && tileflowPortableIdPattern.test(value) && !["constructor", "prototype"].includes(value) && !/^(?:AUX|CON|NUL|PRN|COM[1-9]|LPT[1-9])$/i.test(value);
+}
+function isTileflowThemeName(value) {
+  return isTileflowPortableId(value) && value !== "system";
+}
+
+// src/portable-identity.ts
+var tileflowPortableIdSchema = z.string().min(1).max(tileflowPortableIdMaximumLength).regex(tileflowPortableIdPattern, {
+  message: "Expected lowercase kebab-case beginning with a letter"
+}).refine(
+  (name) => !["constructor", "prototype"].includes(name) && !/^(?:AUX|CON|NUL|PRN|COM[1-9]|LPT[1-9])$/i.test(name),
+  "Expected a portable identifier that is not a reserved filename or prototype key"
+);
+var tileflowThemeNameSchema = tileflowPortableIdSchema.refine(
+  isTileflowThemeName,
+  "Expected a concrete theme name; system is browser-only"
+);
+
+// src/manifest.ts
+var tileflowRuntimeManifestVersion = 1;
+var tileflowRuntimeManifestLimits = Object.freeze({ maximumBytes: 1024 * 1024 });
+var safeTextSchema = z2.string().min(1).max(2048).refine((value) => value === value.trim(), "Expected text without surrounding whitespace").refine((value) => !/[\p{Cc}\\]/u.test(value), "Expected safe text");
+var publicResourceUrlSchema = safeTextSchema.refine(isPublicResourceUrl, {
+  message: "Expected an HTTP(S), root-relative, or path-relative public URL"
+});
+var apiOriginSchema = safeTextSchema.refine(isApiOrigin, {
+  message: "Expected an absolute HTTP(S) origin without path, credentials, query, or fragment"
+});
+var viewSchema = z2.object({
+  bearing: z2.number().finite().min(-180).max(180).optional(),
+  center: z2.tuple([z2.number().finite().min(-180).max(180), z2.number().finite().min(-90).max(90)]).optional(),
+  pitch: z2.number().finite().min(0).max(85).optional(),
+  zoom: z2.number().finite().min(0).max(24).optional()
+}).strict();
+var fontFaceSchema = z2.object({
+  family: safeTextSchema.max(100),
+  source: publicResourceUrlSchema,
+  style: z2.enum(["italic", "normal", "oblique"]).optional(),
+  weight: z2.enum(["100", "200", "300", "400", "500", "600", "700", "800", "900"]).optional()
+}).strict();
+var fontFacesSchema = z2.array(fontFaceSchema).max(16).superRefine(validateUniqueFontFaces);
+var manifestThemeSchema = z2.object({
+  colorScheme: z2.enum(["dark", "light"]),
+  fontFaces: fontFacesSchema.optional(),
+  revision: safeTextSchema.max(128).optional(),
+  styleId: safeTextSchema.max(128).optional(),
+  styleUrl: publicResourceUrlSchema
+}).strict();
+var manifestMapSchema = z2.object({
+  apiUrl: apiOriginSchema.optional(),
+  defaultTheme: tileflowThemeNameSchema,
+  environment: safeTextSchema.max(128).optional(),
+  mapId: safeTextSchema.max(128).optional(),
+  systemThemes: z2.object({ dark: tileflowThemeNameSchema, light: tileflowThemeNameSchema }).strict().optional(),
+  themes: z2.record(tileflowThemeNameSchema, manifestThemeSchema),
+  usageMode: z2.literal("session").optional(),
+  view: viewSchema.optional(),
+  worldGeneration: z2.literal("v1").optional()
+}).strict().superRefine((entry, context) => {
+  const names = Object.keys(entry.themes);
+  if (names.length === 0) {
+    context.addIssue({ code: "custom", message: "Expected at least one theme", path: ["themes"] });
+  }
+  if (names.length > 64) {
+    context.addIssue({ code: "too_big", maximum: 64, origin: "object", path: ["themes"] });
+  }
+  if (!Object.hasOwn(entry.themes, entry.defaultTheme)) {
+    context.addIssue({
+      code: "custom",
+      message: "defaultTheme must name a declared theme",
+      path: ["defaultTheme"]
+    });
+  }
+  if (entry.systemThemes) {
+    for (const colorScheme of ["light", "dark"]) {
+      const name = entry.systemThemes[colorScheme];
+      const theme = entry.themes[name];
+      if (!theme) {
+        context.addIssue({
+          code: "custom",
+          message: `systemThemes.${colorScheme} must name a declared theme`,
+          path: ["systemThemes", colorScheme]
+        });
+      } else if (theme.colorScheme !== colorScheme) {
+        context.addIssue({
+          code: "custom",
+          message: `systemThemes.${colorScheme} must reference a ${colorScheme} theme`,
+          path: ["systemThemes", colorScheme]
+        });
+      }
+    }
+  }
+  if (entry.usageMode === void 0 !== (entry.worldGeneration === void 0)) {
+    context.addIssue({
+      code: "custom",
+      message: "usageMode and worldGeneration must be declared together"
+    });
+  }
+});
+var canonicalManifestSchema = z2.object({
+  apiUrl: apiOriginSchema.optional(),
+  maps: z2.record(tileflowPortableIdSchema, manifestMapSchema),
+  version: z2.literal(tileflowRuntimeManifestVersion)
+}).strict().superRefine((manifest, context) => {
+  const mapCount = Object.keys(manifest.maps).length;
+  if (mapCount === 0) {
+    context.addIssue({ code: "custom", message: "Expected at least one map", path: ["maps"] });
+  }
+  if (mapCount > 1e3) {
+    context.addIssue({ code: "too_big", maximum: 1e3, origin: "object", path: ["maps"] });
+  }
+  if (new TextEncoder().encode(JSON.stringify(manifest)).byteLength > tileflowRuntimeManifestLimits.maximumBytes) {
+    context.addIssue({
+      code: "too_big",
+      maximum: tileflowRuntimeManifestLimits.maximumBytes,
+      origin: "string",
+      message: "Manifest JSON exceeds the 1 MiB limit"
+    });
+  }
+});
+var safeManifestInputSchema = z2.unknown().superRefine((input, context) => {
+  const unsafe = findUnsafeManifestStructure(input);
+  if (unsafe) {
+    context.addIssue({
+      code: "custom",
+      message: unsafe.reason === "prototype" ? "Expected plain manifest objects" : "Expected no prototype-mutating keys",
+      path: unsafe.path
+    });
+  }
+});
+var tileflowRuntimeManifestSchema = safeManifestInputSchema.pipe(canonicalManifestSchema);
+function parseTileflowRuntimeManifest(input) {
+  return tileflowRuntimeManifestSchema.parse(input);
+}
+function safeParseTileflowRuntimeManifest(input) {
+  return tileflowRuntimeManifestSchema.safeParse(input);
+}
+function validateUniqueFontFaces(fontFaces, context) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const [index, fontFace] of fontFaces.entries()) {
+    const identity = `${fontFace.family}\0${fontFace.style ?? "normal"}\0${fontFace.weight ?? "400"}`;
+    const first = seen.get(identity);
+    if (first !== void 0) {
+      context.addIssue({
+        code: "custom",
+        message: `Duplicate font face identity; first declared at index ${first}`,
+        path: [index]
+      });
+      continue;
+    }
+    seen.set(identity, index);
+  }
+}
+function isPublicResourceUrl(value) {
+  if (value.startsWith("//")) return false;
+  if (!value.startsWith("/") && !value.startsWith("./") && !value.startsWith("../") && !isAbsolutePublicUrl(value)) {
+    return false;
+  }
+  return isSafeResolvedPublicUrl(value);
+}
+function isAbsolutePublicUrl(value) {
+  try {
+    const url = new URL(value);
+    return (url.protocol === "http:" || url.protocol === "https:") && !url.username && !url.password && !url.hash && !hasEncodedPathSeparator(value);
+  } catch {
+    return false;
+  }
+}
+function isSafeResolvedPublicUrl(value) {
+  try {
+    const url = new URL(value, "https://manifest.invalid/owner/manifest.json");
+    return (url.protocol === "http:" || url.protocol === "https:") && !url.username && !url.password && !url.hash && !hasEncodedPathSeparator(value);
+  } catch {
+    return false;
+  }
+}
+function hasEncodedPathSeparator(value) {
+  return /%(?:2f|5c)/iu.test(value);
+}
+function isApiOrigin(value) {
+  try {
+    const url = new URL(value);
+    return isAbsolutePublicUrl(value) && url.pathname === "/" && !url.search && value.replace(/\/$/u, "") === url.origin;
+  } catch {
+    return false;
+  }
+}
+function findUnsafeManifestStructure(input) {
+  if (!input || typeof input !== "object") return void 0;
+  const pending = [{ path: [], value: input }];
+  const visited = /* @__PURE__ */ new WeakSet();
+  while (pending.length > 0) {
+    const current = pending.pop();
+    if (visited.has(current.value)) continue;
+    visited.add(current.value);
+    if (!Array.isArray(current.value)) {
+      const prototype = Object.getPrototypeOf(current.value);
+      if (prototype !== Object.prototype && prototype !== null) {
+        return { path: current.path, reason: "prototype" };
+      }
+    }
+    for (const key of Object.keys(current.value)) {
+      const path = [...current.path, Array.isArray(current.value) ? Number(key) : key];
+      if (key === "__proto__") return { path, reason: "key" };
+      const descriptor = Object.getOwnPropertyDescriptor(current.value, key);
+      if (descriptor && "value" in descriptor && descriptor.value && typeof descriptor.value === "object") {
+        pending.push({ path, value: descriptor.value });
+      }
+    }
+  }
+  return void 0;
+}
+export {
+  parseTileflowRuntimeManifest,
+  safeParseTileflowRuntimeManifest,
+  tileflowRuntimeManifestLimits,
+  tileflowRuntimeManifestSchema,
+  tileflowRuntimeManifestVersion
+};

package/dist/recipe.d.ts

@@ -0,0 +1,66 @@
+import { T as TileflowStreetsModuleName, O as OpenMapTilesFieldBindings, a as OpenMapTilesLayerBindings } from './visual-semantics-DTC-8Hsb.js';
+export { b as TileflowVisualValueCategory, c as classifyTileflowVisualProperty } from './visual-semantics-DTC-8Hsb.js';
+import { T as TileflowLayerDomain } from './domains-CPSrdTik.js';
+export { t as toMapLibreStyleValue } from './types-DlUGI6LC.js';
+
+type TileflowSemanticFieldReference = {
+    readonly kind: 'tileflow-semantic-field';
+    readonly name: keyof OpenMapTilesFieldBindings;
+};
+type TileflowSemanticLayerReference = {
+    readonly kind: 'tileflow-semantic-layer';
+    readonly name: keyof OpenMapTilesLayerBindings;
+};
+type TileflowModuleLayerPlacement = {
+    after: string;
+} | {
+    before: string;
+};
+type TileflowModuleEffect = {
+    kind: 'patch';
+    owner: TileflowStreetsModuleName;
+    patch: Record<string, unknown>;
+    requires?: readonly TileflowLayerDomain[];
+    target: string;
+} | {
+    kind: 'add';
+    layer: Record<string, unknown> & {
+        id: string;
+        type: string;
+    };
+    owner: TileflowStreetsModuleName;
+    placement: TileflowModuleLayerPlacement;
+    requires?: readonly TileflowLayerDomain[];
+    target: string;
+} | {
+    kind: 'remove';
+    owner: TileflowStreetsModuleName;
+    requires?: readonly TileflowLayerDomain[];
+    target: string;
+};
+/** Compiler-private authoring field reference. Official maps never capture physical data fields. */
+declare function semanticField(name: keyof OpenMapTilesFieldBindings): TileflowSemanticFieldReference;
+/** Compiler-private authoring layer reference. Official maps never capture physical source layers. */
+declare function semanticLayer(name: keyof OpenMapTilesLayerBindings): TileflowSemanticLayerReference;
+declare function patchModuleLayer(owner: TileflowStreetsModuleName, target: string, patch: Record<string, unknown>, options?: {
+    requires?: readonly TileflowLayerDomain[];
+}): TileflowModuleEffect;
+declare function addModuleLayer(owner: TileflowStreetsModuleName, target: string, layer: Record<string, unknown> & {
+    id: string;
+    type: string;
+}, placement: TileflowModuleLayerPlacement, options?: {
+    requires?: readonly TileflowLayerDomain[];
+}): TileflowModuleEffect;
+declare function removeModuleLayer(owner: TileflowStreetsModuleName, target: string, options?: {
+    requires?: readonly TileflowLayerDomain[];
+}): TileflowModuleEffect;
+/**
+ * Attach compiler-private effects without adding a public string key to a map definition.
+ * The empty return type deliberately keeps the symbol out of public authoring inference.
+ */
+declare function internalModuleEffects(effects: readonly TileflowModuleEffect[]): {};
+declare function getResolvedModuleEffects(input: object): readonly TileflowModuleEffect[];
+
+declare function isMapLibreExpressionOperator(value: unknown): value is string;
+
+export { type TileflowModuleEffect, type TileflowModuleLayerPlacement, addModuleLayer, internalModuleEffects as defineModuleEffects, getResolvedModuleEffects, isMapLibreExpressionOperator, patchModuleLayer, removeModuleLayer, semanticField, semanticLayer };