@mapgis/mapbox-gl 16.0.1 → 16.6.0

package/build/check-bundle-size.js

@@ -1,140 +0,0 @@
-#!/usr/bin/env node
-
-/* eslint-disable */
-
-const jwt = require('jsonwebtoken');
-const github = require('@octokit/rest')();
-const prettyBytes = require('pretty-bytes');
-const fs = require('fs');
-const {execSync} = require('child_process');
-const zlib = require('zlib');
-
-const SIZE_CHECK_APP_ID = 14028;
-const SIZE_CHECK_APP_INSTALLATION_ID = 229425;
-
-const file = process.argv[2];
-const label = process.argv[3];
-const name = `Size - ${label}`;
-
-if (!file || !label) {
-    console.log(`Usage: ${process.argv[0]} ${process.argv[1]} FILE LABEL`);
-    process.exit(1);
-}
-
-const {size} = fs.statSync(file);
-const gzipSize = zlib.gzipSync(fs.readFileSync(file)).length;
-
-process.on('unhandledRejection', error => {
-    // don't log `error` directly, because errors from child_process.execSync
-    // contain an (undocumented) `envPairs` with environment variable values
-    console.log(error.message || 'Error');
-    process.exit(1)
-});
-
-const pk = process.env['SIZE_CHECK_APP_PRIVATE_KEY'];
-if (!pk) {
-    console.log('Fork PR; not computing size.');
-    process.exit(0);
-}
-
-const key = Buffer.from(pk, 'base64').toString('binary');
-const payload = {
-    exp: Math.floor(Date.now() / 1000) + 60,
-    iat: Math.floor(Date.now() / 1000),
-    iss: SIZE_CHECK_APP_ID
-};
-
-const token = jwt.sign(payload, key, {algorithm: 'RS256'});
-github.authenticate({type: 'app', token});
-
-function getMergeBase() {
-    const pr = process.env['CIRCLE_PULL_REQUEST'];
-    if (pr) {
-        const number = +pr.match(/\/(\d+)\/?$/)[1];
-        return github.pullRequests.get({
-            owner: 'mapbox',
-            repo: 'mapbox-gl-js',
-            pull_number: number
-        }).then(({data}) => {
-            const base = data.base.ref;
-            const head = process.env['CIRCLE_SHA1'];
-            return execSync(`git merge-base origin/${base} ${head}`).toString().trim();
-        });
-    } else {
-        // Walk backward through the history (maximum of 10 commits) until
-        // finding a commit on either master or release-*; assume that's the
-        // base branch.
-        const head = process.env['CIRCLE_SHA1'];
-        for (const sha of execSync(`git rev-list --max-count=10 ${head}`).toString().trim().split('\n')) {
-            const base = execSync(`git branch -r --contains ${sha} origin/master origin/release-* origin/publisher-production`).toString().split('\n')[0].trim().replace(/^origin\//, '');
-            if (base) {
-                return Promise.resolve(execSync(`git merge-base origin/${base} ${head}`).toString().trim());
-            }
-        }
-    }
-
-    return Promise.resolve(null);
-}
-
-function getPriorSize(mergeBase) {
-    if (!mergeBase) {
-        console.log('No merge base available.');
-        return Promise.resolve(null);
-    }
-
-    return github.checks.listForRef({
-        owner: 'mapbox',
-        repo: 'mapbox-gl-js',
-        ref: mergeBase
-    }).then(({data}) => {
-        const run = data.check_runs.find(run => run.name === name);
-        if (run) {
-            const match = run.output.summary.match(/`[^`]+` is (\d+) bytes \([^\)]+\) uncompressed, (\d+) bytes \([^\)]+\) gzipped\./);
-            if (match) {
-                const prior = { size: +match[1], gzipSize: +match[2] };
-                console.log(`Prior size was ${prettyBytes(prior.size)}, gzipped ${prior.gzipSize}.`);
-                return prior;
-            }
-        }
-        console.log('No matching check found.');
-        return Promise.resolve(null);
-    });
-}
-
-function formatSize(size, priorSize) {
-    if (priorSize) {
-        const change = size - priorSize;
-        const percent = (change / priorSize) * 100;
-        return `${change >= 0 ? '+' : ''}${prettyBytes(change)} ${percent.toFixed(3)}% (${prettyBytes(size)})`;
-    } else {
-        return prettyBytes(size);
-    }
-}
-
-github.apps.createInstallationToken({installation_id: SIZE_CHECK_APP_INSTALLATION_ID})
-    .then(({data}) => {
-        github.authenticate({type: 'token', token: data.token});
-        getMergeBase().then(getPriorSize).then(prior => {
-            const title = `${formatSize(size, prior ? prior.size : null)}, gzipped ${formatSize(gzipSize, prior ? prior.gzipSize : null)}`;
-
-            const megabit = Math.pow(2, 12);
-            const downloadTime3G = (gzipSize / (3 * megabit)).toFixed(0);
-            const downloadTime4G = (gzipSize / (10 * megabit)).toFixed(0);
-            const summary = `\`${file}\` is ${size} bytes (${prettyBytes(size)}) uncompressed, ${gzipSize} bytes (${prettyBytes(gzipSize)}) gzipped.
-That's **${downloadTime3G} seconds** over slow 3G (3 Mbps), **${downloadTime4G} seconds** over fast 4G (10 Mbps).`;
-
-            console.log(`Posting check result:\n${title}\n${summary}`);
-
-            return github.checks.create({
-                owner: 'mapbox',
-                repo: 'mapbox-gl-js',
-                name,
-                head_branch: process.env['CIRCLE_BRANCH'],
-                head_sha: process.env['CIRCLE_SHA1'],
-                status: 'completed',
-                conclusion: 'success',
-                completed_at: new Date().toISOString(),
-                output: { title, summary }
-            });
-        })
-    });

package/build/generate-access-token-script.js

@@ -1,11 +0,0 @@
-/* eslint-disable */
-'use strict';
-const fs = require('fs');
-const path = require('path');
-const script = fs.readFileSync(path.join(__dirname, '../debug/access_token.js'), 'utf-8')
-    .replace('process.env.MapboxAccessToken',
-        JSON.stringify(process.env.MapboxAccessToken))
-    .replace('process.env.MAPBOX_ACCESS_TOKEN',
-        JSON.stringify(process.env.MAPBOX_ACCESS_TOKEN));
-
-fs.writeFileSync(path.join(__dirname, '../debug/access_token_generated.js'), script);

package/build/generate-flow-typed-style-spec.js

@@ -1,188 +0,0 @@
-const spec = require('../src/style-spec/reference/v8.json');
-const properties = require('../src/style-spec/util/properties');
-const fs = require('fs');
-
-function flowEnum(values) {
-    if (Array.isArray(values)) {
-        return values.map(JSON.stringify).join(' | ');
-    } else {
-        return Object.keys(values).map(JSON.stringify).join(' | ');
-    }
-}
-
-function flowType(property) {
-    if (typeof property.type === 'function') {
-        return property.type();
-    }
-
-    const baseType = (() => {
-        switch (property.type) {
-            case 'string':
-            case 'number':
-            case 'boolean':
-                return property.type;
-            case 'enum':
-                return flowEnum(property.values);
-            case 'array':
-                const elementType = flowType(typeof property.value === 'string' ? {type: property.value, values: property.values} : property.value)
-                if (property.length) {
-                    return `[${Array(property.length).fill(elementType).join(', ')}]`;
-                } else {
-                    return `Array<${elementType}>`;
-                }
-            case 'light':
-                return 'LightSpecification';
-            case 'sources':
-                return '{[_: string]: SourceSpecification}';
-            case '*':
-                return 'mixed';
-            default:
-                return `${property.type.slice(0, 1).toUpperCase()}${property.type.slice(1)}Specification`;
-        }
-    })();
-
-    if (properties.supportsPropertyExpression(property)) {
-        return `DataDrivenPropertyValueSpecification<${baseType}>`;
-    } else if (properties.supportsZoomExpression(property)) {
-        return `PropertyValueSpecification<${baseType}>`;
-    } else if (property.expression) {
-        return `ExpressionSpecification`;
-    } else {
-        return baseType;
-    }
-}
-
-function flowProperty(key, property) {
-    return `"${key}"${property.required ? '' : '?'}: ${flowType(property)}`;
-}
-
-function flowObjectDeclaration(key, properties) {
-    return `export type ${key} = ${flowObject(properties, '', '*' in properties ? '' : '|')}`;
-}
-
-function flowObject(properties, indent, sealing = '') {
-    return `{${sealing}
-${Object.keys(properties)
-        .filter(k => k !== '*')
-        .map(k => `    ${indent}${flowProperty(k, properties[k])}`)
-        .join(',\n')}
-${indent}${sealing}}`
-}
-
-function flowSourceTypeName(key) {
-    return key.replace(/source_(.)(.*)/, (_, _1, _2) => `${_1.toUpperCase()}${_2}SourceSpecification`)
-        .replace(/_dem/, 'DEM')
-        .replace(/Geojson/, 'GeoJSON');
-}
-
-function flowLayerTypeName(key) {
-    return key.split('-').map(k => k.replace(/(.)(.*)/, (_, _1, _2) => `${_1.toUpperCase()}${_2}`)).concat('LayerSpecification').join('');
-}
-
-function flowLayer(key) {
-    const layer = spec.layer;
-
-    layer.type = {
-        type: 'enum',
-        values: [key],
-        required: true
-    };
-
-    delete layer.ref;
-    delete layer['paint.*'];
-
-    layer.paint.type = () => {
-        return flowObject(spec[`paint_${key}`], '    ', '|');
-    };
-
-    layer.layout.type = () => {
-        return flowObject(spec[`layout_${key}`], '    ', '|');
-    };
-
-    if (key === 'background') {
-        delete layer.source;
-        delete layer['source-layer'];
-        delete layer.filter;
-    } else {
-        layer.source.required = true;
-    }
-
-    return flowObjectDeclaration(flowLayerTypeName(key), layer);
-}
-
-const layerTypes = Object.keys(spec.layer.type.values);
-
-fs.writeFileSync('src/style-spec/types.js', `// @flow
-// Generated code; do not edit. Edit build/generate-flow-typed-style-spec.js instead.
-/* eslint-disable */
-
-export type ColorSpecification = string;
-
-export type FormattedSpecification = string;
-
-export type ResolvedImageSpecification = string;
-
-export type PromoteIdSpecification = {[_: string]: string} | string;
-
-export type FilterSpecification =
-    | ['has', string]
-    | ['!has', string]
-    | ['==', string, string | number | boolean]
-    | ['!=', string, string | number | boolean]
-    | ['>', string, string | number | boolean]
-    | ['>=', string, string | number | boolean]
-    | ['<', string, string | number | boolean]
-    | ['<=', string, string | number | boolean]
-    | Array<string | FilterSpecification>; // Can't type in, !in, all, any, none -- https://github.com/facebook/flow/issues/2443
-
-export type TransitionSpecification = {
-    duration?: number,
-    delay?: number
-};
-
-// Note: doesn't capture interpolatable vs. non-interpolatable types.
-
-export type CameraFunctionSpecification<T> =
-    | {| type: 'exponential', stops: Array<[number, T]> |}
-    | {| type: 'interval',    stops: Array<[number, T]> |};
-
-export type SourceFunctionSpecification<T> =
-    | {| type: 'exponential', stops: Array<[number, T]>, property: string, default?: T |}
-    | {| type: 'interval',    stops: Array<[number, T]>, property: string, default?: T |}
-    | {| type: 'categorical', stops: Array<[string | number | boolean, T]>, property: string, default?: T |}
-    | {| type: 'identity', property: string, default?: T |};
-
-export type CompositeFunctionSpecification<T> =
-    | {| type: 'exponential', stops: Array<[{zoom: number, value: number}, T]>, property: string, default?: T |}
-    | {| type: 'interval',    stops: Array<[{zoom: number, value: number}, T]>, property: string, default?: T |}
-    | {| type: 'categorical', stops: Array<[{zoom: number, value: string | number | boolean}, T]>, property: string, default?: T |};
-
-export type ExpressionSpecification = Array<mixed>;
-
-export type PropertyValueSpecification<T> =
-    | T
-    | CameraFunctionSpecification<T>
-    | ExpressionSpecification;
-
-export type DataDrivenPropertyValueSpecification<T> =
-    | T
-    | CameraFunctionSpecification<T>
-    | SourceFunctionSpecification<T>
-    | CompositeFunctionSpecification<T>
-    | ExpressionSpecification;
-
-${flowObjectDeclaration('StyleSpecification', spec.$root)}
-
-${flowObjectDeclaration('LightSpecification', spec.light)}
-
-${spec.source.map(key => flowObjectDeclaration(flowSourceTypeName(key), spec[key])).join('\n\n')}
-
-export type SourceSpecification =
-${spec.source.map(key => `    | ${flowSourceTypeName(key)}`).join('\n')}
-
-${layerTypes.map(key => flowLayer(key)).join('\n\n')}
-
-export type LayerSpecification =
-${layerTypes.map(key => `    | ${flowLayerTypeName(key)}`).join('\n')};
-
-`);

package/build/generate-release-list.js

@@ -1,21 +0,0 @@
-const octokit = require('@octokit/rest')();
-const fs = require('fs');
-
-const list = {};
-
-octokit
-    .paginate(octokit.repos.listReleases.endpoint({
-        owner: 'mapbox',
-        repo: 'mapbox-gl-js'
-    }))
-    .then(releases => {
-        releases.filter(release => release.tag_name.match(/^v\d+\.\d+\.\d+(-\w+)?/)).forEach(release => {
-            list[release.tag_name] = {
-                released: release.published_at,
-                prerelease: release.prerelease
-            };
-        });
-
-        fs.writeFileSync('dist/versions.json', JSON.stringify(list, null, 4) + '\n');
-        fs.writeFileSync('dist/versions.jsonp', 'const mapboxglVersions = ' + JSON.stringify(list, null, 4) + ';\n');
-    });

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    ')}
-};
-`);