@mapgis/mapbox-gl 16.0.1 → 16.2.0

package/build/generate-struct-arrays.js

@@ -1,237 +0,0 @@
-// @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}`;
-    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 patternAttributes = require('../src/data/bucket/pattern_attributes').default;
-
-// layout vertex arrays
-const layoutAttributes = {
-    circle: circleAttributes,
-    fill: fillAttributes,
-    'fill-extrusion': fillExtrusionAttributes,
-    heatmap: circleAttributes,
-    line: lineAttributes,
-    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,
-    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('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

@@ -1,159 +0,0 @@
-'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

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

package/build/print-release-url.js

@@ -1,6 +0,0 @@
-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

@@ -1,20 +0,0 @@
-
-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;
-            }
-
-            return {
-                code: JSON.stringify(JSON.parse(source), replacer, 0),
-                map: {mappings: ''}
-            };
-        }
-    };
-}

package/build/rollup_plugins.js

@@ -1,80 +0,0 @@
-
-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

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

package/build/run-tap

@@ -1,8 +0,0 @@
-#!/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

@@ -1,19 +0,0 @@
-/* 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();
-                });
-            });
-    });
-};

package/flow-typed/gl.js

@@ -1,5 +0,0 @@
-// @flow strict
-declare module "gl" {
-    declare function gl(width: number, height: number, attributes: WebGLContextAttributes): WebGLRenderingContext;
-    declare module.exports: typeof gl;
-}

package/flow-typed/jsdom.js

@@ -1,18 +0,0 @@
-// @flow strict
-
-import type Window from '../src/types/window';
-
-declare module "jsdom" {
-    declare class JSDOM {
-        constructor(content: string, options: Object): JSDOM;
-        window: Window;
-    }
-    declare class VirtualConsole {
-        constructor(): VirtualConsole;
-        sendTo(console: typeof console): VirtualConsole;
-    }
-    declare module.exports: {
-        JSDOM: typeof JSDOM,
-        VirtualConsole: typeof VirtualConsole
-    };
-}

package/flow-typed/mapbox-gl-supported.js

@@ -1,9 +0,0 @@
-// @flow
-'use strict';
-declare module "@mapbox/mapbox-gl-supported" {
-    declare type isSupported = {
-        (options?: {failIfMajorPerformanceCaveat: boolean}): boolean,
-        webGLContextAttributes: WebGLContextAttributes
-    };
-    declare module.exports: isSupported;
-}

package/flow-typed/mapbox-unitbezier.js

@@ -1,14 +0,0 @@
-'use strict';
-// @flow
-
-declare module "@mapbox/unitbezier" {
-    declare class UnitBezier {
-        constructor(p1x: number, p1y: number, p2x: number, p2y: number): UnitBezier;
-        sampleCurveX(t: number): number;
-        sampleCurveY(t: number): number;
-        sampleCurveDerivativeX(t: number): number;
-        solveCurveX(x: number, epsilon: number | void): number;
-        solve(x: number, epsilon: number | void): number;
-    }
-    declare module.exports: typeof UnitBezier;
-}

package/flow-typed/offscreen-canvas.js

@@ -1,9 +0,0 @@
-// @flow strict
-
-declare class OffscreenCanvas {
-    width: number;
-    height: number;
-
-    constructor(width: number, height: number): OffscreenCanvas;
-    getContext(contextType: '2d'): CanvasRenderingContext2D;
-}

package/flow-typed/pbf.js

@@ -1,25 +0,0 @@
-declare module "pbf" {
-    declare type ReadFunction<T> = (tag: number, result: T, pbf: Pbf) => void;
-
-    declare class Pbf {
-        constructor(buf?: ArrayBuffer | Uint8Array): Pbf;
-
-        readFields<T>(readField: ReadFunction<T>, result: T, end?: number): T;
-        readMessage<T>(readField: ReadFunction<T>, result: T): T;
-
-        readFixed32(): number;
-        readSFixed32(): number;
-        readFixed64(): number;
-        readSFixed64(): number;
-        readFloat(): number;
-        readDouble(): number;
-        readVarint(): number;
-        readVarint64(): number;
-        readSVarint(): number;
-        readBoolean(): boolean;
-        readString(): string;
-        readBytes(): Uint8Array;
-    }
-
-    declare module.exports: typeof Pbf
-}

package/flow-typed/point-geometry.js

@@ -1,44 +0,0 @@
-declare module "@mapbox/point-geometry" {
-    declare type PointLike = Point | [number, number];
-
-    declare class Point {
-        x: number;
-        y: number;
-        constructor(x: number, y: number): Point;
-        clone(): Point;
-        add(point: Point): Point;
-        sub(point: Point): Point;
-        multByPoint(point: Point): Point;
-        divByPoint(point: Point): Point;
-        mult(k: number): Point;
-        div(k: number): Point;
-        rotate(angle: number): Point;
-        rotateAround(angle: number, point: Point): Point;
-        matMult(matrix: [number, number, number, number]): Point;
-        unit(): Point;
-        perp(): Point;
-        round(): Point;
-        mag(): number;
-        equals(point: Point): boolean;
-        dist(point: Point): number;
-        distSqr(point: Point): number;
-        angle(): number;
-        angleTo(point: Point): number;
-        angleWith(point: Point): number;
-        angleWithSep(x: number, y: number): number;
-        _matMult(matrix: [number, number, number, number]): Point;
-        _add(point: Point): Point;
-        _sub(point: Point): Point;
-        _mult(k: number): Point;
-        _div(k: number): Point;
-        _multByPoint(point: Point): Point;
-        _divByPoint(point: Point): Point;
-        _unit(): Point;
-        _perp(): Point;
-        _rotate(angle: number): Point;
-        _rotateAround(angle: number, point: Point): Point;
-        _round(): Point;
-        static convert(a: PointLike): Point;
-    }
-    declare module.exports: typeof Point;
-}