mapbox-gl 1.13.2

package/src/style-spec/migrate/v8.js

@@ -0,0 +1,203 @@
+
+import URL from 'url';
+import {eachSource, eachLayer, eachProperty} from '../visit';
+
+function eachLayout(layer, callback) {
+    for (const k in layer) {
+        if (k.indexOf('layout') === 0) {
+            callback(layer[k], k);
+        }
+    }
+}
+
+function eachPaint(layer, callback) {
+    for (const k in layer) {
+        if (k.indexOf('paint') === 0) {
+            callback(layer[k], k);
+        }
+    }
+}
+
+function resolveConstant(style, value) {
+    if (typeof value === 'string' && value[0] === '@') {
+        return resolveConstant(style, style.constants[value]);
+    } else {
+        return value;
+    }
+}
+
+function isFunction(value) {
+    return Array.isArray(value.stops);
+}
+
+function renameProperty(obj, from, to) {
+    obj[to] = obj[from]; delete obj[from];
+}
+
+export default function(style) {
+    style.version = 8;
+
+    // Rename properties, reverse coordinates in source and layers
+    eachSource(style, (source) => {
+        if (source.type === 'video' && source.url !== undefined) {
+            renameProperty(source, 'url', 'urls');
+        }
+        if (source.type === 'video') {
+            source.coordinates.forEach((coord) => {
+                return coord.reverse();
+            });
+        }
+    });
+
+    eachLayer(style, (layer) => {
+        eachLayout(layer, (layout) => {
+            if (layout['symbol-min-distance'] !== undefined) {
+                renameProperty(layout, 'symbol-min-distance', 'symbol-spacing');
+            }
+        });
+
+        eachPaint(layer, (paint) => {
+            if (paint['background-image'] !== undefined) {
+                renameProperty(paint, 'background-image', 'background-pattern');
+            }
+            if (paint['line-image'] !== undefined) {
+                renameProperty(paint, 'line-image', 'line-pattern');
+            }
+            if (paint['fill-image'] !== undefined) {
+                renameProperty(paint, 'fill-image', 'fill-pattern');
+            }
+        });
+    });
+
+    // Inline Constants
+    eachProperty(style, {paint: true, layout: true}, (property) => {
+        const value = resolveConstant(style, property.value);
+
+        if (isFunction(value)) {
+            value.stops.forEach((stop) => {
+                stop[1] = resolveConstant(style, stop[1]);
+            });
+        }
+
+        property.set(value);
+    });
+    delete style.constants;
+
+    eachLayer(style, (layer) => {
+        // get rid of text-max-size, icon-max-size
+        // turn text-size, icon-size into layout properties
+        // https://github.com/mapbox/mapbox-gl-style-spec/issues/255
+
+        eachLayout(layer, (layout) => {
+            delete layout['text-max-size'];
+            delete layout['icon-max-size'];
+        });
+
+        eachPaint(layer, (paint) => {
+            if (paint['text-size']) {
+                if (!layer.layout) layer.layout = {};
+                layer.layout['text-size'] = paint['text-size'];
+                delete paint['text-size'];
+            }
+
+            if (paint['icon-size']) {
+                if (!layer.layout) layer.layout = {};
+                layer.layout['icon-size'] = paint['icon-size'];
+                delete paint['icon-size'];
+            }
+        });
+    });
+
+    function migrateFontstackURL(input) {
+        const inputParsed = URL.parse(input);
+        const inputPathnameParts = inputParsed.pathname.split('/');
+
+        if (inputParsed.protocol !== 'mapbox:') {
+            return input;
+
+        } else if (inputParsed.hostname === 'fontstack') {
+            assert(decodeURI(inputParsed.pathname) === '/{fontstack}/{range}.pbf');
+            return 'mapbox://fonts/mapbox/{fontstack}/{range}.pbf';
+
+        } else if (inputParsed.hostname === 'fonts') {
+            assert(inputPathnameParts[1] === 'v1');
+            assert(decodeURI(inputPathnameParts[3]) === '{fontstack}');
+            assert(decodeURI(inputPathnameParts[4]) === '{range}.pbf');
+            return `mapbox://fonts/${inputPathnameParts[2]}/{fontstack}/{range}.pbf`;
+
+        } else {
+            assert(false);
+        }
+
+        function assert(predicate) {
+            if (!predicate) {
+                throw new Error(`Invalid font url: "${input}"`);
+            }
+        }
+    }
+
+    if (style.glyphs) {
+        style.glyphs = migrateFontstackURL(style.glyphs);
+    }
+
+    function migrateFontStack(font) {
+        function splitAndTrim(string) {
+            return string.split(',').map((s) => {
+                return s.trim();
+            });
+        }
+
+        if (Array.isArray(font)) {
+            // Assume it's a previously migrated font-array.
+            return font;
+
+        } else if (typeof font === 'string') {
+            return splitAndTrim(font);
+
+        } else if (typeof font === 'object') {
+            font.stops.forEach((stop) => {
+                stop[1] = splitAndTrim(stop[1]);
+            });
+            return font;
+
+        } else {
+            throw new Error("unexpected font value");
+        }
+    }
+
+    eachLayer(style, (layer) => {
+        eachLayout(layer, (layout) => {
+            if (layout['text-font']) {
+                layout['text-font'] = migrateFontStack(layout['text-font']);
+            }
+        });
+    });
+
+    // Reverse order of symbol layers. This is an imperfect migration.
+    //
+    // The order of a symbol layer in the layers list affects two things:
+    // - how it is drawn relative to other layers (like oneway arrows below bridges)
+    // - the placement priority compared to other layers
+    //
+    // It's impossible to reverse the placement priority without breaking the draw order
+    // in some cases. This migration only reverses the order of symbol layers that
+    // are above all other types of layers.
+    //
+    // Symbol layers that are at the top of the map preserve their priority.
+    // Symbol layers that are below another type (line, fill) of layer preserve their draw order.
+
+    let firstSymbolLayer = 0;
+    for (let i = style.layers.length - 1; i >= 0; i--) {
+        const layer = style.layers[i];
+        if (layer.type !== 'symbol') {
+            firstSymbolLayer = i + 1;
+            break;
+        }
+    }
+
+    const symbolLayers = style.layers.splice(firstSymbolLayer);
+    symbolLayers.reverse();
+    style.layers = style.layers.concat(symbolLayers);
+
+    return style;
+}

package/src/style-spec/migrate/v9.js

@@ -0,0 +1,26 @@
+
+import deref from '../deref';
+
+function eachLayer(style, callback) {
+    for (const k in style.layers) {
+        callback(style.layers[k]);
+    }
+}
+
+export default function(style) {
+    style.version = 9;
+
+    // remove user-specified refs
+    style.layers = deref(style.layers);
+
+    // remove class-specific paint properties
+    eachLayer(style, (layer) => {
+        for (const k in layer) {
+            if (/paint\..*/.test(k)) {
+                delete layer[k];
+            }
+        }
+    });
+
+    return style;
+}

package/src/style-spec/migrate.js

@@ -0,0 +1,36 @@
+
+import migrateToV8 from './migrate/v8';
+import migrateToExpressions from './migrate/expressions';
+
+/**
+ * Migrate a Mapbox GL Style to the latest version.
+ *
+ * @private
+ * @alias migrate
+ * @param {object} style a Mapbox GL Style
+ * @returns {Object} a migrated style
+ * @example
+ * var fs = require('fs');
+ * var migrate = require('mapbox-gl-style-spec').migrate;
+ * var style = fs.readFileSync('./style.json', 'utf8');
+ * fs.writeFileSync('./style.json', JSON.stringify(migrate(style)));
+ */
+export default function(style) {
+    let migrated = false;
+
+    if (style.version === 7) {
+        style = migrateToV8(style);
+        migrated = true;
+    }
+
+    if (style.version === 8) {
+        migrated = migrateToExpressions(style);
+        migrated = true;
+    }
+
+    if (!migrated) {
+        throw new Error('cannot migrate from', style.version);
+    }
+
+    return style;
+}

package/src/style-spec/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@mapbox/mapbox-gl-style-spec",
+  "description": "a specification for mapbox gl styles",
+  "version": "13.18.0-dev",
+  "author": "Mapbox",
+  "keywords": [
+    "mapbox",
+    "mapbox-gl",
+    "mapbox-gl-js"
+  ],
+  "license": "ISC",
+  "main": "./dist/index.js",
+  "module": "./dist/index.es.js",
+  "scripts": {
+    "copy-flow-typed": "cp -R ../../flow-typed .",
+    "build": "../../node_modules/.bin/rollup -c && ../../node_modules/.bin/rollup -c --environment esm",
+    "prepublish": "git clean -fdx && yarn copy-flow-typed && yarn build",
+    "postpublish": "rm -r flow-typed dist/index.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git@github.com:mapbox/mapbox-gl-js.git"
+  },
+  "bin": {
+    "gl-style-migrate": "bin/gl-style-migrate",
+    "gl-style-validate": "bin/gl-style-validate",
+    "gl-style-format": "bin/gl-style-format",
+    "gl-style-composite": "bin/gl-style-composite"
+  },
+  "dependencies": {
+    "@mapbox/jsonlint-lines-primitives": "~2.0.2",
+    "@mapbox/unitbezier": "^0.0.0",
+    "@mapbox/point-geometry": "^0.1.0",
+    "csscolorparser": "~1.0.2",
+    "json-stringify-pretty-compact": "^2.0.0",
+    "minimist": "^1.2.5",
+    "rw": "^1.3.3",
+    "sort-object": "^0.3.2"
+  },
+  "sideEffects": false
+}

package/src/style-spec/read_style.js

@@ -0,0 +1,14 @@
+import ParsingError from './error/parsing_error';
+import jsonlint from '@mapbox/jsonlint-lines-primitives';
+
+export default function readStyle(style) {
+    if (style instanceof String || typeof style === 'string' || style instanceof Buffer) {
+        try {
+            return jsonlint.parse(style.toString());
+        } catch (e) {
+            throw new ParsingError(e);
+        }
+    }
+
+    return style;
+}

package/src/style-spec/reference/latest.js

@@ -0,0 +1,3 @@
+
+import spec from './v8.json';
+export default spec;