Add length=2 for center (#1372)

* add center length

* add changelog

* add a testcase

* fix typo

* add an integration test

* remove dead code

Author: CommanderStorm

CHANGELOG.md

@@ -4,7 +4,8 @@
 - _...Add new stuff here..._
 
 ### 🐞 Bug fixes
-- _...Add new stuff here..._
+
+- The optional `center` property is now validated to be a `[lon,lat]` array ([#1372](https://github.com/maplibre/maplibre-gl-js/issues/1372))
 
 ## 24.3.1
 

src/index.test.ts

@@ -88,7 +88,6 @@ function validSchema(k, v, obj, ref, version, kind) {
         'expression',
         'property-type',
         'length',
-        'min-length',
         'required',
         'transition',
         'type',

src/reference/v8.json

@@ -28,6 +28,7 @@
     "center": {
       "type": "array",
       "value": "number",
+      "length": 2,
       "doc": "Default map center in longitude and latitude.  The style center will be used only if the map has not been positioned by other means (e.g. map options or user interaction).",
       "example": [
         -73.9749,

src/validate/validate_array.test.ts

@@ -0,0 +1,159 @@
+import {validate} from './validate';
+import {validateArray} from './validate_array';
+import v8 from '../reference/v8.json' with {type: 'json'};
+import {describe, test, expect} from 'vitest';
+
+describe('Validate Array', () => {
+    test('Should return error if type is not array', () => {
+        let errors = validateArray({
+            validateSpec: validate,
+            key: 'testArray',
+            value: '3',
+            valueSpec: {type: 'array', value: 'number'},
+            styleSpec: v8
+        });
+        expect(errors).toHaveLength(1);
+        expect(errors[0].message).toBe('testArray: array expected, string found');
+
+        errors = validateArray({
+            validateSpec: validate,
+            key: 'testArray',
+            value: true,
+            valueSpec: {type: 'array', value: 'number'},
+            styleSpec: v8
+        });
+        expect(errors).toHaveLength(1);
+        expect(errors[0].message).toBe('testArray: array expected, boolean found');
+
+        errors = validateArray({
+            validateSpec: validate,
+            key: 'testArray',
+            value: null,
+            valueSpec: {type: 'array', value: 'number'},
+            styleSpec: v8
+        });
+        expect(errors).toHaveLength(1);
+        expect(errors[0].message).toBe('testArray: array expected, null found');
+
+        errors = validateArray({
+            validateSpec: validate,
+            key: 'testArray',
+            value: {x: 1, y: 1},
+            valueSpec: {type: 'array', value: 'number'},
+            styleSpec: v8
+        });
+        expect(errors).toHaveLength(1);
+        expect(errors[0].message).toBe('testArray: array expected, object found');
+
+        errors = validateArray({
+            validateSpec: validate,
+            key: 'testArray',
+            value: 123,
+            valueSpec: {type: 'array', value: 'number'},
+            styleSpec: v8
+        });
+        expect(errors).toHaveLength(1);
+        expect(errors[0].message).toBe('testArray: array expected, number found');
+    });
+
+    test('Should return error if array length does not match spec', () => {
+        const errors = validateArray({
+            validateSpec: validate,
+            key: 'testArray',
+            value: [1, 2, 3],
+            valueSpec: {type: 'array', value: 'number', length: 2},
+            styleSpec: v8
+        });
+        expect(errors).toHaveLength(1);
+        expect(errors[0].message).toBe('testArray: array length 2 expected, length 3 found');
+    });
+
+    test('Should pass if array length matches spec', () => {
+        const errors = validateArray({
+            validateSpec: validate,
+            key: 'testArray',
+            value: [1, 2],
+            valueSpec: {type: 'array', value: 'number', length: 2},
+            styleSpec: v8
+        });
+        expect(errors).toHaveLength(0);
+    });
+
+    test('Should return error if array contains invalid element types', () => {
+        let errors = validateArray({
+            validateSpec: validate,
+            key: 'testArray',
+            value: ['1', '2'],
+            valueSpec: {type: 'array', value: 'number'},
+            styleSpec: v8
+        });
+        expect(errors).toHaveLength(2);
+        expect(errors[0].message).toBe('testArray[0]: number expected, string found');
+        expect(errors[1].message).toBe('testArray[1]: number expected, string found');
+
+        errors = validateArray({
+            validateSpec: validate,
+            key: 'testArray',
+            value: [1, true, 3],
+            valueSpec: {type: 'array', value: 'number'},
+            styleSpec: v8
+        });
+        expect(errors).toHaveLength(1);
+        expect(errors[0].message).toBe('testArray[1]: number expected, boolean found');
+
+        errors = validateArray({
+            validateSpec: validate,
+            key: 'testArray',
+            value: [1, 2, null],
+            valueSpec: {type: 'array', value: 'number'},
+            styleSpec: v8
+        });
+        expect(errors).toHaveLength(1);
+        expect(errors[0].message).toBe('testArray[2]: number expected, null found');
+    });
+
+    test('Should pass if array contains valid element types', () => {
+        let errors = validateArray({
+            validateSpec: validate,
+            key: 'testArray',
+            value: [1, 2, 3],
+            valueSpec: {type: 'array', value: 'number'},
+            styleSpec: v8
+        });
+        expect(errors).toHaveLength(0);
+
+        errors = validateArray({
+            validateSpec: validate,
+            key: 'testArray',
+            value: ['a', 'b', 'c'],
+            valueSpec: {type: 'array', value: 'string'},
+            styleSpec: v8
+        });
+        expect(errors).toHaveLength(0);
+
+        errors = validateArray({
+            validateSpec: validate,
+            key: 'testArray',
+            value: [true, false, true],
+            valueSpec: {type: 'array', value: 'boolean'},
+            styleSpec: v8
+        });
+        expect(errors).toHaveLength(0);
+    });
+
+    test('Should validate arrays with complex element specs', () => {
+        const errors = validateArray({
+            validateSpec: validate,
+            key: 'testArray',
+            value: [1, 2, 3],
+            valueSpec: {
+                type: 'array',
+                value: {
+                    type: 'number'
+                }
+            },
+            styleSpec: v8
+        });
+        expect(errors).toHaveLength(0);
+    });
+});

src/validate/validate_array.ts

@@ -18,10 +18,6 @@ export function validateArray(options) {
         return [new ValidationError(key, array, `array length ${arraySpec.length} expected, length ${array.length} found`)];
     }
 
-    if (arraySpec['min-length'] && array.length < arraySpec['min-length']) {
-        return [new ValidationError(key, array, `array length at least ${arraySpec['min-length']} expected, length ${array.length} found`)];
-    }
-
     let arrayElementSpec = {
         'type': arraySpec.value,
         'values': arraySpec.values

test/integration/style-spec/tests/center.input.json

@@ -0,0 +1,6 @@
+{
+  "version": 8,
+  "center": [12.3, 45.6, 0],
+  "sources": {},
+  "layers": []
+}

test/integration/style-spec/tests/center.output.json

@@ -0,0 +1,6 @@
+[
+  {
+    "message": "center: array length 2 expected, length 3 found",
+    "line": 3
+  }
+]