map-zero 0.1.0

package/src/style-command.js

@@ -0,0 +1,78 @@
+import { promises as fs } from 'node:fs';
+import { join, resolve } from 'node:path';
+
+import {
+  createStyleFromPreset,
+  createStyleFromTheme,
+  listStylePresets,
+  listStyleThemes,
+  readStyleTheme
+} from './style.js';
+
+/**
+ * Rewrite a package style file without touching data.gpkg or tiles.pmtiles.
+ *
+ * @param {{ packageDir: string, preset?: string, theme?: string }} options
+ * @returns {Promise<{ stylePath: string, styleUrl: string, name: string, sourceType: 'preset' | 'theme' }>}
+ */
+export async function writePackageStyle(options) {
+  const packageDir = resolve(options.packageDir);
+  if (options.preset && options.theme) {
+    throw new Error('use either --preset or --theme, not both');
+  }
+
+  const manifestPath = join(packageDir, 'manifest.json');
+  const manifest = JSON.parse(await fs.readFile(manifestPath, 'utf8'));
+  if (manifest.format !== 'mapzero' || !Array.isArray(manifest.layers)) {
+    throw new Error('manifest must be a mapzero package with layers');
+  }
+
+  const selectedLayers = manifest.layers.map((layer) => String(layer.id));
+  const sourceType = options.theme ? 'theme' : 'preset';
+  const styleDocument = options.theme
+    ? createStyleFromTheme(options.theme, selectedLayers)
+    : createStyleFromPreset(options.preset ?? 'neon-dark', selectedLayers);
+  const name = String(styleDocument.name ?? (options.theme ? readStyleTheme(options.theme).name : options.preset) ?? 'style');
+  const styleFile = `${safeStyleFileName(name)}.json`;
+  const styleUrl = `styles/${styleFile}`;
+  const stylePath = join(packageDir, 'styles', styleFile);
+  await fs.mkdir(join(packageDir, 'styles'), { recursive: true });
+  await fs.writeFile(stylePath, `${JSON.stringify(styleDocument, null, 2)}\n`);
+
+  manifest.styles = {
+    ...(manifest.styles && typeof manifest.styles === 'object' ? manifest.styles : {}),
+    default: styleUrl,
+    [name]: styleUrl
+  };
+  await fs.writeFile(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`);
+
+  return {
+    stylePath,
+    styleUrl,
+    name,
+    sourceType
+  };
+}
+
+/**
+ * @returns {string[]}
+ */
+export function availableStylePresets() {
+  return listStylePresets();
+}
+
+/**
+ * @returns {string[]}
+ */
+export function availableStyleThemes() {
+  return listStyleThemes();
+}
+
+/**
+ * @param {string} name
+ * @returns {string}
+ */
+function safeStyleFileName(name) {
+  const safe = name.toLowerCase().replace(/[^a-z0-9-]+/g, '-').replace(/^-+|-+$/g, '');
+  return safe || 'style';
+}

package/src/style-filters.js

@@ -0,0 +1,76 @@
+/**
+ * Build server/export-side filters for style rules hidden with byProperty.*.visible=false.
+ *
+ * @param {Record<string, unknown>} manifest
+ * @param {Record<string, unknown> | null} style
+ * @returns {import('./gpkg-read.js').HiddenFilters}
+ */
+export function createHiddenFilters(manifest, style) {
+  const filters = new Map();
+  const manifestLayers = Array.isArray(manifest.layers) ? manifest.layers : [];
+  const styleLayers = /** @type {Record<string, unknown> | undefined} */ (style?.layers);
+
+  if (!styleLayers || typeof styleLayers !== 'object') {
+    return filters;
+  }
+
+  for (const layer of manifestLayers) {
+    const layerRecord = /** @type {Record<string, unknown>} */ (layer);
+    const layerId = String(layerRecord.id);
+    const styleId = String(layerRecord.style ?? layerId);
+    const styleRule = /** @type {Record<string, unknown> | undefined} */ (styleLayers[styleId] ?? styleLayers[layerAlias(styleId)]);
+    const byProperty = /** @type {Record<string, unknown> | undefined} */ (styleRule?.byProperty);
+
+    if (!byProperty || typeof byProperty !== 'object') {
+      continue;
+    }
+
+    const layerFilters = new Map();
+    for (const [propertyName, values] of Object.entries(byProperty)) {
+      if (!values || typeof values !== 'object') {
+        continue;
+      }
+
+      for (const [value, overrides] of Object.entries(/** @type {Record<string, unknown>} */ (values))) {
+        if (styleOverrideVisible(overrides) === false) {
+          if (!layerFilters.has(propertyName)) {
+            layerFilters.set(propertyName, new Set());
+          }
+          layerFilters.get(propertyName).add(value);
+        }
+      }
+    }
+
+    if (layerFilters.size > 0) {
+      filters.set(layerId, layerFilters);
+    }
+  }
+
+  return filters;
+}
+
+/**
+ * @param {string} layerId
+ * @returns {string}
+ */
+function layerAlias(layerId) {
+  if (layerId === 'aip') return 'aviation';
+  if (layerId === 'aviation') return 'aip';
+  return layerId;
+}
+
+/**
+ * @param {unknown} overrides
+ * @returns {boolean | undefined}
+ */
+function styleOverrideVisible(overrides) {
+  if (!overrides || typeof overrides !== 'object') {
+    return undefined;
+  }
+
+  const record = /** @type {Record<string, unknown>} */ (overrides);
+  const visibility = record.visibility && typeof record.visibility === 'object'
+    ? /** @type {Record<string, unknown>} */ (record.visibility)
+    : null;
+  return /** @type {boolean | undefined} */ (visibility?.visible ?? record.visible);
+}

package/src/style-presets.js

@@ -0,0 +1,93 @@
+import { readFileSync, readdirSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { SUPPORTED_LAYERS } from './layers.js';
+
+export const PRESETS_DIR = join(dirname(fileURLToPath(import.meta.url)), '..', 'styles', 'presets');
+const PRESET_NAME_PATTERN = /^[a-z0-9-]+$/;
+
+/**
+ * Load a portable JSON style preset and filter it to the selected package layers.
+ *
+ * @param {string} preset
+ * @param {string[]} selectedLayers
+ * @returns {Record<string, unknown>}
+ */
+export function createStyleFromPreset(preset = 'neon-dark', selectedLayers = SUPPORTED_LAYERS) {
+  const style = readStylePreset(preset);
+  return filterStyleLayers(style, selectedLayers);
+}
+
+/**
+ * Backward-compatible default style factory.
+ *
+ * @param {string[]} selectedLayers
+ * @returns {Record<string, unknown>}
+ */
+export function createNeonDarkStyle(selectedLayers = SUPPORTED_LAYERS) {
+  return createStyleFromPreset('neon-dark', selectedLayers);
+}
+
+/**
+ * List bundled JSON style presets.
+ *
+ * @returns {string[]}
+ */
+export function listStylePresets() {
+  return readdirSync(PRESETS_DIR)
+    .filter((file) => file.endsWith('.json'))
+    .map((file) => file.slice(0, -'.json'.length))
+    .sort();
+}
+
+/**
+ * Read one bundled style preset from styles/presets.
+ *
+ * @param {string} preset
+ * @returns {Record<string, unknown>}
+ */
+export function readStylePreset(preset) {
+  if (!PRESET_NAME_PATTERN.test(preset)) {
+    throw new Error(`invalid style preset name: ${preset}`);
+  }
+
+  const filePath = join(PRESETS_DIR, `${preset}.json`);
+  try {
+    return JSON.parse(readFileSync(filePath, 'utf8'));
+  } catch (error) {
+    const available = listStylePresets().join(', ');
+    throw new Error(`unknown style preset: ${preset}${available ? `; available presets: ${available}` : ''}`);
+  }
+}
+
+/**
+ * Return a style containing only selected layers.
+ *
+ * @param {Record<string, unknown>} style
+ * @param {string[]} selectedLayers
+ * @returns {Record<string, unknown>}
+ */
+export function filterStyleLayers(style, selectedLayers = SUPPORTED_LAYERS) {
+  const selected = new Set(selectedLayers);
+  const layers = style.layers && typeof style.layers === 'object'
+    ? /** @type {Record<string, unknown>} */ (style.layers)
+    : {};
+  const drawOrder = Array.isArray(style.drawOrder)
+    ? style.drawOrder.map(String).filter((layer) => selected.has(layer))
+    : Object.keys(layers).filter((layer) => selected.has(layer));
+
+  /** @type {Record<string, unknown>} */
+  const filteredLayers = {};
+  for (const layer of drawOrder) {
+    if (layers[layer]) {
+      filteredLayers[layer] = layers[layer];
+    }
+  }
+
+  return {
+    ...structuredClone(style),
+    drawOrder,
+    layers: filteredLayers
+  };
+}

package/src/style-themes.js

@@ -0,0 +1,235 @@
+import { readFileSync, readdirSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { SUPPORTED_LAYERS } from './layers.js';
+import { filterStyleLayers, readStylePreset } from './style-presets.js';
+
+export const THEMES_DIR = join(dirname(fileURLToPath(import.meta.url)), '..', 'styles', 'themes');
+const THEME_NAME_PATTERN = /^[a-z0-9-]+$/;
+const COLOR_PATCHES = {
+  background: [{ path: ['background'] }],
+  roads: [
+    { path: ['layers', 'roads', 'stroke'] },
+    { path: ['layers', 'roads', 'body', 'color'] }
+  ],
+  roadsMajor: [
+    { path: ['layers', 'roads', 'byProperty', 'highway', 'motorway', 'stroke'] },
+    { path: ['layers', 'roads', 'byProperty', 'highway', 'motorway', 'body', 'color'] },
+    { path: ['layers', 'roads', 'byProperty', 'highway', 'trunk', 'stroke'] },
+    { path: ['layers', 'roads', 'byProperty', 'highway', 'trunk', 'body', 'color'] },
+    { path: ['layers', 'roads', 'byProperty', 'highway', 'primary', 'stroke'] },
+    { path: ['layers', 'roads', 'byProperty', 'highway', 'primary', 'body', 'color'] }
+  ],
+  roadsCasing: [
+    { path: ['layers', 'roads', 'casing', 'color'] },
+    { path: ['layers', 'roads', 'byProperty', 'highway', 'motorway', 'casing', 'color'] },
+    { path: ['layers', 'roads', 'byProperty', 'highway', 'trunk', 'casing', 'color'] },
+    { path: ['layers', 'roads', 'byProperty', 'highway', 'primary', 'casing', 'color'] }
+  ],
+  buildings: [
+    { path: ['layers', 'buildings', 'stroke'] },
+    { path: ['layers', 'buildings', 'body', 'color'] },
+    { path: ['layers', 'buildings', 'glow', 'color'] }
+  ],
+  water: [
+    { path: ['layers', 'water', 'stroke'] },
+    { path: ['layers', 'water', 'body', 'color'] },
+    { path: ['layers', 'water', 'glow', 'color'] }
+  ],
+  landuse: [
+    { path: ['layers', 'landuse', 'stroke'] },
+    { path: ['layers', 'landuse', 'body', 'color'] },
+    { path: ['layers', 'landuse', 'glow', 'color'] }
+  ],
+  labels: [
+    { path: ['labels', 'roads', 'fill'] },
+    { path: ['labels', 'aip', 'fill'] },
+    { path: ['labels', 'pois', 'fill'] },
+    { path: ['labels', 'priorityClasses', 'important', 'fill'] },
+    { path: ['labels', 'priorityClasses', 'normal', 'fill'] }
+  ],
+  critical: [
+    { path: ['labels', 'priorityClasses', 'critical', 'fill'] }
+  ]
+};
+const INTENSITY_PATCHES = {
+  roads: [
+    ['layers', 'roads', 'strokeOpacity'],
+    ['layers', 'roads', 'body', 'opacity']
+  ],
+  buildings: [
+    ['layers', 'buildings', 'strokeOpacity'],
+    ['layers', 'buildings', 'body', 'opacity'],
+    ['layers', 'buildings', 'glow', 'opacity']
+  ],
+  labels: [
+    ['labels', 'roads', 'opacity'],
+    ['labels', 'aip', 'opacity'],
+    ['labels', 'pois', 'opacity'],
+    ['labels', 'priorityClasses', 'important', 'opacity'],
+    ['labels', 'priorityClasses', 'normal', 'opacity']
+  ]
+};
+
+/**
+ * @typedef {{
+ *   name?: string,
+ *   base?: string,
+ *   colors?: Record<string, string>,
+ *   intensity?: Record<string, number>,
+ *   overrides?: Record<string, unknown>
+ * }} StyleTheme
+ */
+
+/**
+ * List bundled compact style themes.
+ *
+ * @returns {string[]}
+ */
+export function listStyleThemes() {
+  return readdirSync(THEMES_DIR)
+    .filter((file) => file.endsWith('.theme.json'))
+    .map((file) => file.slice(0, -'.theme.json'.length))
+    .sort();
+}
+
+/**
+ * Read a bundled theme name or a local theme JSON file.
+ *
+ * @param {string} theme
+ * @returns {StyleTheme}
+ */
+export function readStyleTheme(theme) {
+  const filePath = theme.endsWith('.json') || theme.includes('/') || theme.includes('\\')
+    ? resolve(theme)
+    : bundledThemePath(theme);
+  const document = JSON.parse(readFileSync(filePath, 'utf8'));
+  validateTheme(document, theme);
+  return /** @type {StyleTheme} */ (document);
+}
+
+/**
+ * Expand a compact theme into a full map-zero style document.
+ *
+ * @param {StyleTheme | string} theme
+ * @param {string[]} selectedLayers
+ * @returns {Record<string, unknown>}
+ */
+export function createStyleFromTheme(theme, selectedLayers = SUPPORTED_LAYERS) {
+  const themeDocument = typeof theme === 'string' ? readStyleTheme(theme) : theme;
+  validateTheme(themeDocument, themeDocument.name ?? 'theme');
+  const base = readStylePreset(themeDocument.base ?? 'neon-dark');
+  const style = structuredClone(base);
+  style.name = themeDocument.name ?? base.name ?? 'theme';
+
+  applyThemeColors(style, themeDocument.colors ?? {});
+  applyThemeIntensity(style, themeDocument.intensity ?? {});
+  if (themeDocument.overrides && typeof themeDocument.overrides === 'object') {
+    mergeObject(style, themeDocument.overrides);
+  }
+
+  return filterStyleLayers(style, selectedLayers);
+}
+
+/**
+ * @param {string} themeName
+ * @returns {string}
+ */
+function bundledThemePath(themeName) {
+  if (!THEME_NAME_PATTERN.test(themeName)) {
+    throw new Error(`invalid style theme name: ${themeName}`);
+  }
+
+  return join(THEMES_DIR, `${themeName}.theme.json`);
+}
+
+/**
+ * @param {unknown} value
+ * @param {string} source
+ */
+function validateTheme(value, source) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    throw new Error(`style theme must be a JSON object: ${source}`);
+  }
+}
+
+/**
+ * @param {Record<string, unknown>} style
+ * @param {Record<string, string>} colors
+ */
+function applyThemeColors(style, colors) {
+  for (const [key, color] of Object.entries(colors)) {
+    if (typeof color !== 'string') {
+      continue;
+    }
+
+    for (const patch of COLOR_PATCHES[key] ?? []) {
+      setPathIfPresent(style, patch.path, color);
+    }
+  }
+}
+
+/**
+ * @param {Record<string, unknown>} style
+ * @param {Record<string, number>} intensity
+ */
+function applyThemeIntensity(style, intensity) {
+  for (const [key, value] of Object.entries(intensity)) {
+    const numeric = Number(value);
+    if (!Number.isFinite(numeric)) {
+      continue;
+    }
+
+    const opacity = Math.max(0, Math.min(1, numeric));
+    for (const path of INTENSITY_PATCHES[key] ?? []) {
+      setPathIfPresent(style, path, opacity);
+    }
+  }
+}
+
+/**
+ * @param {Record<string, unknown>} target
+ * @param {string[]} path
+ * @param {unknown} value
+ */
+function setPathIfPresent(target, path, value) {
+  let current = /** @type {Record<string, unknown> | undefined} */ (target);
+  for (const segment of path.slice(0, -1)) {
+    const next = current?.[segment];
+    if (!next || typeof next !== 'object' || Array.isArray(next)) {
+      return;
+    }
+    current = /** @type {Record<string, unknown>} */ (next);
+  }
+
+  const key = path.at(-1);
+  if (current && key && Object.hasOwn(current, key)) {
+    current[key] = value;
+  }
+}
+
+/**
+ * @param {Record<string, unknown>} target
+ * @param {Record<string, unknown>} source
+ */
+function mergeObject(target, source) {
+  for (const [key, value] of Object.entries(source)) {
+    if (isPlainObject(value) && isPlainObject(target[key])) {
+      mergeObject(
+        /** @type {Record<string, unknown>} */ (target[key]),
+        /** @type {Record<string, unknown>} */ (value)
+      );
+    } else {
+      target[key] = structuredClone(value);
+    }
+  }
+}
+
+/**
+ * @param {unknown} value
+ * @returns {value is Record<string, unknown>}
+ */
+function isPlainObject(value) {
+  return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}

package/src/style.js

@@ -0,0 +1,13 @@
+export {
+  createNeonDarkStyle,
+  createStyleFromPreset,
+  filterStyleLayers,
+  listStylePresets,
+  readStylePreset
+} from './style-presets.js';
+
+export {
+  createStyleFromTheme,
+  listStyleThemes,
+  readStyleTheme
+} from './style-themes.js';

package/src/tile-cache.js

@@ -0,0 +1,59 @@
+/**
+ * Small in-memory LRU cache for generated MVT tiles.
+ */
+export class TileCache {
+  /**
+   * @param {number} maxEntries
+   */
+  constructor(maxEntries) {
+    this.maxEntries = Math.max(0, Math.floor(maxEntries));
+    /** @type {Map<string, unknown>} */
+    this.entries = new Map();
+  }
+
+  /**
+   * @param {string} key
+   * @returns {unknown | undefined}
+   */
+  get(key) {
+    if (this.maxEntries <= 0) {
+      return undefined;
+    }
+
+    const value = this.entries.get(key);
+    if (value === undefined) {
+      return undefined;
+    }
+
+    this.entries.delete(key);
+    this.entries.set(key, value);
+    return value;
+  }
+
+  /**
+   * @param {string} key
+   * @param {unknown} value
+   */
+  set(key, value) {
+    if (this.maxEntries <= 0) {
+      return;
+    }
+
+    if (this.entries.has(key)) {
+      this.entries.delete(key);
+    }
+
+    this.entries.set(key, value);
+    while (this.entries.size > this.maxEntries) {
+      const oldest = this.entries.keys().next().value;
+      if (oldest === undefined) {
+        break;
+      }
+      this.entries.delete(oldest);
+    }
+  }
+
+  clear() {
+    this.entries.clear();
+  }
+}