@mapbox/mapbox-gl-style-spec 14.27.0 → 14.28.0-alpha.fa7f708fbcc

package/validate_mapbox_api_supported.ts

@@ -87,7 +87,7 @@ function getSourcesErrors(sources: SourcesSpecification): {
     errors: Array<ValidationError>;
     sourcesCount: number;
 } {
-    const errors = [];
+    const errors: ValidationError[] = [];
     let sourcesCount = 0;
 
     Object.keys(sources).forEach((s: string, i: number) => {
@@ -101,7 +101,6 @@ function getSourcesErrors(sources: SourcesSpecification): {
         errors.push(...sourceErrors);
     });
 
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
     return {errors, sourcesCount};
 }
 

package/expression/definitions/in.ts

@@ -1,86 +0,0 @@
-import {
-    BooleanType,
-    StringType,
-    ValueType,
-    NullType,
-    toString,
-    NumberType,
-    isValidType,
-    isValidNativeType,
-} from '../types';
-import RuntimeError from '../runtime_error';
-import {typeOf} from '../values';
-
-import type {Expression, SerializedExpression} from '../expression';
-import type ParsingContext from '../parsing_context';
-import type EvaluationContext from '../evaluation_context';
-import type {Type} from '../types';
-
-class In implements Expression {
-    type: Type;
-    needle: Expression;
-    haystack: Expression;
-
-    constructor(needle: Expression, haystack: Expression) {
-        this.type = BooleanType;
-        this.needle = needle;
-        this.haystack = haystack;
-    }
-
-    static parse(args: ReadonlyArray<unknown>, context: ParsingContext): In | null | undefined {
-        if (args.length !== 3) {
-            context.error(`Expected 2 arguments, but found ${args.length - 1} instead.`);
-            return null;
-        }
-
-        const needle = context.parse(args[1], 1, ValueType);
-
-        const haystack = context.parse(args[2], 2, ValueType);
-
-        if (!needle || !haystack) return null;
-
-        if (!isValidType(needle.type, [BooleanType, StringType, NumberType, NullType, ValueType])) {
-            context.error(`Expected first argument to be of type boolean, string, number or null, but found ${toString(needle.type)} instead`);
-            return null;
-        }
-
-        return new In(needle, haystack);
-    }
-
-    evaluate(ctx: EvaluationContext): boolean {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-        const needle = (this.needle.evaluate(ctx));
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-        const haystack = (this.haystack.evaluate(ctx));
-
-        if (haystack == null) return false;
-
-        if (!isValidNativeType(needle, ['boolean', 'string', 'number', 'null'])) {
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-            throw new RuntimeError(`Expected first argument to be of type boolean, string, number or null, but found ${toString(typeOf(needle))} instead.`);
-        }
-
-        if (!isValidNativeType(haystack, ['string', 'array'])) {
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-            throw new RuntimeError(`Expected second argument to be of type array or string, but found ${toString(typeOf(haystack))} instead.`);
-        }
-
-        // Type assertions safe due to isValidNativeType checks above
-        return (haystack as string | unknown[]).includes(needle as string);
-    }
-
-    eachChild(fn: (_: Expression) => void) {
-        fn(this.needle);
-        fn(this.haystack);
-    }
-
-    outputDefined(): boolean {
-        return true;
-    }
-
-    serialize(): SerializedExpression {
-        return ["in", this.needle.serialize(), this.haystack.serialize()];
-    }
-}
-
-export default In;

package/expression/definitions/index_of.ts

@@ -1,104 +0,0 @@
-import {
-    BooleanType,
-    StringType,
-    ValueType,
-    NullType,
-    toString,
-    NumberType,
-    isValidType,
-    isValidNativeType,
-} from '../types';
-import RuntimeError from '../runtime_error';
-import {typeOf} from '../values';
-
-import type {Expression, SerializedExpression} from '../expression';
-import type ParsingContext from '../parsing_context';
-import type EvaluationContext from '../evaluation_context';
-import type {Type} from '../types';
-
-class IndexOf implements Expression {
-    type: Type;
-    needle: Expression;
-    haystack: Expression;
-    fromIndex: Expression | null | undefined;
-
-    constructor(needle: Expression, haystack: Expression, fromIndex?: Expression) {
-        this.type = NumberType;
-        this.needle = needle;
-        this.haystack = haystack;
-        this.fromIndex = fromIndex;
-    }
-
-    static parse(args: ReadonlyArray<unknown>, context: ParsingContext): IndexOf | null | undefined {
-        if (args.length <= 2 ||  args.length >= 5) {
-            context.error(`Expected 3 or 4 arguments, but found ${args.length - 1} instead.`);
-            return null;
-        }
-
-        const needle = context.parse(args[1], 1, ValueType);
-
-        const haystack = context.parse(args[2], 2, ValueType);
-
-        if (!needle || !haystack) return null;
-        if (!isValidType(needle.type, [BooleanType, StringType, NumberType, NullType, ValueType])) {
-            context.error(`Expected first argument to be of type boolean, string, number or null, but found ${toString(needle.type)} instead`);
-            return null;
-        }
-
-        if (args.length === 4) {
-            const fromIndex = context.parse(args[3], 3, NumberType);
-            if (!fromIndex) return null;
-            return new IndexOf(needle, haystack, fromIndex);
-        } else {
-            return new IndexOf(needle, haystack);
-        }
-    }
-
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    evaluate(ctx: EvaluationContext): any {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-        const needle = (this.needle.evaluate(ctx));
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-        const haystack = (this.haystack.evaluate(ctx));
-
-        if (!isValidNativeType(needle, ['boolean', 'string', 'number', 'null'])) {
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-            throw new RuntimeError(`Expected first argument to be of type boolean, string, number or null, but found ${toString(typeOf(needle))} instead.`);
-        }
-
-        if (!isValidNativeType(haystack, ['string', 'array'])) {
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-            throw new RuntimeError(`Expected second argument to be of type array or string, but found ${toString(typeOf(haystack))} instead.`);
-        }
-
-        // Type assertions safe due to isValidNativeType checks above
-        if (this.fromIndex) {
-            const fromIndex = (this.fromIndex.evaluate(ctx) as number);
-            return (haystack as string | unknown[]).indexOf(needle as string, fromIndex);
-        }
-
-        return (haystack as string | unknown[]).indexOf(needle as string);
-    }
-
-    eachChild(fn: (_: Expression) => void) {
-        fn(this.needle);
-        fn(this.haystack);
-        if (this.fromIndex) {
-            fn(this.fromIndex);
-        }
-    }
-
-    outputDefined(): boolean {
-        return false;
-    }
-
-    serialize(): SerializedExpression {
-        if (this.fromIndex != null && this.fromIndex !== undefined) {
-            const fromIndex = this.fromIndex.serialize();
-            return ["index-of", this.needle.serialize(), this.haystack.serialize(), fromIndex];
-        }
-        return ["index-of", this.needle.serialize(), this.haystack.serialize()];
-    }
-}
-
-export default IndexOf;

package/expression/definitions/split.ts

@@ -1,56 +0,0 @@
-import {
-    StringType,
-    array,
-} from '../types';
-
-import type {Expression, SerializedExpression} from '../expression';
-import type ParsingContext from '../parsing_context';
-import type EvaluationContext from '../evaluation_context';
-import type {Type} from '../types';
-
-class Split implements Expression {
-    type: Type;
-    str: Expression;
-    delimiter: Expression;
-
-    constructor(str: Expression, delimiter: Expression) {
-        this.type = array(StringType);
-        this.str = str;
-        this.delimiter = delimiter;
-    }
-
-    static parse(args: ReadonlyArray<unknown>, context: ParsingContext): Split | void {
-        if (args.length !== 3) {
-            return context.error(`Expected 2 arguments, but found ${args.length - 1} instead.`);
-        }
-
-        const str = context.parse(args[1], 1, StringType);
-        const delimiter = context.parse(args[2], 2, StringType);
-
-        if (!str || !delimiter) return;
-
-        return new Split(str, delimiter);
-    }
-
-    evaluate(ctx: EvaluationContext): string[] {
-        const str = (this.str.evaluate(ctx) as string);
-        const delimiter = (this.delimiter.evaluate(ctx) as string);
-
-        return str.split(delimiter);
-    }
-
-    eachChild(fn: (_: Expression) => void) {
-        fn(this.str);
-        fn(this.delimiter);
-    }
-
-    outputDefined(): boolean {
-        return false;
-    }
-
-    serialize(): SerializedExpression {
-        return ["split", this.str.serialize(), this.delimiter.serialize()];
-    }
-}
-
-export default Split;