mapbox-gl 1.13.2

package/build/generate-struct-arrays.js

@@ -0,0 +1,243 @@
+// @flow
+
+/*
+ * Generates the following:
+ *  - data/array_types.js, which consists of:
+ *    - StructArrayLayout_* subclasses, one for each underlying memory layout we need
+ *    - Named exports mapping each conceptual array type (e.g., CircleLayoutArray) to its corresponding StructArrayLayout class
+ *    - Particular, named StructArray subclasses, when fancy struct accessors are needed (e.g. CollisionBoxArray)
+ */
+
+'use strict'; // eslint-disable-line strict
+
+const fs = require('fs');
+
+const ejs = require('ejs');
+const util = require('../src/util/util');
+const {createLayout, viewTypes} = require('../src/util/struct_array');
+
+import type {ViewType, StructArrayLayout} from '../src/util/struct_array';
+
+const structArrayLayoutJs = ejs.compile(fs.readFileSync('src/util/struct_array_layout.js.ejs', 'utf8'), {strict: true});
+const structArrayJs = ejs.compile(fs.readFileSync('src/util/struct_array.js.ejs', 'utf8'), {strict: true});
+
+const typeAbbreviations = {
+    'Int8': 'b',
+    'Uint8': 'ub',
+    'Int16': 'i',
+    'Uint16': 'ui',
+    'Int32': 'l',
+    'Uint32': 'ul',
+    'Float32': 'f'
+};
+
+const arraysWithStructAccessors = [];
+const arrayTypeEntries = new Set();
+const layoutCache = {};
+
+function normalizeMembers(members, usedTypes) {
+    return members.map((member) => {
+        if (usedTypes && !usedTypes.has(member.type)) {
+            usedTypes.add(member.type);
+        }
+
+        return util.extend(member, {
+            size: sizeOf(member.type),
+            view: member.type.toLowerCase()
+        });
+    });
+}
+
+// - If necessary, write the StructArrayLayout_* class for the given layout
+// - If `includeStructAccessors`, write the fancy subclass
+// - Add an entry for `name` in the array type registry
+function createStructArrayType(name: string, layout: StructArrayLayout, includeStructAccessors: boolean = false) {
+    const hasAnchorPoint = layout.members.some(m => m.name === 'anchorPointX');
+
+    // create the underlying StructArrayLayout class exists
+    const layoutClass = createStructArrayLayoutType(layout);
+    const arrayClass = `${camelize(name)}Array`;
+
+    if (includeStructAccessors) {
+        const usedTypes = new Set(['Uint8']);
+        const members = normalizeMembers(layout.members, usedTypes);
+        arraysWithStructAccessors.push({
+            arrayClass,
+            members,
+            size: layout.size,
+            usedTypes,
+            hasAnchorPoint,
+            layoutClass,
+            includeStructAccessors
+        });
+    } else {
+        arrayTypeEntries.add(`${layoutClass} as ${arrayClass}`);
+    }
+}
+
+function createStructArrayLayoutType({members, size, alignment}) {
+    const usedTypes = new Set(['Uint8']);
+    members = normalizeMembers(members, usedTypes);
+
+    // combine consecutive 'members' with same underlying type, summing their
+    // component counts
+    if (!alignment || alignment === 1) members = members.reduce((memo, member) => {
+        if (memo.length > 0 && memo[memo.length - 1].type === member.type) {
+            const last = memo[memo.length - 1];
+            return memo.slice(0, -1).concat(util.extend({}, last, {
+                components: last.components + member.components,
+            }));
+        }
+        return memo.concat(member);
+    }, []);
+
+    const key = `${members.map(m => `${m.components}${typeAbbreviations[m.type]}`).join('')}${size}`;
+    const className = `StructArrayLayout${key}`;
+    // Layout alignment to 4 bytes boundaries can be an issue on some set of graphics cards. Particularly AMD.
+    if (size % 4 !== 0) { console.warn(`Warning: The layout ${className} is not aligned to 4-bytes boundaries.`); }
+    if (!layoutCache[key]) {
+        layoutCache[key] = {
+            className,
+            members,
+            size,
+            usedTypes
+        };
+    }
+
+    return className;
+}
+
+function sizeOf(type: ViewType): number {
+    return viewTypes[type].BYTES_PER_ELEMENT;
+}
+
+function camelize (str) {
+    return str.replace(/(?:^|[-_])(.)/g, (_, x) => {
+        return /^[0-9]$/.test(x) ? _ : x.toUpperCase();
+    });
+}
+
+global.camelize = camelize;
+
+const posAttributes = require('../src/data/pos_attributes').default;
+const rasterBoundsAttributes = require('../src/data/raster_bounds_attributes').default;
+
+createStructArrayType('pos', posAttributes);
+createStructArrayType('raster_bounds', rasterBoundsAttributes);
+
+const circleAttributes = require('../src/data/bucket/circle_attributes').default;
+const fillAttributes = require('../src/data/bucket/fill_attributes').default;
+const fillExtrusionAttributes = require('../src/data/bucket/fill_extrusion_attributes').default;
+const lineAttributes = require('../src/data/bucket/line_attributes').default;
+const lineAttributesExt = require('../src/data/bucket/line_attributes_ext').default;
+const patternAttributes = require('../src/data/bucket/pattern_attributes').default;
+
+// layout vertex arrays
+const layoutAttributes = {
+    circle: circleAttributes,
+    fill: fillAttributes,
+    'fill-extrusion': fillExtrusionAttributes,
+    heatmap: circleAttributes,
+    line: lineAttributes,
+    lineExt: lineAttributesExt,
+    pattern: patternAttributes
+};
+for (const name in layoutAttributes) {
+    createStructArrayType(`${name.replace(/-/g, '_')}_layout`, layoutAttributes[name]);
+}
+
+// symbol layer specific arrays
+const {
+    symbolLayoutAttributes,
+    dynamicLayoutAttributes,
+    placementOpacityAttributes,
+    collisionBox,
+    collisionBoxLayout,
+    collisionCircleLayout,
+    collisionVertexAttributes,
+    quadTriangle,
+    placement,
+    symbolInstance,
+    glyphOffset,
+    lineVertex
+} = require('../src/data/bucket/symbol_attributes');
+
+createStructArrayType(`symbol_layout`, symbolLayoutAttributes);
+createStructArrayType(`symbol_dynamic_layout`, dynamicLayoutAttributes);
+createStructArrayType(`symbol_opacity`, placementOpacityAttributes);
+createStructArrayType('collision_box', collisionBox, true);
+createStructArrayType(`collision_box_layout`, collisionBoxLayout);
+createStructArrayType(`collision_circle_layout`, collisionCircleLayout);
+createStructArrayType(`collision_vertex`, collisionVertexAttributes);
+createStructArrayType(`quad_triangle`, quadTriangle);
+createStructArrayType('placed_symbol', placement, true);
+createStructArrayType('symbol_instance', symbolInstance, true);
+createStructArrayType('glyph_offset', glyphOffset, true);
+createStructArrayType('symbol_line_vertex', lineVertex, true);
+
+// feature index array
+createStructArrayType('feature_index', createLayout([
+    // the index of the feature in the original vectortile
+    { type: 'Uint32', name: 'featureIndex' },
+    // the source layer the feature appears in
+    { type: 'Uint16', name: 'sourceLayerIndex' },
+    // the bucket the feature appears in
+    { type: 'Uint16', name: 'bucketIndex' }
+]), true);
+
+// triangle index array
+createStructArrayType('triangle_index', createLayout([
+    { type: 'Uint16', name: 'vertices', components: 3 }
+]));
+
+// line index array
+createStructArrayType('line_index', createLayout([
+    { type: 'Uint16', name: 'vertices', components: 2 }
+]));
+
+// line strip index array
+createStructArrayType('line_strip_index', createLayout([
+    { type: 'Uint16', name: 'vertices', components: 1 }
+]));
+
+// paint vertex arrays
+
+// used by SourceBinder for float properties
+createStructArrayLayoutType(createLayout([{
+    name: 'dummy name (unused for StructArrayLayout)',
+    type: 'Float32',
+    components: 1
+}], 4));
+
+// used by SourceBinder for color properties and CompositeBinder for float properties
+createStructArrayLayoutType(createLayout([{
+    name: 'dummy name (unused for StructArrayLayout)',
+    type: 'Float32',
+    components: 2
+}], 4));
+
+// used by CompositeBinder for color properties
+createStructArrayLayoutType(createLayout([{
+    name: 'dummy name (unused for StructArrayLayout)',
+    type: 'Float32',
+    components: 4
+}], 4));
+
+const layouts = Object.keys(layoutCache).map(k => layoutCache[k]);
+
+fs.writeFileSync('src/data/array_types.js',
+    `// This file is generated. Edit build/generate-struct-arrays.js, then run \`yarn run codegen\`.
+// @flow
+
+import assert from 'assert';
+import {Struct, StructArray} from '../util/struct_array';
+import {register} from '../util/web_worker_transfer';
+import Point from '@mapbox/point-geometry';
+
+${layouts.map(structArrayLayoutJs).join('\n')}
+${arraysWithStructAccessors.map(structArrayJs).join('\n')}
+export {
+    ${layouts.map(layout => layout.className).join(',\n    ')},
+    ${[...arrayTypeEntries].join(',\n    ')}
+};
+`);

package/build/generate-style-code.js

@@ -0,0 +1,159 @@
+'use strict';
+
+const fs = require('fs');
+
+const ejs = require('ejs');
+const spec = require('../src/style-spec/reference/v8');
+const Color = require('../src/style-spec/util/color');
+
+global.camelize = function (str) {
+    return str.replace(/(?:^|-)(.)/g, function (_, x) {
+        return x.toUpperCase();
+    });
+};
+
+global.camelizeWithLeadingLowercase = function (str) {
+    return str.replace(/-(.)/g, function (_, x) {
+      return x.toUpperCase();
+    });
+};
+
+global.flowType = function (property) {
+    switch (property.type) {
+        case 'boolean':
+            return 'boolean';
+        case 'number':
+            return 'number';
+        case 'string':
+            return 'string';
+        case 'enum':
+            return Object.keys(property.values).map(JSON.stringify).join(' | ');
+        case 'color':
+            return `Color`;
+        case 'formatted':
+            return `Formatted`;
+        case 'resolvedImage':
+            return `ResolvedImage`;
+        case 'array':
+            if (property.length) {
+                return `[${new Array(property.length).fill(flowType({type: property.value})).join(', ')}]`;
+            } else {
+                return `Array<${flowType({type: property.value, values: property.values})}>`;
+            }
+        default: throw new Error(`unknown type for ${property.name}`)
+    }
+};
+
+global.propertyType = function (property) {
+    switch (property['property-type']) {
+        case 'data-driven':
+            return `DataDrivenProperty<${flowType(property)}>`;
+        case 'cross-faded':
+            return `CrossFadedProperty<${flowType(property)}>`;
+        case 'cross-faded-data-driven':
+            return `CrossFadedDataDrivenProperty<${flowType(property)}>`;
+        case 'color-ramp':
+            return `ColorRampProperty`;
+        case 'data-constant':
+        case 'constant':
+            return `DataConstantProperty<${flowType(property)}>`;
+        default:
+            throw new Error(`unknown property-type "${property['property-type']}" for ${property.name}`);
+    }
+};
+
+global.runtimeType = function (property) {
+    switch (property.type) {
+        case 'boolean':
+            return 'BooleanType';
+        case 'number':
+            return 'NumberType';
+        case 'string':
+        case 'enum':
+            return 'StringType';
+        case 'color':
+            return `ColorType`;
+        case 'formatted':
+            return `FormattedType`;
+        case 'Image':
+            return `ImageType`;
+        case 'array':
+            if (property.length) {
+                return `array(${runtimeType({type: property.value})}, ${property.length})`;
+            } else {
+                return `array(${runtimeType({type: property.value})})`;
+            }
+        default: throw new Error(`unknown type for ${property.name}`)
+    }
+};
+
+global.defaultValue = function (property) {
+    switch (property.type) {
+        case 'boolean':
+        case 'number':
+        case 'string':
+        case 'array':
+        case 'enum':
+            return JSON.stringify(property.default);
+        case 'color':
+            if (typeof property.default !== 'string') {
+                return JSON.stringify(property.default);
+            } else {
+                const {r, g, b, a} = Color.parse(property.default);
+                return `new Color(${r}, ${g}, ${b}, ${a})`;
+            }
+        default: throw new Error(`unknown type for ${property.name}`)
+    }
+};
+
+global.overrides = function (property) {
+    return `{ runtimeType: ${runtimeType(property)}, getOverride: (o) => o.${camelizeWithLeadingLowercase(property.name)}, hasOverride: (o) => !!o.${camelizeWithLeadingLowercase(property.name)} }`;
+}
+
+global.propertyValue = function (property, type) {
+    switch (property['property-type']) {
+        case 'data-driven':
+            if (property.overridable) {
+                return `new DataDrivenProperty(styleSpec["${type}_${property.layerType}"]["${property.name}"], ${overrides(property)})`;
+            } else {
+                return `new DataDrivenProperty(styleSpec["${type}_${property.layerType}"]["${property.name}"])`;
+            }
+        case 'cross-faded':
+            return `new CrossFadedProperty(styleSpec["${type}_${property.layerType}"]["${property.name}"])`;
+        case 'cross-faded-data-driven':
+            return `new CrossFadedDataDrivenProperty(styleSpec["${type}_${property.layerType}"]["${property.name}"])`;
+        case 'color-ramp':
+            return `new ColorRampProperty(styleSpec["${type}_${property.layerType}"]["${property.name}"])`;
+        case 'data-constant':
+        case 'constant':
+            return `new DataConstantProperty(styleSpec["${type}_${property.layerType}"]["${property.name}"])`;
+        default:
+            throw new Error(`unknown property-type "${property['property-type']}" for ${property.name}`);
+    }
+};
+
+const propertiesJs = ejs.compile(fs.readFileSync('src/style/style_layer/layer_properties.js.ejs', 'utf8'), {strict: true});
+
+const layers = Object.keys(spec.layer.type.values).map((type) => {
+    const layoutProperties = Object.keys(spec[`layout_${type}`]).reduce((memo, name) => {
+        if (name !== 'visibility') {
+            spec[`layout_${type}`][name].name = name;
+            spec[`layout_${type}`][name].layerType = type;
+            memo.push(spec[`layout_${type}`][name]);
+        }
+        return memo;
+    }, []);
+
+    const paintProperties = Object.keys(spec[`paint_${type}`]).reduce((memo, name) => {
+        spec[`paint_${type}`][name].name = name;
+        spec[`paint_${type}`][name].layerType = type;
+        memo.push(spec[`paint_${type}`][name]);
+        return memo;
+    }, []);
+
+    return { type, layoutProperties, paintProperties };
+});
+
+for (const layer of layers) {
+    fs.writeFileSync(`src/style/style_layer/${layer.type.replace('-', '_')}_style_layer_properties.js`, propertiesJs(layer))
+}

package/build/mapbox-gl.js.flow

@@ -0,0 +1,3 @@
+// @flow
+/* eslint-disable */
+export * from '../src/index.js';

package/build/print-release-url.js

@@ -0,0 +1,6 @@
+const address = require('address');
+const qrcode = require('qrcode-terminal');
+
+const url = `http://${address.ip()}:9966/test/release/index.html`;
+console.warn(`Scan this QR code or enter ${url}`);
+qrcode.generate(url);

package/build/rollup_plugin_minify_style_spec.js

@@ -0,0 +1,24 @@
+
+function replacer(k, v) {
+    return (k === 'doc' || k === 'example' || k === 'sdk-support') ? undefined : v;
+}
+
+export default function minifyStyleSpec() {
+    return {
+        name: 'minify-style-spec',
+        transform: (source, id) => {
+            if (!/style\-spec[\\/]reference[\\/]v[0-9]+\.json$/.test(id)) {
+                return;
+            }
+
+            const spec = JSON.parse(source);
+
+            delete spec['expression_name'];
+
+            return {
+                code: JSON.stringify(spec, replacer, 0),
+                map: {mappings: ''}
+            };
+        }
+    };
+}

package/build/rollup_plugins.js

@@ -0,0 +1,80 @@
+
+import flowRemoveTypes from '@mapbox/flow-remove-types';
+import buble from 'rollup-plugin-buble';
+import resolve from 'rollup-plugin-node-resolve';
+import commonjs from 'rollup-plugin-commonjs';
+import unassert from 'rollup-plugin-unassert';
+import json from 'rollup-plugin-json';
+import {terser} from 'rollup-plugin-terser';
+import minifyStyleSpec from './rollup_plugin_minify_style_spec';
+import {createFilter} from 'rollup-pluginutils';
+import strip from '@rollup/plugin-strip';
+
+// Common set of plugins/transformations shared across different rollup
+// builds (main mapboxgl bundle, style-spec package, benchmarks bundle)
+
+export const plugins = (minified, production) => [
+    flow(),
+    minifyStyleSpec(),
+    json(),
+    production ? strip({
+        sourceMap: true,
+        functions: ['PerformanceUtils.*', 'Debug.*']
+    }) : false,
+    glsl('./src/shaders/*.glsl', production),
+    buble({transforms: {dangerousForOf: true}, objectAssign: "Object.assign"}),
+    minified ? terser({
+        compress: {
+            pure_getters: true,
+            passes: 3
+        }
+    }) : false,
+    production ? unassert() : false,
+    resolve({
+        browser: true,
+        preferBuiltins: false
+    }),
+    commonjs({
+        // global keyword handling causes Webpack compatibility issues, so we disabled it:
+        // https://github.com/mapbox/mapbox-gl-js/pull/6956
+        ignoreGlobal: true
+    })
+].filter(Boolean);
+
+// Using this instead of rollup-plugin-flow due to
+// https://github.com/leebyron/rollup-plugin-flow/issues/5
+export function flow() {
+    return {
+        name: 'flow-remove-types',
+        transform: (code) => ({
+            code: flowRemoveTypes(code).toString(),
+            map: null
+        })
+    };
+}
+
+// Using this instead of rollup-plugin-string to add minification
+function glsl(include, minify) {
+    const filter = createFilter(include);
+    return {
+        name: 'glsl',
+        transform(code, id) {
+            if (!filter(id)) return;
+
+            // barebones GLSL minification
+            if (minify) {
+                code = code.trim() // strip whitespace at the start/end
+                    .replace(/\s*\/\/[^\n]*\n/g, '\n') // strip double-slash comments
+                    .replace(/\n+/g, '\n') // collapse multi line breaks
+                    .replace(/\n\s+/g, '\n') // strip identation
+                    .replace(/\s?([+-\/*=,])\s?/g, '$1') // strip whitespace around operators
+                    .replace(/([;\(\),\{\}])\n(?=[^#])/g, '$1'); // strip more line breaks
+            }
+
+            return {
+                code: `export default ${JSON.stringify(code)};`,
+                map: {mappings: ''}
+            };
+        }
+    };
+}

package/build/run-node

@@ -0,0 +1,3 @@
+#!/usr/bin/env bash
+
+node -r @mapbox/flow-remove-types/register -r esm ${@}

package/build/run-tap

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+if [ "$#" == 5 ]; then
+  arg="${@:1:3} ${4}/${5}"
+else
+  arg="${@}"
+fi
+
+node_modules/.bin/tap --node-arg -r --node-arg @mapbox/flow-remove-types/register --node-arg -r --node-arg esm $arg --node-arg

package/build/test/build-tape.js

@@ -0,0 +1,19 @@
+/* eslint-disable import/no-commonjs */
+/* eslint-disable flowtype/require-valid-file-annotation */
+const browserify = require('browserify');
+const fs = require('fs');
+
+module.exports = function() {
+    return new Promise((resolve, reject) => {
+        browserify(require.resolve('../../test/util/tape_config.js'), { standalone: 'tape' })
+            .transform("babelify", {presets: ["@babel/preset-env"], global: true})
+            .bundle((err, buff) => {
+                if (err) { throw err; }
+
+                fs.writeFile('test/integration/dist/tape.js', buff, { encoding: 'utf8'}, (err) => {
+                    if (err) { reject(err); }
+                    resolve();
+                });
+            });
+    });
+};