@mapbox/mapbox-gl-style-spec 14.21.0 → 14.22.0-rc.1

package/expression/definitions/config.ts

@@ -146,9 +146,8 @@ class Config implements Expression {
             }
         }
 
-        // @ts-expect-error - TS2367 - This comparison appears to be unintentional because the types 'string' and 'Type' have no overlap.
         // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-        if ((type && type !== this.type) || (result !== undefined && !typeEquals(typeOf(result), this.type))) {
+        if ((type && type !== (this.type as unknown as string)) || (result !== undefined && !typeEquals(typeOf(result), this.type))) {
             // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
             result = coerceValue(this.type.kind, result);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mapbox/mapbox-gl-style-spec",
-  "version": "14.21.0",
+  "version": "14.22.0-rc.1",
   "description": "a specification for mapbox gl styles",
   "author": "Mapbox",
   "license": "SEE LICENSE IN LICENSE.txt",
@@ -44,7 +44,6 @@
     "gl-style-composite": "./bin/gl-style-composite.js"
   },
   "dependencies": {
-    "@mapbox/jsonlint-lines-primitives": "~2.0.2",
     "@mapbox/point-geometry": "^1.1.0",
     "@mapbox/unitbezier": "^0.0.1",
     "cheap-ruler": "^4.0.0",

package/read_style.ts

@@ -1,12 +1,13 @@
 import ParsingError from './error/parsing_error';
-import jsonlint from '@mapbox/jsonlint-lines-primitives';
 
 import type {StyleSpecification} from './types';
 
 export default function readStyle(style: string | Buffer | StyleSpecification): StyleSpecification {
     if (style instanceof String || typeof style === 'string' || ArrayBuffer.isView(style)) {
         try {
-            return (jsonlint as {parse: (input: string) => StyleSpecification}).parse(style.toString());
+            const str = style.toString();
+            JSON.parse(str); // first try full parsing to catch malformed JSON
+            return parse(str) as StyleSpecification; // then our custom parser
         } catch (e) {
             throw new ParsingError(e as Error);
         }
@@ -14,3 +15,124 @@ export default function readStyle(style: string | Buffer | StyleSpecification):
 
     return style;
 }
+
+// custom JSON parser that assumes valid JSON and wraps values to include line metadata
+
+export const LBRACE   = 0; // {
+export const RBRACE   = 1; // }
+export const LBRACKET = 2; // [
+export const RBRACKET = 3; // ]
+export const STRING   = 4; // "..."
+export const NUMBER   = 5; // -1.5e+3
+export const TRUE     = 6; // true
+export const FALSE    = 7; // false
+export const NULL     = 8; // null
+
+export function tokenize(s: string) {
+    const tokens: number[] = [];
+    let pos = 0;
+    const len = s.length;
+
+    while (pos < len) {
+        const c = s.charCodeAt(pos);
+
+        if (c === 32 || c === 9 || c === 10 || c === 13 || c === 58 || c === 44) { // whitespace
+            pos++;
+            continue;
+        }
+
+        const start = pos;
+
+        if (c === 123) tokens.push(LBRACE, start, ++pos); // {
+        else if (c === 125) tokens.push(RBRACE,   start, ++pos); // }
+        else if (c === 91) tokens.push(LBRACKET, start, ++pos); // [
+        else if (c === 93) tokens.push(RBRACKET, start, ++pos); // ]
+        else if (c === 34) { // "
+            pos++;
+            while (pos < len) {
+                const ch = s.charCodeAt(pos);
+                if (ch === 92) pos += s.charCodeAt(pos + 1) === 117 ? 6 : 2; // escape; \uXXXX = 6 chars, others = 2
+                else if (ch === 34) break; // closing quote
+                else pos++;
+            }
+            tokens.push(STRING, start, ++pos);
+        } else if (c === 116) tokens.push(TRUE,  start, pos += 4); // true
+        else if (c === 102) tokens.push(FALSE, start, pos += 5); // false
+        else if (c === 110) tokens.push(NULL,  start, pos += 4); // null
+        else { // number
+            while (pos < len) {
+                const ch = s.charCodeAt(pos);
+                if ((ch >= 48 && ch <= 57) || ch === 45 || ch === 43 || ch === 46 || ch === 101 || ch === 69) pos++;
+                else break;
+            }
+            tokens.push(NUMBER, start, pos);
+        }
+    }
+
+    return tokens;
+}
+
+/* eslint-disable @typescript-eslint/no-wrapper-object-types */
+type JSONValue = String | Number | Boolean | null | {[key: string]: JSONValue} | JSONValue[];
+
+function parseTokens(s: string, tokens: number[]) {
+    let i = 0;
+
+    const lineOffsets = [0];
+    for (let j = 0; j < s.length; j++) {
+        if (s.charCodeAt(j) === 10) lineOffsets.push(j + 1);
+    }
+
+    function lineNum(pos: number) {
+        let lo = 0, hi = lineOffsets.length - 1;
+        while (lo < hi) {
+            const mid = (lo + hi + 1) >> 1;
+            if (lineOffsets[mid] <= pos) lo = mid;
+            else hi = mid - 1;
+        }
+        return lo + 1;
+    }
+
+    function setLine<T>(obj: T, line: number): T {
+        Object.defineProperty(obj, '__line__', {value: line});
+        return obj;
+    }
+
+    function parseValue(): JSONValue {
+        const type = tokens[i];
+        const start = tokens[i + 1];
+        const end = tokens[i + 2];
+        i += 3;
+
+        const line = lineNum(start);
+
+        if (type === LBRACE) {
+            const obj = setLine({}, line);
+            while (tokens[i] !== RBRACE) {
+                const key: string = JSON.parse(s.slice(tokens[i + 1], tokens[i + 2])) as string;
+                i += 3;
+                obj[key] = parseValue();
+            }
+            i += 3;
+            return obj;
+        }
+        if (type === LBRACKET) {
+            const arr: JSONValue = setLine([], line);
+            while (tokens[i] !== RBRACKET) arr.push(parseValue());
+            i += 3;
+            return arr;
+        }
+        /* eslint-disable no-new-wrappers */
+        if (type === STRING) return setLine(new String(JSON.parse(s.slice(start, end))), line);
+        if (type === NUMBER) return setLine(new Number(+s.slice(start, end)), line);
+        if (type === TRUE)   return setLine(new Boolean(true), line);
+        if (type === FALSE)  return setLine(new Boolean(false), line);
+        return null; // null cannot carry properties
+    }
+
+    return parseValue();
+}
+
+function parse(s: string): JSONValue {
+    return parseTokens(s, tokenize(s));
+}

package/rollup.config.js

@@ -1,4 +1,3 @@
-import replace from '@rollup/plugin-replace';
 import resolve from '@rollup/plugin-node-resolve';
 import commonjs from '@rollup/plugin-commonjs';
 import unassert from 'rollup-plugin-unassert';
@@ -20,15 +19,6 @@ const config = [{
         sourcemap: true
     },
     plugins: [
-        // https://github.com/zaach/jison/issues/351
-        replace({
-            preventAssignment: true,
-            include: /\/jsonlint-lines-primitives\/lib\/jsonlint.js/,
-            delimiters: ['', ''],
-            values: {
-                '_token_stack:': ''
-            }
-        }),
         esbuild({tsconfig: `${__dirname}/../../tsconfig.json`}),
         json(),
         // eslint-disable-next-line @typescript-eslint/no-unsafe-call