ts-maps 0.2.7 → 0.3.0

package/dist/core-map/services/providers/Google.d.ts

@@ -0,0 +1,16 @@
+import type { DirectionsOptions, DirectionsProvider, GeocoderOptions, GeocoderProvider, GeocodingResult, LatLngLike, Route } from '../types';
+export declare interface GoogleOptions {
+  apiKey: string
+  baseUrl?: string
+}
+export declare class GoogleGeocoder implements GeocoderProvider {
+  name: string;
+  constructor(opts: GoogleOptions);
+  search(query: string, opts?: GeocoderOptions): Promise<GeocodingResult[]>;
+  reverse(center: LatLngLike, opts?: GeocoderOptions): Promise<GeocodingResult[]>;
+}
+export declare class GoogleDirections implements DirectionsProvider {
+  name: string;
+  constructor(opts: GoogleOptions);
+  getDirections(waypoints: LatLngLike[], opts?: DirectionsOptions): Promise<Route[]>;
+}

package/dist/core-map/services/providers/Mapbox.d.ts

@@ -0,0 +1,26 @@
+import type { DirectionsOptions, DirectionsProvider, GeocoderOptions, GeocoderProvider, GeocodingResult, IsochroneOptions, IsochronePolygon, IsochroneProvider, LatLngLike, MatrixOptions, MatrixProvider, MatrixResult, Route } from '../types';
+export declare interface MapboxOptions {
+  accessToken: string
+  baseUrl?: string
+}
+export declare class MapboxGeocoder implements GeocoderProvider {
+  name: string;
+  constructor(opts: MapboxOptions);
+  search(query: string, opts?: GeocoderOptions): Promise<GeocodingResult[]>;
+  reverse(center: LatLngLike, opts?: GeocoderOptions): Promise<GeocodingResult[]>;
+}
+export declare class MapboxDirections implements DirectionsProvider {
+  name: string;
+  constructor(opts: MapboxOptions);
+  getDirections(waypoints: LatLngLike[], opts?: DirectionsOptions): Promise<Route[]>;
+}
+export declare class MapboxIsochrone implements IsochroneProvider {
+  name: string;
+  constructor(opts: MapboxOptions);
+  getIsochrones(center: LatLngLike, opts: IsochroneOptions): Promise<IsochronePolygon[]>;
+}
+export declare class MapboxMatrix implements MatrixProvider {
+  name: string;
+  constructor(opts: MapboxOptions);
+  getMatrix(origins: LatLngLike[], destinations: LatLngLike[], opts?: MatrixOptions): Promise<MatrixResult>;
+}

package/dist/core-map/services/providers/Maptiler.d.ts

@@ -0,0 +1,11 @@
+import type { GeocoderOptions, GeocoderProvider, GeocodingResult, LatLngLike } from '../types';
+export declare interface MaptilerOptions {
+  apiKey: string
+  baseUrl?: string
+}
+export declare class MaptilerGeocoder implements GeocoderProvider {
+  name: string;
+  constructor(opts: MaptilerOptions);
+  search(query: string, opts?: GeocoderOptions): Promise<GeocodingResult[]>;
+  reverse(center: LatLngLike, opts?: GeocoderOptions): Promise<GeocodingResult[]>;
+}

package/dist/core-map/services/providers/Nominatim.d.ts

@@ -0,0 +1,11 @@
+import type { GeocoderOptions, GeocoderProvider, GeocodingResult, LatLngLike } from '../types';
+export declare interface NominatimOptions {
+  baseUrl?: string
+  userAgent?: string
+}
+export declare class NominatimGeocoder implements GeocoderProvider {
+  name: string;
+  constructor(opts?: NominatimOptions);
+  search(query: string, opts?: GeocoderOptions): Promise<GeocodingResult[]>;
+  reverse(center: LatLngLike, opts?: GeocoderOptions): Promise<GeocodingResult[]>;
+}

package/dist/core-map/services/providers/OSRM.d.ts

@@ -0,0 +1,20 @@
+import type { DirectionsOptions, DirectionsProvider, LatLngLike, MatrixOptions, MatrixProvider, MatrixResult, Route } from '../types';
+export declare interface OSRMOptions {
+  baseUrl?: string
+}
+export declare class OSRMDirections implements DirectionsProvider {
+  name: string;
+  constructor(opts?: OSRMOptions);
+  getDirections(waypoints: LatLngLike[], opts?: DirectionsOptions): Promise<Route[]>;
+}
+/**
+ * OSRM `/table` matrix — keyless default travel-time / distance matrix.
+ *
+ * Shares a baseUrl with `OSRMDirections`; point it at a self-hosted OSRM
+ * instance for production traffic.
+ */
+export declare class OSRMMatrix implements MatrixProvider {
+  name: string;
+  constructor(opts?: OSRMOptions);
+  getMatrix(origins: LatLngLike[], destinations: LatLngLike[], opts?: MatrixOptions): Promise<MatrixResult>;
+}

package/dist/core-map/services/providers/Photon.d.ts

@@ -0,0 +1,10 @@
+import type { GeocoderOptions, GeocoderProvider, GeocodingResult, LatLngLike } from '../types';
+export declare interface PhotonOptions {
+  baseUrl?: string
+}
+export declare class PhotonGeocoder implements GeocoderProvider {
+  name: string;
+  constructor(opts?: PhotonOptions);
+  search(query: string, opts?: GeocoderOptions): Promise<GeocodingResult[]>;
+  reverse(center: LatLngLike, opts?: GeocoderOptions): Promise<GeocodingResult[]>;
+}

package/dist/core-map/services/providers/Valhalla.d.ts

@@ -0,0 +1,20 @@
+import type { DirectionsOptions, DirectionsProvider, IsochroneOptions, IsochronePolygon, IsochroneProvider, LatLngLike, MatrixOptions, MatrixProvider, MatrixResult, Route } from '../types';
+export declare interface ValhallaOptions {
+  baseUrl?: string
+  apiKey?: string
+}
+export declare class ValhallaDirections implements DirectionsProvider {
+  name: string;
+  constructor(opts?: ValhallaOptions);
+  getDirections(waypoints: LatLngLike[], opts?: DirectionsOptions): Promise<Route[]>;
+}
+export declare class ValhallaIsochrone implements IsochroneProvider {
+  name: string;
+  constructor(opts?: ValhallaOptions);
+  getIsochrones(center: LatLngLike, opts: IsochroneOptions): Promise<IsochronePolygon[]>;
+}
+export declare class ValhallaMatrix implements MatrixProvider {
+  name: string;
+  constructor(opts?: ValhallaOptions);
+  getMatrix(origins: LatLngLike[], destinations: LatLngLike[], opts?: MatrixOptions): Promise<MatrixResult>;
+}

package/dist/core-map/services/types.d.ts

@@ -0,0 +1,84 @@
+// Provider-interface layer for geocoding, directions, isochrone, and matrix
+// services. Consumers program against these interfaces; providers are
+// implemented separately so upstream backends can be swapped without touching
+// map code.
+export declare interface LatLngLike {
+  lat: number
+  lng: number
+}
+export declare interface GeocodingResult {
+  text: string
+  center: LatLngLike
+  bbox?: [number, number, number, number]
+  placeType?: 'country' | 'region' | 'district' | 'postcode' | 'place' | 'address' | 'poi'
+  properties?: Record<string, unknown>
+  relevance?: number
+}
+export declare interface GeocoderOptions {
+  limit?: number
+  language?: string
+  proximity?: LatLngLike
+  bbox?: [number, number, number, number]
+  countries?: string[]
+  signal?: AbortSignal
+}
+export declare interface GeocoderProvider {
+  name: string
+  search: (query: string, opts?: GeocoderOptions) => Promise<GeocodingResult[]>
+  reverse: (center: LatLngLike, opts?: GeocoderOptions) => Promise<GeocodingResult[]>
+}
+export declare interface RouteStep {
+  distance: number
+  duration: number
+  instruction: string
+  geometry: LatLngLike[]
+  maneuver?: string
+}
+export declare interface Route {
+  distance: number
+  duration: number
+  geometry: LatLngLike[]
+  steps: RouteStep[]
+  legs?: Route[]
+}
+export declare interface DirectionsOptions {
+  profile?: TransportProfile
+  alternatives?: boolean
+  signal?: AbortSignal
+  language?: string
+}
+export declare interface DirectionsProvider {
+  name: string
+  getDirections: (waypoints: LatLngLike[], opts?: DirectionsOptions) => Promise<Route[]>
+}
+export declare interface IsochroneOptions {
+  profile?: TransportProfile
+  contours: number[]
+  contourMetric?: 'time' | 'distance'
+  denoise?: number
+  generalize?: number
+  signal?: AbortSignal
+}
+export declare interface IsochronePolygon {
+  geometry: LatLngLike[]
+  holes?: LatLngLike[][]
+  contour: number
+}
+export declare interface IsochroneProvider {
+  name: string
+  getIsochrones: (center: LatLngLike, opts: IsochroneOptions) => Promise<IsochronePolygon[]>
+}
+export declare interface MatrixOptions {
+  profile?: TransportProfile
+  metric?: 'time' | 'distance'
+  signal?: AbortSignal
+}
+export declare interface MatrixResult {
+  durations?: number[][]
+  distances?: number[][]
+}
+export declare interface MatrixProvider {
+  name: string
+  getMatrix: (origins: LatLngLike[], destinations: LatLngLike[], opts?: MatrixOptions) => Promise<MatrixResult>
+}
+export type TransportProfile = 'driving' | 'walking' | 'cycling';

package/dist/core-map/storage/TileCache.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Async key-value store for tile bytes, with TTL + LRU pruning. The default
+ * backend is in-memory; callers may inject their own (e.g. an IndexedDB-backed
+ * one in browsers) via the `backend` option.
+ */
+export declare interface Tile {
+  key: string
+  data: Uint8Array
+  mime: string
+  bytes: number
+  addedAt: number
+}
+export declare interface TileCacheBackend {
+  get: (key: string) => Promise<Tile | undefined>
+  put: (tile: Tile) => Promise<void>
+  delete: (key: string) => Promise<void>
+  clear: () => Promise<void>
+  all: () => Promise<Tile[]>
+  close?: () => void | Promise<void>
+}
+export declare interface TileCacheOptions {
+  ttlMs?: number
+  maxEntries?: number
+  maxBytes?: number
+  backend?: TileCacheBackend
+}
+export declare interface TileCacheSize {
+  entries: number
+  bytes: number
+}
+export declare class TileCache {
+  constructor(options?: TileCacheOptions);
+  get(key: string): Promise<Tile | undefined>;
+  put(key: string, data: Uint8Array, mime: string): Promise<void>;
+  delete(key: string): Promise<void>;
+  clear(): Promise<void>;
+  size(): Promise<TileCacheSize>;
+  prune(): Promise<void>;
+  close(): Promise<void>;
+}

package/dist/core-map/storage/cachedFetch.d.ts

@@ -0,0 +1,13 @@
+import type { TileCache } from './TileCache';
+export declare function cachedFetch(url: string, options: CachedFetchOptions): Promise<CachedFetchResult>;
+export declare interface CachedFetchOptions {
+  cache: TileCache
+  signal?: AbortSignal
+  noStore?: boolean
+  forceNetwork?: boolean
+}
+export declare interface CachedFetchResult {
+  data: Uint8Array
+  mime: string
+  fromCache: boolean
+}

package/dist/core-map/storage/defaultCache.d.ts

@@ -0,0 +1,3 @@
+import { TileCache } from './TileCache';
+export declare function getDefaultCache(): TileCache;
+export declare function resetDefaultCache(): Promise<void>;

package/dist/core-map/storage/index.d.ts

@@ -0,0 +1,13 @@
+export type { CachedFetchOptions, CachedFetchResult } from './cachedFetch';
+// `Bounds` and `TileCoord` are re-used names in geo/geometry barrels — keep
+// them out of the storage re-export to avoid collisions in `core-map/index`.
+export type {
+  OfflineRegionOptions,
+  OfflineRegionResult,
+  ProgressEmitter,
+} from './offlineRegion';
+export type { Tile, TileCacheBackend, TileCacheOptions, TileCacheSize } from './TileCache';
+export { cachedFetch } from './cachedFetch';
+export { getDefaultCache, resetDefaultCache } from './defaultCache';
+export { computeTileCoords, saveOfflineRegion } from './offlineRegion';
+export { TileCache } from './TileCache';

package/dist/core-map/storage/index.js

@@ -0,0 +1,283 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// src/core-map/storage/cachedFetch.ts
+function abortError() {
+  const err = new Error("The operation was aborted.");
+  err.name = "AbortError";
+  return err;
+}
+async function cachedFetch(url, options) {
+  const { cache, signal, noStore, forceNetwork } = options;
+  if (signal?.aborted)
+    throw abortError();
+  if (!forceNetwork) {
+    const cached = await cache.get(url);
+    if (cached) {
+      return { data: cached.data, mime: cached.mime, fromCache: true };
+    }
+  }
+  try {
+    const res = await fetch(url, { signal });
+    const buf = new Uint8Array(await res.arrayBuffer());
+    const mime = res.headers.get("content-type") ?? "application/octet-stream";
+    if (!noStore)
+      await cache.put(url, buf, mime);
+    return { data: buf, mime, fromCache: false };
+  } catch (err) {
+    if (signal?.aborted)
+      throw abortError();
+    const cached = await cache.get(url);
+    if (cached)
+      return { data: cached.data, mime: cached.mime, fromCache: true };
+    throw err;
+  }
+}
+
+// src/core-map/storage/TileCache.ts
+function createMemoryBackend() {
+  let store = new Map;
+  return {
+    get: async (key) => store.get(key),
+    put: async (tile) => {
+      store.set(tile.key, tile);
+    },
+    delete: async (key) => {
+      store.delete(key);
+    },
+    clear: async () => {
+      store.clear();
+    },
+    all: async () => [...store.values()],
+    close: () => {
+      store = new Map;
+    }
+  };
+}
+
+class TileCache {
+  _ttlMs;
+  _maxEntries;
+  _maxBytes;
+  _customBackend;
+  _backend;
+  constructor(options = {}) {
+    this._ttlMs = options.ttlMs ?? 0;
+    this._maxEntries = options.maxEntries ?? Number.POSITIVE_INFINITY;
+    this._maxBytes = options.maxBytes ?? Number.POSITIVE_INFINITY;
+    this._customBackend = options.backend;
+    this._backend = options.backend ?? createMemoryBackend();
+  }
+  async get(key) {
+    const tile = await this._backend.get(key);
+    if (!tile)
+      return;
+    if (this._isExpired(tile)) {
+      await this._backend.delete(key);
+      return;
+    }
+    return tile;
+  }
+  async put(key, data, mime) {
+    const tile = {
+      key,
+      data,
+      mime,
+      bytes: data.byteLength,
+      addedAt: Date.now()
+    };
+    await this._backend.put(tile);
+  }
+  async delete(key) {
+    await this._backend.delete(key);
+  }
+  async clear() {
+    await this._backend.clear();
+  }
+  async size() {
+    const all = await this._backend.all();
+    let bytes = 0;
+    for (const t of all)
+      bytes += t.bytes;
+    return { entries: all.length, bytes };
+  }
+  async prune() {
+    const all = await this._backend.all();
+    const live = [];
+    for (const t of all) {
+      if (this._isExpired(t))
+        await this._backend.delete(t.key);
+      else
+        live.push(t);
+    }
+    live.sort((a, b) => a.addedAt - b.addedAt);
+    let totalBytes = 0;
+    for (const t of live)
+      totalBytes += t.bytes;
+    let entries = live.length;
+    while (live.length > 0 && (entries > this._maxEntries || totalBytes > this._maxBytes)) {
+      const oldest = live.shift();
+      await this._backend.delete(oldest.key);
+      totalBytes -= oldest.bytes;
+      entries -= 1;
+    }
+  }
+  async close() {
+    if (this._backend.close)
+      await this._backend.close();
+    if (this._customBackend) {
+      this._backend = createMemoryBackend();
+    } else {
+      this._backend = createMemoryBackend();
+    }
+  }
+  _isExpired(tile) {
+    if (this._ttlMs <= 0)
+      return false;
+    return Date.now() - tile.addedAt > this._ttlMs;
+  }
+}
+
+// src/core-map/storage/defaultCache.ts
+function getDefaultCache() {
+  if (!_instance)
+    _instance = new TileCache;
+  return _instance;
+}
+async function resetDefaultCache() {
+  if (_instance) {
+    await _instance.close();
+    _instance = undefined;
+  }
+}
+var _instance;
+var init_defaultCache = () => {};
+
+// src/core-map/storage/offlineRegion.ts
+function normalizeBounds(b) {
+  if (Array.isArray(b))
+    return { west: b[0], south: b[1], east: b[2], north: b[3] };
+  return b;
+}
+function lonToTileX(lon, z) {
+  return Math.floor((lon + 180) / 360 * 2 ** z);
+}
+function latToTileY(lat, z) {
+  const rad = lat * Math.PI / 180;
+  return Math.floor((1 - Math.log(Math.tan(rad) + 1 / Math.cos(rad)) / Math.PI) / 2 * 2 ** z);
+}
+function clampTile(v, z) {
+  const max = 2 ** z - 1;
+  if (v < 0)
+    return 0;
+  if (v > max)
+    return max;
+  return v;
+}
+function computeTileCoords(bounds, zoomRange) {
+  const { west, south, east, north } = normalizeBounds(bounds);
+  const [zMin, zMax] = zoomRange;
+  const out = [];
+  for (let z = zMin;z <= zMax; z++) {
+    const x0 = clampTile(lonToTileX(Math.min(west, east), z), z);
+    const x1 = clampTile(lonToTileX(Math.max(west, east), z), z);
+    const y0 = clampTile(latToTileY(Math.max(south, north), z), z);
+    const y1 = clampTile(latToTileY(Math.min(south, north), z), z);
+    for (let x = x0;x <= x1; x++) {
+      for (let y = y0;y <= y1; y++) {
+        out.push({ x, y, z });
+      }
+    }
+  }
+  return out;
+}
+function fillTileUrl(tmpl, c) {
+  return tmpl.replace("{z}", String(c.z)).replace("{x}", String(c.x)).replace("{y}", String(c.y));
+}
+async function saveOfflineRegion(options, emitter) {
+  const cache = options.cache ?? getDefaultCache();
+  const concurrency = Math.max(1, options.concurrency ?? 4);
+  const coords = computeTileCoords(options.bounds, options.zoomRange);
+  const total = coords.length;
+  const result = { saved: 0, failed: 0, skipped: 0 };
+  let cursor = 0;
+  let completed = 0;
+  async function worker() {
+    while (cursor < coords.length) {
+      const idx = cursor++;
+      const c = coords[idx];
+      const url = fillTileUrl(options.tileUrl, c);
+      try {
+        const res = await cachedFetch(url, { cache, signal: options.signal });
+        if (res.fromCache)
+          result.skipped++;
+        else
+          result.saved++;
+      } catch {
+        result.failed++;
+      }
+      completed++;
+      emitter?.fire("offline:progress", { completed, total, coord: c });
+    }
+  }
+  const workers = [];
+  for (let i = 0;i < Math.min(concurrency, coords.length); i++)
+    workers.push(worker());
+  await Promise.all(workers);
+  return result;
+}
+var init_offlineRegion = __esm(() => {
+  init_defaultCache();
+});
+
+// src/core-map/storage/index.ts
+var init_storage = __esm(() => {
+  init_defaultCache();
+  init_offlineRegion();
+});
+init_storage();
+
+export {
+  saveOfflineRegion,
+  resetDefaultCache,
+  getDefaultCache,
+  computeTileCoords,
+  cachedFetch,
+  TileCache
+};

package/dist/core-map/storage/offlineRegion.d.ts

@@ -0,0 +1,26 @@
+import type { TileCache } from './TileCache';
+export declare function computeTileCoords(bounds: Bounds, zoomRange: readonly [number, number]): TileCoord[];
+export declare function saveOfflineRegion(options: OfflineRegionOptions, emitter?: ProgressEmitter): Promise<OfflineRegionResult>;
+export declare interface TileCoord {
+  x: number
+  y: number
+  z: number
+}
+export declare interface ProgressEmitter {
+  fire: (type: string, data?: Record<string, unknown>) => unknown
+}
+export declare interface OfflineRegionOptions {
+  bounds: Bounds
+  zoomRange: readonly [number, number]
+  tileUrl: string
+  cache?: TileCache
+  concurrency?: number
+  signal?: AbortSignal
+}
+export declare interface OfflineRegionResult {
+  saved: number
+  failed: number
+  skipped: number
+}
+export type Bounds = | { west: number, south: number, east: number, north: number }
+  | readonly [west: number, south: number, east: number, north: number];

package/dist/core-map/style-spec/diff.d.ts

@@ -0,0 +1,17 @@
+import type { LayerSpecification, LightSpecification, SourceSpecification, Style, TransitionSpecification } from './types';
+export declare function diffStyles(prev: Style, next: Style): StyleDiff;
+export declare interface StyleDiff {
+  commands: StyleDiffCommand[]
+}
+export type StyleDiffCommand = | { command: 'setStyle', args: [Style] }
+  | { command: 'addLayer', args: [LayerSpecification, string | undefined] }
+  | { command: 'removeLayer', args: [string] }
+  | { command: 'setLayoutProperty', args: [string, string, unknown] }
+  | { command: 'setPaintProperty', args: [string, string, unknown] }
+  | { command: 'setLayerZoomRange', args: [string, number | undefined, number | undefined] }
+  | { command: 'setFilter', args: [string, unknown] }
+  | { command: 'addSource', args: [string, SourceSpecification] }
+  | { command: 'removeSource', args: [string] }
+  | { command: 'setSourceData', args: [string, unknown] }
+  | { command: 'setTransition', args: [TransitionSpecification] }
+  | { command: 'setLight', args: [LightSpecification] }

package/dist/core-map/style-spec/expressions/Color.d.ts

@@ -0,0 +1,16 @@
+import type { RGBA } from './types';
+/**
+ * Parse a CSS color string into an RGBA tuple with float channels in [0..1].
+ * Returns null if the string can't be recognised — callers decide whether to
+ * treat that as an error or substitute a default.
+ */
+export declare function parseColor(css: string): RGBA | null;
+/**
+ * Linearly blend two RGBA tuples in straight sRGB. t is clamped to [0..1].
+ */
+export declare function lerpColor(a: RGBA, b: RGBA, t: number): RGBA;
+/**
+ * Render an RGBA tuple as a CSS `rgba(...)` string. Used mainly for diagnostic
+ * output and as the canonical wire form when handing colors to canvas.
+ */
+export declare function formatColor(c: RGBA): string;

package/dist/core-map/style-spec/expressions/compile.d.ts

@@ -0,0 +1,4 @@
+import type { CompiledExpression, ExpressionType } from './types';
+export declare function boot(): void;
+// The recursive compiler.
+export declare function compile(expr: unknown, expectedType?: ExpressionType, path?: (string | number)[]): CompiledExpression;

package/dist/core-map/style-spec/expressions/errors.d.ts

@@ -0,0 +1,8 @@
+// A small error class for expression compilation and evaluation failures.
+// Attaches the offending expression and the path through the AST so that
+// style authors can locate the problem without guessing.
+export declare class ExpressionError extends Error {
+  expression: unknown;
+  path: (string | number)[];
+  constructor(message: string, expression: unknown, path?: (string | number)[]);
+}

package/dist/core-map/style-spec/expressions/index.d.ts

@@ -0,0 +1,16 @@
+import { compile } from './compile';
+import { ExpressionError } from './errors';
+import { isExpression } from './validate';
+import type { CompiledExpression, EvaluationContext, ExpressionType } from './types';
+export type { CompiledExpression, EvaluationContext, ExpressionType, RGBA } from './types';
+/**
+ * Compile-and-run convenience for one-shot evaluation. Prefer `compile` +
+ * a long-lived `evaluate` closure on the render path — `evaluate` here
+ * recompiles every call and only makes sense for tests and diagnostics.
+ */
+export declare function evaluate(expr: unknown, ctx: EvaluationContext, expectedType?: ExpressionType): unknown;
+export { formatColor, lerpColor, parseColor } from './Color';
+export { compile } from './compile';
+export { ExpressionError } from './errors';
+export { convertLegacyFilter } from './legacyFilter';
+export { isExpression, validateExpression } from './validate';

package/dist/core-map/style-spec/expressions/legacyFilter.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Upgrade a legacy Mapbox filter to an equivalent expression-form filter.
+ * Already-upgraded filters pass through unchanged so callers can apply this
+ * blindly as a pre-pass.
+ */
+export declare function convertLegacyFilter(filter: unknown[]): unknown[];

package/dist/core-map/style-spec/expressions/operators/conversion.d.ts

@@ -0,0 +1 @@
+export declare function registerConversionOps(): void;