@honua/react 0.0.20-alpha.0

package/runtime/style-interactions.js

@@ -0,0 +1,574 @@
+/**
+ * Mapbox-style runtime helpers for source/layer mutation, expression
+ * diagnostics, and source-qualified feature interaction targets.
+ *
+ * The types in this file intentionally stay structural instead of importing
+ * MapLibre GL JS declarations. App code can use common source, layer, paint,
+ * layout, filter, and interaction helpers without coupling to a specific
+ * renderer package version.
+ *
+ * @module
+ */
+import { sourceFeatureSelectionTarget } from "../exploration/selection.js";
+import { Expr } from "../expr/index.js";
+import { isHonuaSource } from "../style/specification.js";
+import { validateRuntimeFilterStyleSpecSync, validateRuntimeLayerStyleSpecSync, validateRuntimeSourceStyleSpecSync, validateRuntimeStyleExpressionStyleSpecSync, } from "./style-spec-validation.js";
+export class HonuaRuntimeDiagnosticError extends Error {
+    diagnostics;
+    cause;
+    constructor(message, diagnostics, cause) {
+        super(message);
+        this.name = "HonuaRuntimeDiagnosticError";
+        this.diagnostics = diagnostics;
+        this.cause = cause;
+    }
+}
+const EXPRESSION_OPERATORS = {
+    "!": { minArgs: 1, maxArgs: 1 },
+    "!=": { minArgs: 2, maxArgs: 3 },
+    "<": { minArgs: 2, maxArgs: 3 },
+    "<=": { minArgs: 2, maxArgs: 3 },
+    "==": { minArgs: 2, maxArgs: 3 },
+    ">": { minArgs: 2, maxArgs: 3 },
+    ">=": { minArgs: 2, maxArgs: 3 },
+    "-": { minArgs: 1, maxArgs: 2 },
+    "+": { minArgs: 2 },
+    "*": { minArgs: 2 },
+    "/": { minArgs: 2, maxArgs: 2 },
+    "%": { minArgs: 2, maxArgs: 2 },
+    "^": { minArgs: 2, maxArgs: 2 },
+    abs: { minArgs: 1, maxArgs: 1 },
+    accumulated: { minArgs: 0, maxArgs: 0 },
+    acos: { minArgs: 1, maxArgs: 1 },
+    all: { minArgs: 1 },
+    any: { minArgs: 1 },
+    array: { minArgs: 1 },
+    asin: { minArgs: 1, maxArgs: 1 },
+    at: { minArgs: 2, maxArgs: 2 },
+    atan: { minArgs: 1, maxArgs: 1 },
+    boolean: { minArgs: 1 },
+    case: { custom: validateCaseExpression },
+    ceil: { minArgs: 1, maxArgs: 1 },
+    coalesce: { minArgs: 1 },
+    collator: { minArgs: 0, maxArgs: 1 },
+    concat: { minArgs: 1 },
+    cos: { minArgs: 1, maxArgs: 1 },
+    "cubic-bezier": { minArgs: 4, maxArgs: 4 },
+    "distance-from-center": { minArgs: 0, maxArgs: 0 },
+    downcase: { minArgs: 1, maxArgs: 1 },
+    distance: { minArgs: 1, maxArgs: 1 },
+    e: { minArgs: 0, maxArgs: 0 },
+    "feature-state": { minArgs: 1, maxArgs: 1 },
+    floor: { minArgs: 1, maxArgs: 1 },
+    format: { minArgs: 1 },
+    geometry: { minArgs: 0, maxArgs: 0 },
+    "geometry-type": { minArgs: 0, maxArgs: 0 },
+    get: { minArgs: 1, maxArgs: 2 },
+    has: { minArgs: 1, maxArgs: 2 },
+    "heatmap-density": { minArgs: 0, maxArgs: 0 },
+    hsl: { minArgs: 3, maxArgs: 3 },
+    hsla: { minArgs: 4, maxArgs: 4 },
+    id: { minArgs: 0, maxArgs: 0 },
+    image: { minArgs: 1, maxArgs: 1 },
+    in: { minArgs: 2, maxArgs: 2 },
+    index: { minArgs: 0, maxArgs: 0 },
+    "index-of": { minArgs: 2, maxArgs: 3 },
+    interpolate: { custom: validateInterpolateExpression },
+    "interpolate-hcl": { custom: validateInterpolateExpression },
+    "interpolate-lab": { custom: validateInterpolateExpression },
+    intersects: { minArgs: 1, maxArgs: 1 },
+    length: { minArgs: 1, maxArgs: 1 },
+    let: { minArgs: 3 },
+    "line-progress": { minArgs: 0, maxArgs: 0 },
+    literal: { minArgs: 1, maxArgs: 1 },
+    ln: { minArgs: 1, maxArgs: 1 },
+    ln2: { minArgs: 0, maxArgs: 0 },
+    log10: { minArgs: 1, maxArgs: 1 },
+    log2: { minArgs: 1, maxArgs: 1 },
+    match: { custom: validateMatchExpression },
+    max: { minArgs: 1 },
+    min: { minArgs: 1 },
+    "number-format": { minArgs: 1, maxArgs: 2 },
+    number: { minArgs: 1 },
+    object: { minArgs: 1 },
+    pi: { minArgs: 0, maxArgs: 0 },
+    pitch: { minArgs: 0, maxArgs: 0 },
+    properties: { minArgs: 0, maxArgs: 0 },
+    "resolved-locale": { minArgs: 1, maxArgs: 1 },
+    resolvedLocale: { minArgs: 1, maxArgs: 1 },
+    rgb: { minArgs: 3, maxArgs: 3 },
+    rgba: { minArgs: 4, maxArgs: 4 },
+    round: { minArgs: 1, maxArgs: 1 },
+    sin: { minArgs: 1, maxArgs: 1 },
+    slice: { minArgs: 2, maxArgs: 3 },
+    sqrt: { minArgs: 1, maxArgs: 1 },
+    step: { custom: validateStepExpression },
+    string: { minArgs: 1 },
+    tan: { minArgs: 1, maxArgs: 1 },
+    "to-boolean": { minArgs: 1, maxArgs: 1 },
+    "to-color": { minArgs: 1 },
+    "to-number": { minArgs: 1 },
+    "to-rgba": { minArgs: 1, maxArgs: 1 },
+    "to-string": { minArgs: 1, maxArgs: 1 },
+    typeof: { minArgs: 1, maxArgs: 1 },
+    upcase: { minArgs: 1, maxArgs: 1 },
+    var: { minArgs: 1, maxArgs: 1 },
+    within: { minArgs: 1, maxArgs: 1 },
+    zoom: { minArgs: 0, maxArgs: 0 },
+};
+export function materializeRuntimeSource(source) {
+    return materializeStyleValue(source);
+}
+export function materializeRuntimeLayer(layer) {
+    return materializeStyleValue(layer);
+}
+export function materializeStyleValue(value) {
+    if (value instanceof Expr) {
+        return value.toJSON();
+    }
+    if (Array.isArray(value)) {
+        return value.map((entry) => materializeStyleValue(entry));
+    }
+    if (isPlainObject(value)) {
+        const result = {};
+        for (const [key, entry] of Object.entries(value)) {
+            result[key] = materializeStyleValue(entry);
+        }
+        return result;
+    }
+    return value;
+}
+export function validateRuntimeSource(sourceId, source, context = {}) {
+    const diagnostics = [];
+    const sourceContext = sourceDiagnosticContext(sourceId, source, context);
+    if (!sourceId.trim()) {
+        diagnostics.push({
+            code: "source-id-empty",
+            severity: "error",
+            message: "Source id must be a non-empty string.",
+            path: "sourceId",
+            ...sourceContext,
+        });
+    }
+    if (!isPlainObject(source)) {
+        diagnostics.push({
+            code: "source-invalid",
+            severity: "error",
+            message: "Source specification must be a non-null object.",
+            path: `sources.${sourceId}`,
+            ...sourceContext,
+        });
+        return diagnostics;
+    }
+    if (typeof source.type !== "string" || source.type.trim().length === 0) {
+        diagnostics.push({
+            code: "source-type-invalid",
+            severity: "error",
+            message: "Source specification must include a non-empty string type.",
+            path: `sources.${sourceId}.type`,
+            ...sourceContext,
+        });
+    }
+    if (isHonuaSource(source) && typeof source.url !== "string") {
+        diagnostics.push({
+            code: "source-url-missing",
+            severity: "error",
+            message: "Honua source specifications require a string url.",
+            path: `sources.${sourceId}.url`,
+            ...sourceContext,
+        });
+    }
+    diagnostics.push(...validateRuntimeSourceStyleSpecSync(sourceId, source, {
+        mode: context.styleSpecValidationMode,
+        path: `sources.${sourceId}`,
+        ...sourceContext,
+    }));
+    return diagnostics;
+}
+export function validateRuntimeLayer(layer, context = {}) {
+    const materialized = materializeRuntimeLayer(layer);
+    const diagnostics = [];
+    const sourceId = materialized.source;
+    const sourceContext = layerDiagnosticContext(materialized.id, sourceId, context);
+    if (typeof materialized.id !== "string" || materialized.id.trim().length === 0) {
+        diagnostics.push({
+            code: "layer-id-invalid",
+            severity: "error",
+            message: "Layer specification must include a non-empty string id.",
+            path: "layers[].id",
+            ...sourceContext,
+        });
+    }
+    if (typeof materialized.type !== "string" || materialized.type.trim().length === 0) {
+        diagnostics.push({
+            code: "layer-type-invalid",
+            severity: "error",
+            message: "Layer specification must include a non-empty string type.",
+            path: `layers.${materialized.id}.type`,
+            ...sourceContext,
+        });
+    }
+    if (sourceId && context.style && !Object.hasOwn(context.style.sources, sourceId)) {
+        diagnostics.push({
+            code: "layer-source-missing",
+            severity: "error",
+            message: `Layer "${materialized.id}" references missing source "${sourceId}".`,
+            path: `layers.${materialized.id}.source`,
+            ...sourceContext,
+        });
+    }
+    if (materialized.paint !== undefined && !isPlainObject(materialized.paint)) {
+        diagnostics.push({
+            code: "layer-paint-invalid",
+            severity: "error",
+            message: "Layer paint must be an object when provided.",
+            path: `layers.${materialized.id}.paint`,
+            ...sourceContext,
+        });
+    }
+    else {
+        for (const [property, value] of Object.entries(materialized.paint ?? {})) {
+            diagnostics.push(...validateRuntimeStyleExpression(value, {
+                kind: "style",
+                path: `layers.${materialized.id}.paint.${property}`,
+                ...sourceContext,
+            }));
+        }
+    }
+    if (materialized.layout !== undefined && !isPlainObject(materialized.layout)) {
+        diagnostics.push({
+            code: "layer-layout-invalid",
+            severity: "error",
+            message: "Layer layout must be an object when provided.",
+            path: `layers.${materialized.id}.layout`,
+            ...sourceContext,
+        });
+    }
+    else {
+        for (const [property, value] of Object.entries(materialized.layout ?? {})) {
+            diagnostics.push(...validateRuntimeStyleExpression(value, {
+                kind: "style",
+                path: `layers.${materialized.id}.layout.${property}`,
+                ...sourceContext,
+            }));
+        }
+    }
+    if (materialized.filter !== undefined) {
+        diagnostics.push(...validateRuntimeFilterExpression(materialized.filter, {
+            path: `layers.${materialized.id}.filter`,
+            ...sourceContext,
+        }));
+    }
+    diagnostics.push(...validateRuntimeLayerStyleSpecSync(materialized, {
+        mode: context.styleSpecValidationMode,
+        style: context.style,
+        path: `layers.${materialized.id}`,
+        ...sourceContext,
+    }));
+    return diagnostics;
+}
+export function validateRuntimeStyleExpression(value, options = {}) {
+    const materialized = materializeStyleValue(value);
+    if (!Array.isArray(materialized)) {
+        return [];
+    }
+    if (!looksLikeExpressionArray(materialized)) {
+        return options.requireExpression
+            ? [
+                diagnostic("expression-operator-invalid", "Expression arrays must start with an operator string.", {
+                    ...options,
+                }),
+            ]
+            : [];
+    }
+    return [
+        ...validateExpressionArray(materialized, options),
+        ...validateRuntimeStyleExpressionStyleSpecSync(materialized, styleSpecOptions(options)),
+    ];
+}
+export function validateRuntimeFilterExpression(filter, options = {}) {
+    const materialized = materializeStyleValue(filter);
+    if (!Array.isArray(materialized)) {
+        return [
+            diagnostic("filter-invalid", "Layer filter must be a MapLibre expression array.", {
+                kind: "filter",
+                requireExpression: true,
+                ...options,
+            }),
+        ];
+    }
+    const expressionOptions = {
+        kind: "filter",
+        requireExpression: true,
+        ...options,
+    };
+    return [
+        ...validateRuntimeStyleExpression(materialized, expressionOptions),
+        ...validateRuntimeFilterStyleSpecSync(materialized, styleSpecOptions(expressionOptions)),
+    ];
+}
+export function throwRuntimeDiagnostics(diagnostics, message = "Runtime style diagnostics failed.") {
+    const errors = diagnostics.filter((entry) => entry.severity === "error");
+    if (errors.length > 0) {
+        throw new HonuaRuntimeDiagnosticError(message, errors);
+    }
+}
+export function rendererRuntimeDiagnosticError(message, diagnostic, cause) {
+    return new HonuaRuntimeDiagnosticError(message, [
+        {
+            severity: "error",
+            ...diagnostic,
+        },
+    ], cause);
+}
+export function resolveRuntimeBeforeId(style, order, movingLayerId) {
+    const diagnostics = [];
+    const orderedLayers = style.layers.filter((layer) => layer.id !== movingLayerId);
+    if (order === undefined) {
+        return { beforeId: undefined, diagnostics };
+    }
+    if (typeof order === "string") {
+        if (order && !orderedLayers.some((layer) => layer.id === order)) {
+            diagnostics.push({
+                code: "layer-order-before-missing",
+                severity: "error",
+                message: `Cannot insert before missing layer "${order}".`,
+                layerId: movingLayerId,
+                path: "beforeId",
+            });
+        }
+        return { beforeId: order || undefined, diagnostics };
+    }
+    const requested = [order.beforeId, order.afterId, order.position].filter((value) => value !== undefined);
+    if (requested.length > 1) {
+        diagnostics.push({
+            code: "layer-order-conflict",
+            severity: "error",
+            message: "Specify only one of beforeId, afterId, or position.",
+            layerId: movingLayerId,
+            path: "order",
+        });
+        return { beforeId: undefined, diagnostics };
+    }
+    if (order.beforeId !== undefined) {
+        if (!orderedLayers.some((layer) => layer.id === order.beforeId)) {
+            diagnostics.push({
+                code: "layer-order-before-missing",
+                severity: "error",
+                message: `Cannot insert before missing layer "${order.beforeId}".`,
+                layerId: movingLayerId,
+                path: "order.beforeId",
+            });
+        }
+        return { beforeId: order.beforeId, diagnostics };
+    }
+    if (order.afterId !== undefined) {
+        const index = orderedLayers.findIndex((layer) => layer.id === order.afterId);
+        if (index === -1) {
+            diagnostics.push({
+                code: "layer-order-after-missing",
+                severity: "error",
+                message: `Cannot insert after missing layer "${order.afterId}".`,
+                layerId: movingLayerId,
+                path: "order.afterId",
+            });
+            return { beforeId: undefined, diagnostics };
+        }
+        return { beforeId: orderedLayers[index + 1]?.id, diagnostics };
+    }
+    if (order.position === "bottom") {
+        return { beforeId: orderedLayers[0]?.id, diagnostics };
+    }
+    return { beforeId: undefined, diagnostics };
+}
+export function sourceContextForLayer(style, mapPackage, layerId) {
+    const layer = style.layers.find((entry) => entry.id === layerId);
+    if (!layer?.source)
+        return undefined;
+    return {
+        sourceId: layer.source,
+        sourceLayer: layer["source-layer"],
+        protocol: protocolForSource(style, mapPackage, layer.source),
+    };
+}
+export function featureTargetForLayer(style, layerId, id) {
+    const layer = style.layers.find((entry) => entry.id === layerId);
+    if (!layer?.source)
+        return undefined;
+    return {
+        source: layer.source,
+        id,
+        ...(layer["source-layer"] !== undefined ? { sourceLayer: layer["source-layer"] } : {}),
+    };
+}
+export function selectionTargetForLayer(style, layerId, id) {
+    const target = featureTargetForLayer(style, layerId, id);
+    if (!target)
+        return undefined;
+    return sourceFeatureSelectionTarget(target.source, target.id, { sourceLayer: target.sourceLayer });
+}
+export function featureStateTargetFromSelection(target) {
+    return {
+        source: target.sourceId,
+        id: target.id,
+        ...(target.sourceLayer !== undefined ? { sourceLayer: target.sourceLayer } : {}),
+    };
+}
+export function featureStateTargetKey(target) {
+    return `${target.source}\u0000${target.sourceLayer ?? ""}\u0000${typeof target.id}:${String(target.id)}`;
+}
+export function protocolForSource(style, mapPackage, sourceId) {
+    if (!sourceId)
+        return undefined;
+    const bindingProtocol = mapPackage?.sourceBindings.find((binding) => binding.sourceId === sourceId)?.protocol;
+    if (bindingProtocol)
+        return bindingProtocol;
+    const source = style.sources[sourceId];
+    return typeof source?.type === "string" ? source.type : undefined;
+}
+export function resolveFeatureIdFromEventFeature(feature, event, options = {}) {
+    const explicit = options.resolveFeatureId?.(feature, event);
+    if (explicit !== undefined)
+        return explicit;
+    if (isPlainObject(feature)) {
+        const directId = feature.id;
+        if (typeof directId === "string" || typeof directId === "number")
+            return directId;
+        if (options.featureIdProperty && isPlainObject(feature.properties)) {
+            const propertyId = feature.properties[options.featureIdProperty];
+            if (typeof propertyId === "string" || typeof propertyId === "number")
+                return propertyId;
+        }
+    }
+    return undefined;
+}
+function validateExpressionArray(expr, options) {
+    const diagnostics = [];
+    if (expr.length === 0) {
+        return [diagnostic("expression-empty", "Expression array must not be empty.", options)];
+    }
+    const operator = expr[0];
+    if (typeof operator !== "string") {
+        return [
+            diagnostic("expression-operator-invalid", "Expression arrays must start with an operator string.", options),
+        ];
+    }
+    const rule = EXPRESSION_OPERATORS[operator];
+    if (!rule) {
+        diagnostics.push(diagnostic("expression-operator-unknown", `Expression operator "${operator}" is not recognized by Honua's built-in validator.`, {
+            ...options,
+            strictUnknownOperators: options.strictUnknownOperators,
+            context: { operator },
+        }, options.strictUnknownOperators ? "error" : "warning"));
+    }
+    else {
+        const argCount = expr.length - 1;
+        if (rule.minArgs !== undefined && argCount < rule.minArgs) {
+            diagnostics.push(diagnostic("expression-arity-too-small", `Expression operator "${operator}" expects at least ${rule.minArgs} argument(s), received ${argCount}.`, { ...options, context: { operator, expected: rule.minArgs, received: argCount } }));
+        }
+        if (rule.maxArgs !== undefined && argCount > rule.maxArgs) {
+            diagnostics.push(diagnostic("expression-arity-too-large", `Expression operator "${operator}" expects at most ${rule.maxArgs} argument(s), received ${argCount}.`, { ...options, context: { operator, expected: rule.maxArgs, received: argCount } }));
+        }
+        diagnostics.push(...(rule.custom?.(expr, options) ?? []));
+    }
+    if (operator === "literal") {
+        return diagnostics;
+    }
+    for (let i = 1; i < expr.length; i++) {
+        const entry = expr[i];
+        if (Array.isArray(entry) && looksLikeExpressionArray(entry)) {
+            diagnostics.push(...validateExpressionArray(entry, {
+                ...options,
+                path: pathWithIndex(options.path, i),
+            }));
+        }
+    }
+    return diagnostics;
+}
+function validateCaseExpression(expr, options) {
+    const argCount = expr.length - 1;
+    if (argCount < 3 || argCount % 2 === 0) {
+        return [
+            diagnostic("expression-case-invalid", 'The "case" expression requires condition/output pairs followed by a fallback value.', { ...options, context: { operator: "case", received: argCount } }),
+        ];
+    }
+    return [];
+}
+function validateMatchExpression(expr, options) {
+    const argCount = expr.length - 1;
+    if (argCount < 4 || argCount % 2 !== 0) {
+        return [
+            diagnostic("expression-match-invalid", 'The "match" expression requires an input, label/output pairs, and a fallback value.', { ...options, context: { operator: "match", received: argCount } }),
+        ];
+    }
+    return [];
+}
+function validateStepExpression(expr, options) {
+    const argCount = expr.length - 1;
+    if (argCount < 4 || argCount % 2 !== 0) {
+        return [
+            diagnostic("expression-step-invalid", 'The "step" expression requires an input, base output, and stop/output pairs.', { ...options, context: { operator: "step", received: argCount } }),
+        ];
+    }
+    return [];
+}
+function validateInterpolateExpression(expr, options) {
+    if (expr.length < 7 || (expr.length - 3) % 2 !== 0) {
+        return [
+            diagnostic("expression-interpolate-invalid", 'The "interpolate" expression requires an interpolation mode, input, and stop/output pairs.', { ...options, context: { operator: String(expr[0]), received: expr.length - 1 } }),
+        ];
+    }
+    return [];
+}
+function sourceDiagnosticContext(sourceId, source, context) {
+    const protocol = source?.type ?? protocolForSource(context.style ?? emptyStyle(), context.mapPackage, sourceId);
+    return {
+        sourceId,
+        ...(protocol ? { protocol } : {}),
+        ...(context.operation ? { context: { operation: context.operation } } : {}),
+    };
+}
+function layerDiagnosticContext(layerId, sourceId, context) {
+    return {
+        ...(sourceId ? { sourceId } : {}),
+        ...(layerId ? { layerId } : {}),
+        ...(protocolForSource(context.style ?? emptyStyle(), context.mapPackage, sourceId) !== undefined
+            ? { protocol: protocolForSource(context.style ?? emptyStyle(), context.mapPackage, sourceId) }
+            : {}),
+        ...(context.operation ? { context: { operation: context.operation } } : {}),
+    };
+}
+function diagnostic(code, message, options, severity = "error") {
+    return {
+        code,
+        severity,
+        message,
+        ...(options.path ? { path: options.path } : {}),
+        ...(options.sourceId ? { sourceId: options.sourceId } : {}),
+        ...(options.layerId ? { layerId: options.layerId } : {}),
+        ...(options.protocol ? { protocol: options.protocol } : {}),
+        ...(options.context ? { context: options.context } : {}),
+    };
+}
+function styleSpecOptions(options) {
+    return {
+        mode: options.styleSpecValidationMode,
+        path: options.path,
+        sourceId: options.sourceId,
+        layerId: options.layerId,
+        protocol: options.protocol,
+        context: options.context,
+    };
+}
+function looksLikeExpressionArray(value) {
+    return value.length > 0 && typeof value[0] === "string";
+}
+function pathWithIndex(path, index) {
+    return path ? `${path}[${index}]` : `[${index}]`;
+}
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function emptyStyle() {
+    return { version: 8, sources: {}, layers: [] };
+}

package/runtime/style-spec-validation.d.ts

@@ -0,0 +1,23 @@
+import type { HonuaLayerSpecification, HonuaStyleSpecification } from "../style/specification.js";
+import type { HonuaRuntimeDiagnostic } from "./style-interactions.js";
+export type RuntimeStyleSpecValidationMode = "strict" | "warning-only" | "renderer-deferred";
+export interface RuntimeStyleSpecValidationOptions {
+    readonly mode?: RuntimeStyleSpecValidationMode;
+    readonly style?: HonuaStyleSpecification;
+    readonly path?: string;
+    readonly sourceId?: string;
+    readonly layerId?: string;
+    readonly protocol?: string;
+    readonly context?: Readonly<Record<string, unknown>>;
+}
+export declare function prepareRuntimeStyleSpecValidation(mode?: RuntimeStyleSpecValidationMode): Promise<HonuaRuntimeDiagnostic[]>;
+export declare function validateRuntimeStyleSpec(style: HonuaStyleSpecification, options?: RuntimeStyleSpecValidationOptions): Promise<HonuaRuntimeDiagnostic[]>;
+export declare function validateRuntimeSourceStyleSpec(sourceId: string, source: unknown, options?: RuntimeStyleSpecValidationOptions): Promise<HonuaRuntimeDiagnostic[]>;
+export declare function validateRuntimeLayerStyleSpec(layer: HonuaLayerSpecification, options?: RuntimeStyleSpecValidationOptions): Promise<HonuaRuntimeDiagnostic[]>;
+export declare function validateRuntimeStyleExpressionStyleSpec(value: unknown, options?: RuntimeStyleSpecValidationOptions): Promise<HonuaRuntimeDiagnostic[]>;
+export declare function validateRuntimeFilterStyleSpec(filter: unknown, options?: RuntimeStyleSpecValidationOptions): Promise<HonuaRuntimeDiagnostic[]>;
+export declare function validateRuntimeSourceStyleSpecSync(sourceId: string, source: unknown, options?: RuntimeStyleSpecValidationOptions): HonuaRuntimeDiagnostic[];
+export declare function validateRuntimeLayerStyleSpecSync(layer: HonuaLayerSpecification, options?: RuntimeStyleSpecValidationOptions): HonuaRuntimeDiagnostic[];
+export declare function validateRuntimeStyleExpressionStyleSpecSync(value: unknown, options?: RuntimeStyleSpecValidationOptions): HonuaRuntimeDiagnostic[];
+export declare function validateRuntimeFilterStyleSpecSync(filter: unknown, options?: RuntimeStyleSpecValidationOptions): HonuaRuntimeDiagnostic[];
+//# sourceMappingURL=style-spec-validation.d.ts.map

package/runtime/style-spec-validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"style-spec-validation.d.ts","sourceRoot":"","sources":["../../../src/runtime/style-spec-validation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,uBAAuB,EAAE,MAAM,2BAA2B,CAAC;AAClG,OAAO,KAAK,EAAE,sBAAsB,EAAkC,MAAM,yBAAyB,CAAC;AAEtG,MAAM,MAAM,8BAA8B,GAAG,QAAQ,GAAG,cAAc,GAAG,mBAAmB,CAAC;AAE7F,MAAM,WAAW,iCAAiC;IAChD,QAAQ,CAAC,IAAI,CAAC,EAAE,8BAA8B,CAAC;IAC/C,QAAQ,CAAC,KAAK,CAAC,EAAE,uBAAuB,CAAC;IACzC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,OAAO,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;CACtD;AA0BD,wBAAsB,iCAAiC,CACrD,IAAI,GAAE,8BAAyC,GAC9C,OAAO,CAAC,sBAAsB,EAAE,CAAC,CAKnC;AAED,wBAAsB,wBAAwB,CAC5C,KAAK,EAAE,uBAAuB,EAC9B,OAAO,GAAE,iCAAsC,GAC9C,OAAO,CAAC,sBAAsB,EAAE,CAAC,CAMnC;AAED,wBAAsB,8BAA8B,CAClD,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,OAAO,EACf,OAAO,GAAE,iCAAsC,GAC9C,OAAO,CAAC,sBAAsB,EAAE,CAAC,CAiBnC;AAED,wBAAsB,6BAA6B,CACjD,KAAK,EAAE,uBAAuB,EAC9B,OAAO,GAAE,iCAAsC,GAC9C,OAAO,CAAC,sBAAsB,EAAE,CAAC,CA0BnC;AAED,wBAAsB,uCAAuC,CAC3D,KAAK,EAAE,OAAO,EACd,OAAO,GAAE,iCAAsC,GAC9C,OAAO,CAAC,sBAAsB,EAAE,CAAC,CAMnC;AAED,wBAAsB,8BAA8B,CAClD,MAAM,EAAE,OAAO,EACf,OAAO,GAAE,iCAAsC,GAC9C,OAAO,CAAC,sBAAsB,EAAE,CAAC,CAUnC;AAED,wBAAgB,kCAAkC,CAChD,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,OAAO,EACf,OAAO,GAAE,iCAAsC,GAC9C,sBAAsB,EAAE,CAc1B;AAED,wBAAgB,iCAAiC,CAC/C,KAAK,EAAE,uBAAuB,EAC9B,OAAO,GAAE,iCAAsC,GAC9C,sBAAsB,EAAE,CAuB1B;AAED,wBAAgB,2CAA2C,CACzD,KAAK,EAAE,OAAO,EACd,OAAO,GAAE,iCAAsC,GAC9C,sBAAsB,EAAE,CAK1B;AAED,wBAAgB,kCAAkC,CAChD,MAAM,EAAE,OAAO,EACf,OAAO,GAAE,iCAAsC,GAC9C,sBAAsB,EAAE,CAS1B"}