@tileflow/core 0.1.0-alpha.0

package/README.md

@@ -0,0 +1,25 @@
+# @tileflow/core
+
+Typed Tileflow config helpers and the MapLibre style compiler.
+
+```ts
+import { defineTileflow } from "@tileflow/core";
+
+export default defineTileflow({
+  maps: {
+    madrid: {
+      colors: {
+        canvas: "#F8F6F1",
+        land: "#F2EEE6",
+        water: "#B6CBD8",
+        nature: "#AEBB9B",
+        road: "#DED6C8",
+        text: "#2E2E2E",
+        accent: "#C6A15B",
+      },
+    },
+  },
+});
+```
+
+Docs: https://tileflow.dev/docs

package/dist/index.d.ts

@@ -0,0 +1,111 @@
+type TileflowDensity = "clean" | "balanced" | "dense";
+type TileflowRoads = "hidden" | "soft" | "standard" | "detailed";
+type TileflowLabels = "none" | "essential" | "balanced" | "full";
+type TileflowPoi = "none" | "minimal" | "balanced" | "full";
+type TileflowColors = {
+    canvas: string;
+    land: string;
+    water: string;
+    nature: string;
+    road: string;
+    text: string;
+    accent: string;
+};
+type LegacyTileflowColorAliases = {
+    background?: string;
+    park?: string;
+    building?: string;
+};
+type TileflowColorConfig = Partial<TileflowColors> & LegacyTileflowColorAliases;
+type TileflowFontWeight = "regular" | "medium" | "semibold" | "bold";
+type TileflowTypography = {
+    font?: string;
+    weight?: TileflowFontWeight;
+};
+type TileflowSourceLayers = {
+    landuse?: string;
+    park?: string;
+    water?: string;
+    road?: string;
+    building?: string;
+    boundary?: string;
+    place?: string;
+    poi?: string;
+};
+type TileflowTiles = {
+    sourceId?: string;
+    tileset?: string;
+    url?: string;
+    attribution?: string;
+    sourceLayers?: TileflowSourceLayers;
+};
+type TileflowConfig = {
+    name?: string;
+    tileset?: string;
+    colors?: TileflowColorConfig;
+    typography?: TileflowTypography;
+    density?: TileflowDensity;
+    roads?: TileflowRoads;
+    labels?: TileflowLabels;
+    poi?: TileflowPoi;
+    glyphs?: string;
+    sprite?: string;
+    tiles?: TileflowTiles;
+    /**
+     * Domains allowed to load this map in production (e.g. "example.com" or
+     * "*.example.com"). When set, tile and session requests from other
+     * websites are rejected. Local development (localhost, private network
+     * addresses) is always allowed. Leave unset to allow any domain.
+     */
+    allowedOrigins?: string[];
+};
+type TileflowMapConfig = TileflowConfig;
+type TileflowTilesetConfig = {
+    id?: string;
+    name?: string;
+    attribution?: string;
+    sourceLayers?: TileflowSourceLayers;
+};
+type TileflowProjectConfig = {
+    tilesets?: Record<string, TileflowTilesetConfig>;
+    maps: Record<string, TileflowMapConfig>;
+};
+type TileflowStyleOptions = {
+    tileBaseUrl?: string;
+    tileset?: string;
+};
+type TileflowManifest = {
+    version: 1;
+    tileBaseUrl: string;
+    styles: Record<string, string>;
+    maps: Record<string, string>;
+};
+type MapLibreStyle = {
+    version: 8;
+    name: string;
+    glyphs?: string;
+    sprite?: string;
+    sources: Record<string, Record<string, unknown>>;
+    layers: Array<Record<string, unknown>>;
+    metadata?: Record<string, unknown>;
+};
+type ValidationMessage = {
+    level: "error" | "warning";
+    path: string;
+    message: string;
+};
+type ValidationResult = {
+    valid: boolean;
+    messages: ValidationMessage[];
+};
+declare function defineTileflow(config: TileflowProjectConfig): TileflowProjectConfig;
+declare function validateConfig(input: unknown): ValidationResult;
+declare function createStyle(input?: TileflowConfig, options?: TileflowStyleOptions): MapLibreStyle;
+declare function createStyleFromProject(projectConfig: TileflowProjectConfig, mapName: string, options?: TileflowStyleOptions): MapLibreStyle;
+declare function createManifest(projectConfig: TileflowProjectConfig, options?: {
+    styleBaseUrl?: string;
+    tileBaseUrl?: string;
+}): TileflowManifest;
+declare function getDefaultColors(): TileflowColors;
+
+export { type MapLibreStyle, type TileflowColorConfig, type TileflowColors, type TileflowConfig, type TileflowDensity, type TileflowFontWeight, type TileflowLabels, type TileflowManifest, type TileflowMapConfig, type TileflowPoi, type TileflowProjectConfig, type TileflowRoads, type TileflowSourceLayers, type TileflowStyleOptions, type TileflowTiles, type TileflowTilesetConfig, type TileflowTypography, type ValidationMessage, type ValidationResult, createManifest, createStyle, createStyleFromProject, defineTileflow, getDefaultColors, validateConfig };

package/dist/index.js

@@ -0,0 +1,658 @@
+// src/index.ts
+import { z } from "zod";
+var hexColorSchema = z.string().regex(/^#(?:[0-9a-fA-F]{3}|[0-9a-fA-F]{4}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/, {
+  message: "Expected a hex color like #F8F6F1 or #F8F6F1FF"
+});
+var configSchema = z.object({
+  name: z.string().min(1).optional(),
+  tileset: z.string().trim().min(1).optional(),
+  colors: z.object({
+    canvas: hexColorSchema.optional(),
+    land: hexColorSchema.optional(),
+    background: hexColorSchema.optional(),
+    water: hexColorSchema.optional(),
+    nature: hexColorSchema.optional(),
+    text: hexColorSchema.optional(),
+    accent: hexColorSchema.optional(),
+    park: hexColorSchema.optional(),
+    road: hexColorSchema.optional(),
+    building: hexColorSchema.optional()
+  }).optional(),
+  typography: z.object({
+    font: z.string().trim().min(1).optional(),
+    weight: z.enum(["regular", "medium", "semibold", "bold"]).optional()
+  }).optional(),
+  density: z.enum(["clean", "balanced", "dense"]).optional(),
+  roads: z.enum(["hidden", "soft", "standard", "detailed"]).optional(),
+  labels: z.enum(["none", "essential", "balanced", "full"]).optional(),
+  poi: z.enum(["none", "minimal", "balanced", "full"]).optional(),
+  glyphs: z.string().min(1).optional(),
+  sprite: z.string().min(1).optional(),
+  tiles: z.object({
+    sourceId: z.string().min(1).optional(),
+    tileset: z.string().trim().min(1).optional(),
+    url: z.url().optional(),
+    attribution: z.string().optional(),
+    sourceLayers: z.object({
+      landuse: z.string().optional(),
+      park: z.string().optional(),
+      water: z.string().optional(),
+      road: z.string().optional(),
+      building: z.string().optional(),
+      boundary: z.string().optional(),
+      place: z.string().optional(),
+      poi: z.string().optional()
+    }).optional()
+  }).optional(),
+  allowedOrigins: z.array(z.string().trim().min(1).max(253)).max(20).optional()
+});
+var tilesetConfigSchema = z.object({
+  id: z.string().trim().min(1).optional(),
+  name: z.string().trim().min(1).optional(),
+  attribution: z.string().optional(),
+  sourceLayers: z.object({
+    landuse: z.string().optional(),
+    park: z.string().optional(),
+    water: z.string().optional(),
+    road: z.string().optional(),
+    building: z.string().optional(),
+    boundary: z.string().optional(),
+    place: z.string().optional(),
+    poi: z.string().optional()
+  }).optional()
+});
+var projectConfigSchema = z.object({
+  tilesets: z.record(z.string(), tilesetConfigSchema).optional(),
+  maps: z.record(z.string(), configSchema).refine((maps) => {
+    return Object.keys(maps).length > 0;
+  }, "Expected at least one map")
+});
+var defaultSourceLayers = {
+  landuse: "landuse",
+  park: "park",
+  water: "water",
+  road: "transportation",
+  building: "building",
+  boundary: "boundary",
+  place: "place",
+  poi: "poi"
+};
+var defaultColors = {
+  canvas: "#F8F6F1",
+  land: "#F2EEE6",
+  water: "#B6CBD8",
+  nature: "#AEBB9B",
+  road: "#DED6C8",
+  text: "#2E2E2E",
+  accent: "#C6A15B"
+};
+var defaultConfig = {
+  density: "clean",
+  roads: "soft",
+  labels: "essential",
+  poi: "minimal"
+};
+var defaultTypography = {
+  font: "Noto Sans",
+  weight: "regular"
+};
+var fontWeightLabels = {
+  regular: "Regular",
+  medium: "Medium",
+  semibold: "Semibold",
+  bold: "Bold"
+};
+var defaultTileBaseUrl = "https://api.tileflow.dev";
+var defaultTileset = "world";
+function defineTileflow(config) {
+  return config;
+}
+function validateConfig(input) {
+  const parsed = isProjectConfigLike(input) ? projectConfigSchema.safeParse(input) : configSchema.safeParse(input);
+  if (parsed.success) {
+    return { valid: true, messages: [] };
+  }
+  return {
+    valid: false,
+    messages: parsed.error.issues.map((issue) => ({
+      level: "error",
+      path: issue.path.join(".") || "config",
+      message: issue.message
+    }))
+  };
+}
+function createStyle(input = {}, options = {}) {
+  const parsed = configSchema.safeParse(input);
+  if (!parsed.success) {
+    const message = parsed.error.issues.map((issue) => `${issue.path.join(".") || "config"}: ${issue.message}`).join("; ");
+    throw new Error(`Invalid Tileflow config. ${message}`);
+  }
+  const config = parsed.data;
+  const density = config.density ?? defaultConfig.density;
+  const roads = config.roads ?? defaultConfig.roads;
+  const labels = config.labels ?? defaultConfig.labels;
+  const poi = config.poi ?? defaultConfig.poi;
+  const colors = resolveColors(config.colors);
+  const sourceId = config.tiles?.sourceId ?? "tileflow";
+  const tileBaseUrl = normalizeBaseUrl(options.tileBaseUrl);
+  const tileset = options.tileset ?? config.tileset ?? config.tiles?.tileset ?? defaultTileset;
+  const tilesUrl = config.tiles?.url ?? `${tileBaseUrl}/tiles/${tileset}/tiles.json`;
+  const typography = resolveTypography(config.typography, defaultTypography);
+  const sourceLayers = resolveSourceLayers(
+    {
+      ...defaultSourceLayers,
+      ...config.tiles?.sourceLayers
+    },
+    void 0
+  );
+  const layers = openMapTilesLayers(sourceId, sourceLayers, colors, {
+    density,
+    labels,
+    poi,
+    roads,
+    typography
+  });
+  const style = {
+    version: 8,
+    name: config.name ?? "Tileflow",
+    glyphs: config.glyphs ?? `${tileBaseUrl}/fonts/{fontstack}/{range}.pbf`,
+    ...config.sprite ? { sprite: config.sprite } : {},
+    sources: {
+      [sourceId]: {
+        type: "vector",
+        url: tilesUrl,
+        attribution: config.tiles?.attribution ?? "\xA9 OpenMapTiles \xA9 OpenStreetMap contributors"
+      }
+    },
+    layers,
+    metadata: {
+      "tileflow:density": density,
+      "tileflow:roads": roads,
+      "tileflow:labels": labels,
+      "tileflow:poi": poi,
+      "tileflow:typography": typography,
+      "tileflow:colors": colors,
+      "tileflow:tileBaseUrl": tileBaseUrl,
+      "tileflow:tileset": tileset,
+      "tileflow:tiles": "tileflow"
+    }
+  };
+  return style;
+}
+function createStyleFromProject(projectConfig, mapName, options = {}) {
+  const config = projectConfig.maps[mapName];
+  if (!config) {
+    throw new Error(`Unknown Tileflow map: ${mapName}`);
+  }
+  const tilesetName = options.tileset ?? config.tileset ?? config.tiles?.tileset;
+  const tilesetConfig = tilesetName ? projectConfig.tilesets?.[tilesetName] : void 0;
+  const resolvedTileset = tilesetConfig?.id ?? tilesetName ?? defaultTileset;
+  return createStyle(
+    {
+      ...config,
+      tileset: resolvedTileset,
+      tiles: {
+        ...config.tiles,
+        tileset: resolvedTileset,
+        attribution: config.tiles?.attribution ?? tilesetConfig?.attribution,
+        sourceLayers: resolveSourceLayers(
+          config.tiles?.sourceLayers,
+          tilesetConfig?.sourceLayers
+        )
+      }
+    },
+    {
+      ...options,
+      tileset: resolvedTileset
+    }
+  );
+}
+function createManifest(projectConfig, options = {}) {
+  const styleBaseUrl = normalizeStyleBaseUrl(options.styleBaseUrl);
+  const tileBaseUrl = normalizeBaseUrl(options.tileBaseUrl);
+  const maps = Object.keys(projectConfig.maps);
+  return {
+    version: 1,
+    tileBaseUrl,
+    styles: Object.fromEntries(
+      maps.map((mapName) => [
+        mapName,
+        `${styleBaseUrl}/styles/${mapName}.json`
+      ])
+    ),
+    maps: Object.fromEntries(
+      maps.map((mapName) => [
+        mapName,
+        `${styleBaseUrl}/styles/${mapName}.json`
+      ])
+    )
+  };
+}
+function getDefaultColors() {
+  return defaultColors;
+}
+function resolveColors(overrides = {}) {
+  const colors = {
+    ...defaultColors,
+    canvas: overrides.canvas ?? overrides.background ?? defaultColors.canvas,
+    land: overrides.land ?? defaultColors.land,
+    water: overrides.water ?? defaultColors.water,
+    nature: overrides.nature ?? overrides.park ?? defaultColors.nature,
+    road: overrides.road ?? defaultColors.road,
+    text: overrides.text ?? defaultColors.text,
+    accent: overrides.accent ?? defaultColors.accent,
+    building: overrides.building
+  };
+  const building = colors.building ?? mix(colors.land, colors.road, 0.46);
+  return {
+    canvas: cssColor(colors.canvas),
+    land: cssColor(colors.land),
+    water: cssColor(colors.water),
+    nature: cssColor(colors.nature),
+    road: cssColor(colors.road),
+    text: cssColor(colors.text),
+    accent: cssColor(colors.accent),
+    building: cssColor(building),
+    roadCasing: mix(colors.road, colors.text, 0.2),
+    roadMajor: mix(colors.road, colors.accent, 0.16),
+    roadMinor: cssColor(colors.road),
+    textHalo: alpha(colors.canvas, 0.84),
+    textMuted: mix(colors.text, colors.canvas, 0.42)
+  };
+}
+function resolveTypography(overrides = {}, defaults = defaultTypography) {
+  return {
+    ...defaults,
+    ...overrides
+  };
+}
+function resolveSourceLayers(mapLayers, tilesetLayers) {
+  return {
+    ...defaultSourceLayers,
+    ...tilesetLayers,
+    ...mapLayers
+  };
+}
+function normalizeBaseUrl(value) {
+  return normalizeUrl(value ?? defaultTileBaseUrl);
+}
+function normalizeStyleBaseUrl(value) {
+  return normalizeUrl(value ?? "");
+}
+function normalizeUrl(value) {
+  return value.replace(/\/+$/, "");
+}
+function isProjectConfigLike(input) {
+  return Boolean(
+    input && typeof input === "object" && "maps" in input && typeof input.maps === "object"
+  );
+}
+function textFont(typography) {
+  return [`${typography.font} ${fontWeightLabels[typography.weight]}`];
+}
+function fillLayer(id, source, sourceLayer, color, opacity) {
+  return {
+    id,
+    type: "fill",
+    source,
+    "source-layer": sourceLayer,
+    paint: {
+      "fill-color": color,
+      "fill-opacity": opacity
+    }
+  };
+}
+function openMapTilesLayers(source, sourceLayers, colors, options) {
+  return [
+    {
+      id: "background",
+      type: "background",
+      paint: {
+        "background-color": colors.canvas
+      }
+    },
+    fillLayer("landuse", source, sourceLayers.landuse, colors.land, 0.42),
+    fillLayer(
+      "parks",
+      source,
+      sourceLayers.park,
+      colors.nature,
+      parkOpacity(options.density)
+    ),
+    fillLayer("water", source, sourceLayers.water, colors.water, 1),
+    ...buildingLayers(source, sourceLayers.building, colors, options.density),
+    ...roadLayers(source, sourceLayers.road, colors, options.roads),
+    ...boundaryLayers(source, sourceLayers.boundary, colors),
+    ...labelLayers(
+      source,
+      sourceLayers.place,
+      colors,
+      options.labels,
+      options.typography
+    ),
+    ...poiLayers(
+      source,
+      sourceLayers.poi,
+      colors,
+      options.poi,
+      options.typography
+    )
+  ];
+}
+function buildingLayers(source, sourceLayer, colors, density) {
+  if (density === "clean") {
+    return [
+      {
+        id: "buildings-soft",
+        type: "fill",
+        source,
+        "source-layer": sourceLayer,
+        minzoom: 14,
+        paint: {
+          "fill-color": colors.building,
+          "fill-opacity": 0.38
+        }
+      }
+    ];
+  }
+  return [
+    {
+      id: "buildings",
+      type: "fill",
+      source,
+      "source-layer": sourceLayer,
+      minzoom: 13,
+      paint: {
+        "fill-color": colors.building,
+        "fill-opacity": density === "dense" ? 0.62 : 0.5
+      }
+    },
+    {
+      id: "buildings-outline",
+      type: "line",
+      source,
+      "source-layer": sourceLayer,
+      minzoom: 15,
+      paint: {
+        "line-color": mix(colors.building, colors.text, 0.2),
+        "line-opacity": 0.24,
+        "line-width": 0.6
+      }
+    }
+  ];
+}
+function roadLayers(source, sourceLayer, colors, roads) {
+  if (roads === "hidden") {
+    return [];
+  }
+  const opacity = roads === "soft" ? 0.72 : roads === "standard" ? 0.84 : 0.96;
+  const casingOpacity = roads === "detailed" ? 0.3 : 0.16;
+  const majorRoadFilter = [
+    "match",
+    ["get", "class"],
+    ["motorway", "trunk", "primary", "secondary"],
+    true,
+    false
+  ];
+  const minorRoadFilter = ["!", majorRoadFilter];
+  return [
+    {
+      id: "roads-tunnels",
+      type: "line",
+      source,
+      "source-layer": sourceLayer,
+      minzoom: 10,
+      filter: ["==", ["get", "brunnel"], "tunnel"],
+      paint: {
+        "line-color": colors.roadMinor,
+        "line-dasharray": [0.6, 0.8],
+        "line-opacity": opacity * 0.62,
+        "line-width": [
+          "interpolate",
+          ["linear"],
+          ["zoom"],
+          10,
+          0.25,
+          14,
+          1,
+          16,
+          2.4
+        ]
+      }
+    },
+    {
+      id: "roads-casing",
+      type: "line",
+      source,
+      "source-layer": sourceLayer,
+      minzoom: 6,
+      paint: {
+        "line-color": colors.roadCasing,
+        "line-opacity": casingOpacity,
+        "line-width": [
+          "interpolate",
+          ["linear"],
+          ["zoom"],
+          6,
+          0.4,
+          12,
+          1.2,
+          16,
+          4
+        ]
+      }
+    },
+    {
+      id: "roads-minor",
+      type: "line",
+      source,
+      "source-layer": sourceLayer,
+      minzoom: 6,
+      filter: minorRoadFilter,
+      paint: {
+        "line-color": colors.roadMinor,
+        "line-opacity": opacity * 0.88,
+        "line-width": [
+          "interpolate",
+          ["linear"],
+          ["zoom"],
+          6,
+          0.2,
+          12,
+          0.8,
+          16,
+          3
+        ]
+      }
+    },
+    {
+      id: "roads-major",
+      type: "line",
+      source,
+      "source-layer": sourceLayer,
+      minzoom: 5,
+      filter: majorRoadFilter,
+      paint: {
+        "line-color": colors.roadMajor,
+        "line-opacity": opacity,
+        "line-width": [
+          "interpolate",
+          ["linear"],
+          ["zoom"],
+          5,
+          0.35,
+          12,
+          1.2,
+          16,
+          4
+        ]
+      }
+    },
+    {
+      id: "roads-bridges",
+      type: "line",
+      source,
+      "source-layer": sourceLayer,
+      minzoom: 10,
+      filter: ["==", ["get", "brunnel"], "bridge"],
+      paint: {
+        "line-color": mix(colors.roadMajor, colors.canvas, 0.14),
+        "line-opacity": opacity,
+        "line-width": [
+          "interpolate",
+          ["linear"],
+          ["zoom"],
+          10,
+          0.45,
+          14,
+          1.6,
+          16,
+          4.4
+        ]
+      }
+    }
+  ];
+}
+function boundaryLayers(source, sourceLayer, colors) {
+  return [
+    {
+      id: "boundaries",
+      type: "line",
+      source,
+      "source-layer": sourceLayer,
+      minzoom: 2,
+      paint: {
+        "line-color": mix(colors.text, colors.canvas, 0.7),
+        "line-opacity": 0.35,
+        "line-width": ["interpolate", ["linear"], ["zoom"], 2, 0.35, 8, 0.8]
+      }
+    }
+  ];
+}
+function labelLayers(source, sourceLayer, colors, labels, typography) {
+  if (labels === "none") {
+    return [];
+  }
+  const maxRank = labels === "essential" ? 3 : labels === "balanced" ? 7 : 12;
+  return [
+    {
+      id: "place-labels",
+      type: "symbol",
+      source,
+      "source-layer": sourceLayer,
+      minzoom: 3,
+      filter: ["<=", ["coalesce", ["get", "rank"], 10], maxRank],
+      layout: {
+        "text-field": ["coalesce", ["get", "name:en"], ["get", "name"]],
+        "text-font": textFont(typography),
+        "text-size": [
+          "interpolate",
+          ["linear"],
+          ["zoom"],
+          3,
+          10,
+          8,
+          13,
+          14,
+          17
+        ],
+        "text-letter-spacing": 0,
+        "text-padding": 4
+      },
+      paint: {
+        "text-color": colors.text,
+        "text-halo-color": colors.textHalo,
+        "text-halo-width": 1.2
+      }
+    }
+  ];
+}
+function poiLayers(source, sourceLayer, colors, poi, typography) {
+  if (poi === "none") {
+    return [];
+  }
+  const minzoom = poi === "minimal" ? 15 : poi === "balanced" ? 13 : 11;
+  return [
+    {
+      id: "poi-labels",
+      type: "symbol",
+      source,
+      "source-layer": sourceLayer,
+      minzoom,
+      layout: {
+        "text-field": ["coalesce", ["get", "name:en"], ["get", "name"]],
+        "text-font": textFont(typography),
+        "text-size": ["interpolate", ["linear"], ["zoom"], minzoom, 10, 17, 12],
+        "text-letter-spacing": 0,
+        "text-padding": 2
+      },
+      paint: {
+        "text-color": mix(colors.textMuted, colors.accent, 0.22),
+        "text-halo-color": alpha(colors.canvas, 0.78),
+        "text-halo-width": 1
+      }
+    }
+  ];
+}
+function parkOpacity(density) {
+  return density === "clean" ? 0.64 : density === "balanced" ? 0.78 : 0.9;
+}
+function alpha(color, opacity) {
+  const { a, b, g, r } = hexToRgba(color);
+  return `rgba(${r}, ${g}, ${b}, ${roundAlpha(a * opacity)})`;
+}
+function mix(hexA, hexB, amount) {
+  const a = hexToRgb(hexA);
+  const b = hexToRgb(hexB);
+  const r = Math.round(a.r + (b.r - a.r) * amount);
+  const g = Math.round(a.g + (b.g - a.g) * amount);
+  const bValue = Math.round(a.b + (b.b - a.b) * amount);
+  return rgbToHex(r, g, bValue);
+}
+function hexToRgb(hex) {
+  const { b, g, r } = hexToRgba(hex);
+  return { b, g, r };
+}
+function hexToRgba(hex) {
+  const rgbMatch = hex.match(
+    /^rgba?\(\s*(\d+(?:\.\d+)?)\s*,\s*(\d+(?:\.\d+)?)\s*,\s*(\d+(?:\.\d+)?)(?:\s*,\s*(\d+(?:\.\d+)?))?\s*\)$/
+  );
+  if (rgbMatch) {
+    return {
+      a: roundAlpha(Number(rgbMatch[4] ?? 1)),
+      r: Math.round(Number(rgbMatch[1])),
+      g: Math.round(Number(rgbMatch[2])),
+      b: Math.round(Number(rgbMatch[3]))
+    };
+  }
+  const value = hex.replace("#", "");
+  const normalized = value.length === 3 || value.length === 4 ? value.split("").map((character) => character + character).join("") : value;
+  return {
+    a: normalized.length === 8 ? roundAlpha(Number.parseInt(normalized.slice(6, 8), 16) / 255) : 1,
+    r: Number.parseInt(normalized.slice(0, 2), 16),
+    g: Number.parseInt(normalized.slice(2, 4), 16),
+    b: Number.parseInt(normalized.slice(4, 6), 16)
+  };
+}
+function cssColor(hex) {
+  const value = hex.replace("#", "");
+  if (value.length !== 4 && value.length !== 8) {
+    return hex;
+  }
+  const { a, b, g, r } = hexToRgba(hex);
+  return `rgba(${r}, ${g}, ${b}, ${a})`;
+}
+function roundAlpha(value) {
+  return Math.round(value * 1e3) / 1e3;
+}
+function rgbToHex(r, g, b) {
+  return `#${[r, g, b].map((value) => value.toString(16).padStart(2, "0")).join("")}`;
+}
+export {
+  createManifest,
+  createStyle,
+  createStyleFromProject,
+  defineTileflow,
+  getDefaultColors,
+  validateConfig
+};

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@tileflow/core",
+  "version": "0.1.0-alpha.0",
+  "description": "Typed Tileflow config and MapLibre style compiler.",
+  "type": "module",
+  "homepage": "https://tileflow.dev",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tileflow/tileflow.git",
+    "directory": "packages/core"
+  },
+  "bugs": {
+    "url": "https://github.com/tileflow/tileflow/issues"
+  },
+  "keywords": [
+    "tileflow",
+    "maps",
+    "maplibre",
+    "tiles",
+    "styles"
+  ],
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "zod": "^4.4.3"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "lint": "tsc -p tsconfig.json --noEmit"
+  }
+}