Initial commit
This commit is contained in:
237
node_modules/@maplibre/maplibre-gl-style-spec/src/expression/parsing_context.ts
generated
vendored
Normal file
237
node_modules/@maplibre/maplibre-gl-style-spec/src/expression/parsing_context.ts
generated
vendored
Normal file
@@ -0,0 +1,237 @@
|
||||
import {Scope} from './scope';
|
||||
import {checkSubtype} from './types';
|
||||
import {ExpressionParsingError} from './parsing_error';
|
||||
import {Literal} from './definitions/literal';
|
||||
import {Assertion} from './definitions/assertion';
|
||||
import {Coercion} from './definitions/coercion';
|
||||
import {EvaluationContext} from './evaluation_context';
|
||||
|
||||
import type {Expression, ExpressionRegistry} from './expression';
|
||||
import type {Type} from './types';
|
||||
|
||||
/**
|
||||
* State associated parsing at a given point in an expression tree.
|
||||
* @private
|
||||
*/
|
||||
export class ParsingContext {
|
||||
registry: ExpressionRegistry;
|
||||
path: Array<number>;
|
||||
key: string;
|
||||
scope: Scope;
|
||||
errors: Array<ExpressionParsingError>;
|
||||
|
||||
// The expected type of this expression. Provided only to allow Expression
|
||||
// implementations to infer argument types: Expression#parse() need not
|
||||
// check that the output type of the parsed expression matches
|
||||
// `expectedType`.
|
||||
expectedType: Type;
|
||||
|
||||
/**
|
||||
* Internal delegate to inConstant function to avoid circular dependency to CompoundExpression
|
||||
*/
|
||||
private _isConstant: (expression: Expression) => boolean;
|
||||
|
||||
constructor(
|
||||
registry: ExpressionRegistry,
|
||||
isConstantFunc: (expression: Expression) => boolean,
|
||||
path: Array<number> = [],
|
||||
expectedType?: Type | null,
|
||||
scope: Scope = new Scope(),
|
||||
errors: Array<ExpressionParsingError> = []
|
||||
) {
|
||||
this.registry = registry;
|
||||
this.path = path;
|
||||
this.key = path.map((part) => `[${part}]`).join('');
|
||||
this.scope = scope;
|
||||
this.errors = errors;
|
||||
this.expectedType = expectedType;
|
||||
this._isConstant = isConstantFunc;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param expr the JSON expression to parse
|
||||
* @param index the optional argument index if this expression is an argument of a parent expression that's being parsed
|
||||
* @param options
|
||||
* @param options.omitTypeAnnotations set true to omit inferred type annotations. Caller beware: with this option set, the parsed expression's type will NOT satisfy `expectedType` if it would normally be wrapped in an inferred annotation.
|
||||
* @private
|
||||
*/
|
||||
parse(
|
||||
expr: unknown,
|
||||
index?: number,
|
||||
expectedType?: Type | null,
|
||||
bindings?: Array<[string, Expression]>,
|
||||
options: {
|
||||
typeAnnotation?: 'assert' | 'coerce' | 'omit';
|
||||
} = {}
|
||||
): Expression {
|
||||
if (index) {
|
||||
return this.concat(index, expectedType, bindings)._parse(expr, options);
|
||||
}
|
||||
return this._parse(expr, options);
|
||||
}
|
||||
|
||||
_parse(
|
||||
expr: unknown,
|
||||
options: {
|
||||
typeAnnotation?: 'assert' | 'coerce' | 'omit';
|
||||
}
|
||||
): Expression {
|
||||
if (
|
||||
expr === null ||
|
||||
typeof expr === 'string' ||
|
||||
typeof expr === 'boolean' ||
|
||||
typeof expr === 'number'
|
||||
) {
|
||||
expr = ['literal', expr];
|
||||
}
|
||||
|
||||
function annotate(parsed, type, typeAnnotation: 'assert' | 'coerce' | 'omit') {
|
||||
if (typeAnnotation === 'assert') {
|
||||
return new Assertion(type, [parsed]);
|
||||
} else if (typeAnnotation === 'coerce') {
|
||||
return new Coercion(type, [parsed]);
|
||||
} else {
|
||||
return parsed;
|
||||
}
|
||||
}
|
||||
|
||||
if (Array.isArray(expr)) {
|
||||
if (expr.length === 0) {
|
||||
return this.error(
|
||||
'Expected an array with at least one element. If you wanted a literal array, use ["literal", []].'
|
||||
) as null;
|
||||
}
|
||||
|
||||
const op = expr[0];
|
||||
if (typeof op !== 'string') {
|
||||
this.error(
|
||||
`Expression name must be a string, but found ${typeof op} instead. If you wanted a literal array, use ["literal", [...]].`,
|
||||
0
|
||||
);
|
||||
return null;
|
||||
}
|
||||
|
||||
const Expr = this.registry[op];
|
||||
if (Expr) {
|
||||
let parsed = Expr.parse(expr, this);
|
||||
if (!parsed) return null;
|
||||
|
||||
if (this.expectedType) {
|
||||
const expected = this.expectedType;
|
||||
const actual = parsed.type;
|
||||
|
||||
// When we expect a number, string, boolean, or array but have a value, wrap it in an assertion.
|
||||
// When we expect a color or formatted string, but have a string or value, wrap it in a coercion.
|
||||
// Otherwise, we do static type-checking.
|
||||
//
|
||||
// These behaviors are overridable for:
|
||||
// * The "coalesce" operator, which needs to omit type annotations.
|
||||
// * String-valued properties (e.g. `text-field`), where coercion is more convenient than assertion.
|
||||
//
|
||||
if (
|
||||
(expected.kind === 'string' ||
|
||||
expected.kind === 'number' ||
|
||||
expected.kind === 'boolean' ||
|
||||
expected.kind === 'object' ||
|
||||
expected.kind === 'array') &&
|
||||
actual.kind === 'value'
|
||||
) {
|
||||
parsed = annotate(parsed, expected, options.typeAnnotation || 'assert');
|
||||
} else if (
|
||||
('projectionDefinition' === expected.kind &&
|
||||
['string', 'array'].includes(actual.kind)) ||
|
||||
(['color', 'formatted', 'resolvedImage'].includes(expected.kind) &&
|
||||
['value', 'string'].includes(actual.kind)) ||
|
||||
(['padding', 'numberArray'].includes(expected.kind) &&
|
||||
['value', 'number', 'array'].includes(actual.kind)) ||
|
||||
('colorArray' === expected.kind &&
|
||||
['value', 'string', 'array'].includes(actual.kind)) ||
|
||||
('variableAnchorOffsetCollection' === expected.kind &&
|
||||
['value', 'array'].includes(actual.kind))
|
||||
) {
|
||||
parsed = annotate(parsed, expected, options.typeAnnotation || 'coerce');
|
||||
} else if (this.checkSubtype(expected, actual)) {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
// If an expression's arguments are all literals, we can evaluate
|
||||
// it immediately and replace it with a literal value in the
|
||||
// parsed/compiled result. Expressions that expect an image should
|
||||
// not be resolved here so we can later get the available images.
|
||||
if (
|
||||
!(parsed instanceof Literal) &&
|
||||
parsed.type.kind !== 'resolvedImage' &&
|
||||
this._isConstant(parsed)
|
||||
) {
|
||||
const ec = new EvaluationContext();
|
||||
try {
|
||||
parsed = new Literal(parsed.type, parsed.evaluate(ec));
|
||||
} catch (e) {
|
||||
this.error(e.message);
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
return parsed;
|
||||
}
|
||||
|
||||
return this.error(
|
||||
`Unknown expression "${op}". If you wanted a literal array, use ["literal", [...]].`,
|
||||
0
|
||||
) as null;
|
||||
} else if (typeof expr === 'undefined') {
|
||||
return this.error("'undefined' value invalid. Use null instead.") as null;
|
||||
} else if (typeof expr === 'object') {
|
||||
return this.error('Bare objects invalid. Use ["literal", {...}] instead.') as null;
|
||||
} else {
|
||||
return this.error(`Expected an array, but found ${typeof expr} instead.`) as null;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns a copy of this context suitable for parsing the subexpression at
|
||||
* index `index`, optionally appending to 'let' binding map.
|
||||
*
|
||||
* Note that `errors` property, intended for collecting errors while
|
||||
* parsing, is copied by reference rather than cloned.
|
||||
* @private
|
||||
*/
|
||||
concat(index: number, expectedType?: Type | null, bindings?: Array<[string, Expression]>) {
|
||||
const path = typeof index === 'number' ? this.path.concat(index) : this.path;
|
||||
const scope = bindings ? this.scope.concat(bindings) : this.scope;
|
||||
return new ParsingContext(
|
||||
this.registry,
|
||||
this._isConstant,
|
||||
path,
|
||||
expectedType || null,
|
||||
scope,
|
||||
this.errors
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Push a parsing (or type checking) error into the `this.errors`
|
||||
* @param error The message
|
||||
* @param keys Optionally specify the source of the error at a child
|
||||
* of the current expression at `this.key`.
|
||||
* @private
|
||||
*/
|
||||
error(error: string, ...keys: Array<number>) {
|
||||
const key = `${this.key}${keys.map((k) => `[${k}]`).join('')}`;
|
||||
this.errors.push(new ExpressionParsingError(key, error));
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns null if `t` is a subtype of `expected`; otherwise returns an
|
||||
* error message and also pushes it to `this.errors`.
|
||||
* @param expected The expected type
|
||||
* @param t The actual type
|
||||
* @returns null if `t` is a subtype of `expected`; otherwise returns an error message
|
||||
*/
|
||||
checkSubtype(expected: Type, t: Type): string {
|
||||
const error = checkSubtype(expected, t);
|
||||
if (error) this.error(error);
|
||||
return error;
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user