ts-maps 0.2.7 → 0.3.0

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

@@ -0,0 +1,14 @@
+export declare function registerInterpolateOps(): void;
+declare type Interp = {
+  kind: 'linear'
+} | {
+  kind: 'exponential'
+  base: number
+} | {
+  kind: 'cubic-bezier'
+  bezier: (u: number) => number
+}
+// Pick the blender for a given return type. For types we don't know how to
+// interpolate (strings, booleans, resolved images) we fall back to stepping —
+// the spec says this is the required behaviour.
+declare type Blender = (_a: unknown, _b: unknown, _t: number) => unknown;

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,29 @@
+import type { CompiledExpression, ExpressionType } from './types';
+// `ExpressionType` is used in the `OperatorCompiler` signature below — export
+// so consumers can satisfy the shape without reaching into `./types` directly.
+export type { ExpressionType };
+export declare function registerOperator(name: string, fn: OperatorCompiler): void;
+export declare function getOperator(name: string): OperatorCompiler | undefined;
+export declare function hasOperator(name: string): boolean;
+// Introspection for validators — walkers that need to know whether a head
+// token is a known operator (vs. an arbitrary data literal).
+export declare function listOperators(): string[];
+// A compiler callback — operators call this to compile their child arguments.
+// `expected` is the type the child should produce; 'value' means anything.
+export type CompileFn = (
+  expr: unknown,
+  expected: ExpressionType,
+  path: (string | number)[],
+) => CompiledExpression;
+// An operator's compile-time function: given the raw expression array and a
+// recursive compiler, return a CompiledExpression. The operator owns arity
+// checking and argument compilation; the central compiler does not look at
+// the shape of individual operator arguments. `expected` is the type the
+// enclosing context wants back — used by `interpolate`/`step` to decide how
+// their child branches should be compiled.
+export type OperatorCompiler = (
+  args: unknown[],
+  compile: CompileFn,
+  path: (string | number)[],
+  expected: ExpressionType,
+) => CompiledExpression;

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

@@ -0,0 +1,48 @@
+// Everything the evaluator needs to resolve an expression against a feature
+// at a given zoom level. `feature` and `featureState` are optional because
+// zoom-only expressions don't need them; we use that fact downstream to
+// decide whether a compiled expression can be cached across features.
+export declare interface EvaluationContext {
+  zoom: number
+  feature?: {
+    type: 1 | 2 | 3
+    id?: number | string
+    properties: Record<string, unknown>
+  }
+  featureState?: Record<string, unknown>
+  lineProgress?: number
+  globalProperties?: {
+    bearing?: number
+    pitch?: number
+    zoom: number
+  }
+}
+// A compiled expression: a closure plus metadata the renderer uses to decide
+// whether it needs to re-evaluate on zoom change, on feature change, or on
+// feature-state change. Every flag starts false and ORs upward as children
+// propagate their dependencies.
+export declare interface CompiledExpression {
+  evaluate: (ctx: EvaluationContext) => unknown
+  returnType: ExpressionType
+  dependsOnZoom: boolean
+  dependsOnFeature: boolean
+  dependsOnFeatureState: boolean
+}
+// Internal types for the expression evaluator. These are kept separate from
+// the public style-spec types to keep the surface area small — callers should
+// import from `./index` rather than reaching in here directly.
+// The set of runtime types an expression can return. `value` is the catch-all
+// used when a position accepts anything; the evaluator will still validate
+// against the expected type of the enclosing property.
+export type ExpressionType = | 'string'
+    | 'number'
+    | 'boolean'
+    | 'color'
+    | 'array'
+    | 'null'
+    | 'formatted'
+    | 'resolvedImage'
+    | 'value';
+// A parsed RGBA color in [0..1] space. Stored as a plain tuple to keep the
+// evaluator allocation-lean in hot loops — no wrapper objects.
+export type RGBA = [number, number, number, number];

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

@@ -0,0 +1,13 @@
+import type { ExpressionType } from './types';
+/**
+ * Quick predicate: does this value look like an expression? Used by the
+ * style-spec validator to decide whether to hand off to us or to match
+ * literal-shape rules.
+ */
+export declare function isExpression(value: unknown): boolean;
+/**
+ * Validate an expression statically. Returns an array of error messages;
+ * empty array means valid. Non-array inputs are accepted unconditionally
+ * here — literal shape checking belongs to the caller's schema pass.
+ */
+export declare function validateExpression(value: unknown, expectedType: ExpressionType): string[];

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

@@ -0,0 +1,68 @@
+export type { StyleDiff, StyleDiffCommand } from './diff';
+export type {
+  CompiledExpression,
+  EvaluationContext,
+  ExpressionType,
+  RGBA,
+} from './expressions/index';
+export type { PropertySchema, PropertySchemaType } from './schema';
+export type {
+  BackgroundLayerSpecification,
+  BackgroundLayoutSpecification,
+  BackgroundPaintSpecification,
+  CircleLayerSpecification,
+  CircleLayoutSpecification,
+  CirclePaintSpecification,
+  ColorSpecification,
+  ExpressionSpecification,
+  FillLayerSpecification,
+  FillLayoutSpecification,
+  FillPaintSpecification,
+  FilterSpecification,
+  FormattedSpecification,
+  GeoJSONSourceSpecification,
+  LayerSpecification,
+  LayerType,
+  LightSpecification,
+  LineLayerSpecification,
+  LineLayoutSpecification,
+  LinePaintSpecification,
+  PaddingSpecification,
+  PromoteIdSpecification,
+  PropertyValueSpecification,
+  RasterDEMSourceSpecification,
+  RasterLayerSpecification,
+  RasterLayoutSpecification,
+  RasterPaintSpecification,
+  RasterSourceSpecification,
+  ResolvedImageSpecification,
+  SourceSpecification,
+  SpriteSource,
+  Style,
+  SymbolLayerSpecification,
+  SymbolLayoutSpecification,
+  SymbolPaintSpecification,
+  TransitionSpecification,
+  VectorSourceSpecification,
+} from './types';
+export type { ValidationError } from './validate';
+export { diffStyles } from './diff';
+export {
+  compile as compileExpression,
+  convertLegacyFilter,
+  evaluate as evaluateExpression,
+  ExpressionError,
+  formatColor,
+  isExpression,
+  lerpColor,
+  parseColor,
+  validateExpression,
+} from './expressions/index';
+export { layerTypes, layoutPropertySchemas, paintPropertySchemas, sourceTypes } from './schema';
+export {
+  validateLayer,
+  validateLayoutProperty,
+  validatePaintProperty,
+  validateSource,
+  validateStyle,
+} from './validate';