@scoova/mgl 1.0.0

package/build/generate-style-code.ts

@@ -0,0 +1,283 @@
+'use strict';
+
+import * as fs from 'fs';
+
+import {v8} from '@maplibre/maplibre-gl-style-spec';
+
+function camelCase(str: string): string {
+    return str.replace(/-(.)/g, (_, x) => {
+        return x.toUpperCase();
+    });
+}
+
+function pascalCase(str: string): string {
+    const almostCamelized = camelCase(str);
+    return almostCamelized[0].toUpperCase() + almostCamelized.slice(1);
+}
+
+function nativeType(property) {
+    switch (property.type) {
+        case 'boolean':
+            return 'boolean';
+        case 'number':
+            return 'number';
+        case 'string':
+            return 'string';
+        case 'enum':
+            return Object.keys(property.values).map(v => JSON.stringify(v)).join(' | ');
+        case 'color':
+            return 'Color';
+        case 'padding':
+            return 'Padding';
+        case 'variableAnchorOffsetCollection':
+            return 'VariableAnchorOffsetCollection';
+        case 'sprite':
+            return 'Sprite';
+        case 'formatted':
+            return 'Formatted';
+        case 'resolvedImage':
+            return 'ResolvedImage';
+        case 'array':
+            if (property.length) {
+                return `[${new Array(property.length).fill(nativeType({type: property.value})).join(', ')}]`;
+            } else {
+                return `Array<${nativeType({type: property.value, values: property.values})}>`;
+            }
+        default: throw new Error(`unknown type "${property.type}" for "${property.name}"`);
+    }
+}
+
+function possiblyEvaluatedType(property)  {
+    const propType = nativeType(property);
+
+    switch (property['property-type']) {
+        case 'color-ramp':
+            return 'ColorRampProperty';
+        case 'cross-faded':
+            return `CrossFaded<${propType}>`;
+        case 'cross-faded-data-driven':
+            return `PossiblyEvaluatedPropertyValue<CrossFaded<${propType}>>`;
+        case 'data-driven':
+            return `PossiblyEvaluatedPropertyValue<${propType}>`;
+    }
+
+    return propType;
+}
+
+function propertyType(property) {
+    switch (property['property-type']) {
+        case 'data-driven':
+            return `DataDrivenProperty<${nativeType(property)}>`;
+        case 'cross-faded':
+            return `CrossFadedProperty<${nativeType(property)}>`;
+        case 'cross-faded-data-driven':
+            return `CrossFadedDataDrivenProperty<${nativeType(property)}>`;
+        case 'color-ramp':
+            return 'ColorRampProperty';
+        case 'data-constant':
+        case 'constant':
+            return `DataConstantProperty<${nativeType(property)}>`;
+        default:
+            throw new Error(`unknown property-type "${property['property-type']}" for ${property.name}`);
+    }
+}
+
+function runtimeType(property) {
+    switch (property.type) {
+        case 'boolean':
+            return 'BooleanType';
+        case 'number':
+            return 'NumberType';
+        case 'string':
+        case 'enum':
+            return 'StringType';
+        case 'color':
+            return 'ColorType';
+        case 'padding':
+            return 'PaddingType';
+        case 'variableAnchorOffsetCollection':
+            return 'VariableAnchorOffsetCollectionType';
+        case 'sprite':
+            return 'SpriteType';
+        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 "${property.type}" for "${property.name}"`);
+    }
+}
+
+function overrides(property) {
+    return `{ runtimeType: ${runtimeType(property)}, getOverride: (o) => o.${camelCase(property.name)}, hasOverride: (o) => !!o.${camelCase(property.name)} }`;
+}
+
+function propertyValue(property, type) {
+    const propertyAsSpec = `styleSpec["${type}_${property.layerType}"]["${property.name}"] as any as StylePropertySpecification`;
+
+    switch (property['property-type']) {
+        case 'data-driven':
+            if (property.overridable) {
+                return `new DataDrivenProperty(${propertyAsSpec}, ${overrides(property)})`;
+            } else {
+                return `new DataDrivenProperty(${propertyAsSpec})`;
+            }
+        case 'cross-faded':
+            return `new CrossFadedProperty(${propertyAsSpec})`;
+        case 'cross-faded-data-driven':
+            return `new CrossFadedDataDrivenProperty(${propertyAsSpec})`;
+        case 'color-ramp':
+            return `new ColorRampProperty(${propertyAsSpec})`;
+        case 'data-constant':
+        case 'constant':
+            return `new DataConstantProperty(${propertyAsSpec})`;
+        default:
+            throw new Error(`unknown property-type "${property['property-type']}" for ${property.name}`);
+    }
+}
+
+const layers = Object.keys(v8.layer.type.values).map((type) => {
+    const layoutProperties = Object.keys(v8[`layout_${type}`]).reduce((memo, name) => {
+        if (name !== 'visibility') {
+            v8[`layout_${type}`][name].name = name;
+            v8[`layout_${type}`][name].layerType = type;
+            memo.push(v8[`layout_${type}`][name]);
+        }
+        return memo;
+    }, []);
+
+    const paintProperties = Object.keys(v8[`paint_${type}`]).reduce((memo, name) => {
+        v8[`paint_${type}`][name].name = name;
+        v8[`paint_${type}`][name].layerType = type;
+        memo.push(v8[`paint_${type}`][name]);
+        return memo;
+    }, []);
+
+    return {type, layoutProperties, paintProperties};
+});
+
+function emitlayerProperties(locals) {
+    const output = [];
+    const layerType = pascalCase(locals.type);
+    const {
+        layoutProperties,
+        paintProperties
+    } = locals;
+
+    output.push(
+        `// This file is generated. Edit build/generate-style-code.ts, then run 'npm run codegen'.
+/* eslint-disable */
+
+import {latest as styleSpec} from '@maplibre/maplibre-gl-style-spec';
+
+import {
+    Properties,
+    DataConstantProperty,
+    DataDrivenProperty,
+    CrossFadedDataDrivenProperty,
+    CrossFadedProperty,
+    ColorRampProperty,
+    PossiblyEvaluatedPropertyValue,
+    CrossFaded
+} from '../properties';
+
+import type {Color, Formatted, Padding, ResolvedImage, VariableAnchorOffsetCollection} from '@maplibre/maplibre-gl-style-spec';
+import {StylePropertySpecification} from '@maplibre/maplibre-gl-style-spec';
+`);
+
+    const overridables = paintProperties.filter(p => p.overridable);
+    if (overridables.length) {
+        const overridesArray = `import {
+            ${overridables.reduce((imports, prop) => { imports.push(runtimeType(prop)); return imports; }, []).join(',\n    ')}
+        } from '@maplibre/maplibre-gl-style-spec';
+        `;
+        output.push(overridesArray);
+    }
+
+    if (layoutProperties.length) {
+        output.push(
+            `export type ${layerType}LayoutProps = {`);
+
+        for (const property of layoutProperties) {
+            output.push(
+                `    "${property.name}": ${propertyType(property)},`);
+        }
+
+        output.push(
+            `};
+
+export type ${layerType}LayoutPropsPossiblyEvaluated = {`);
+
+        for (const property of layoutProperties) {
+            output.push(
+                `    "${property.name}": ${possiblyEvaluatedType(property)},`);
+        }
+
+        output.push(
+            `};
+
+let layout: Properties<${layerType}LayoutProps>;
+const getLayout = () => layout = layout || new Properties({`);
+
+        for (const property of layoutProperties) {
+            output.push(
+                `    "${property.name}": ${propertyValue(property, 'layout')},`);
+        }
+
+        output.push(
+            '});');
+    }
+
+    if (paintProperties.length) {
+        output.push(
+            `
+export type ${layerType}PaintProps = {`);
+
+        for (const property of paintProperties) {
+            output.push(
+                `    "${property.name}": ${propertyType(property)},`);
+        }
+
+        output.push(
+            `};
+
+export type ${layerType}PaintPropsPossiblyEvaluated = {`);
+
+        for (const property of paintProperties) {
+            output.push(
+                `    "${property.name}": ${possiblyEvaluatedType(property)},`);
+        }
+
+        output.push(
+            '};');
+    } else {
+        output.push(
+            `export type ${layerType}PaintProps = {};`);
+    }
+
+    output.push(
+        `
+let paint: Properties<${layerType}PaintProps>;
+const getPaint = () => paint = paint || new Properties({`);
+
+    for (const property of paintProperties) {
+        output.push(
+            `    "${property.name}": ${propertyValue(property, 'paint')},`);
+    }
+
+    output.push(
+        `});
+
+export default ({ get paint() { return getPaint() }${layoutProperties.length ? ', get layout() { return getLayout() }' : ''} });`);
+
+    return output.join('\n');
+}
+
+for (const layer of layers) {
+    fs.writeFileSync(`src/style/style_layer/${layer.type.replace('-', '_')}_style_layer_properties.g.ts`, emitlayerProperties(layer));
+}

package/build/readme.md

@@ -0,0 +1,56 @@
+# Build Scripts
+
+This folder holds common build scripts accessed via the various `npm run` commands.
+Codegen is executed when calling `npm install` in order to generate all artifacts needed for the build to pass
+
+## Bundeling all the code
+
+The bundling process can be split into several steps:
+
+`npm run build-css`
+This command will compile the css code and create the css file.
+
+`npm run build-prod` and `npm run build-dev`
+These commands will use rollup to bundle the code. This is where the magic happens and uses some files in this folder.
+
+`banner.ts` is used to create a banner at the beginning of the output file
+
+`rollup_plugins.ts` is used to define common plugins for rollup configurations
+
+`rollup_plugin_minify_style_spec.ts` is used to specify the plugin used in style spec bundeling
+
+In the `rollup` folder there are some files that are used as linking files as they link to other files for rollup to pick when bundling.
+
+Rollup is generating 3 files throughout the process of bundling:
+
+`index.ts` a file containing all the code that will run in the main thread.
+
+`shared.ts` a file containing all the code shared between the main and worker code.
+
+`worker.ts` a file containing all the code the will run in the worker threads.
+
+These 3 files are then referenced and used by the `bundle_prelude.js` file. It allows loading the web worker code automatically in web workers without any extra effort from someone who would like to use the library, i.e. it simply works.
+
+<hr>
+
+### `npm run codegen`
+
+The `codegen` command runs the following three scripts, to update the corresponding code files based on the `v8.json` style source, and other data files. Contributors should run this command manually when the underlying style data is modified. The generated code files are then committed to the repo.
+
+#### generate-struct-arrays.ts
+
+Generates `data/array_types.ts`, which consists of:
+
+ - `StructArrayLayout_*` subclasses, one for each underlying memory layout
+ - Named exports mapping each conceptual array type (e.g., `CircleLayoutArray`) to its corresponding `StructArrayLayout` class
+ - Specific named `StructArray` subclasses, when type-specific struct accessors are needed (e.g., `CollisionBoxArray`)
+
+#### generate-style-code.ts
+
+Generates the various `style/style_layer/[layer type]_style_layer_properties.ts` code files based on the content of `v8.json`. These files provide the type signatures for the paint and layout properties for each type of style layer.
+
+<hr>
+
+### Generate Release Nodes
+
+`release-notes.js` Used to generate release notes when releasing a new version

package/build/release-notes.js

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+
+import * as fs from 'fs';
+import semver from 'semver';
+
+const changelogPath = 'CHANGELOG.md';
+const changelog = fs.readFileSync(changelogPath, 'utf8');
+
+/*
+  Parse the raw changelog text and split it into individual releases.
+
+  This regular expression:
+    - Matches lines starting with "## x.x.x".
+    - Groups the version number.
+    - Skips the (optional) release date.
+    - Groups the changelog content.
+    - Ends when another "## x.x.x" is found.
+*/
+const regex = /^## (\d+\.\d+\.\d+.*?)\n(.+?)(?=\n^## \d+\.\d+\.\d+.*?\n)/gms;
+
+let releaseNotes = [];
+let match;
+// eslint-disable-next-line no-cond-assign
+while (match = regex.exec(changelog)) {
+    releaseNotes.push({
+        'version': match[1],
+        'changelog': match[2].trim(),
+    });
+}
+
+const latest = releaseNotes[0];
+const previous = releaseNotes[1];
+
+
+//  Print the release notes template.
+
+const templatedReleaseNotes = `https://github.com/maplibre/maplibre-gl-js
+[Changes](https://github.com/maplibre/maplibre-gl-js/compare/v${previous.version}...v${latest.version}) since [MapLibre GL JS v${previous.version}](https://github.com/maplibre/releases/tag/v${previous.version}):
+
+${latest.changelog}
+
+${semver.prerelease(latest.version) ? 'Pre-release version' : ''}`;
+
+// eslint-disable-next-line eol-last
+process.stdout.write(templatedReleaseNotes.trimEnd());

package/build/rollup/bundle_prelude.js

@@ -0,0 +1,29 @@
+/* eslint-disable */
+
+var maplibregl = {};
+var modules = {};
+function define(moduleName, _dependencies, moduleFactory) {
+    modules[moduleName] = moduleFactory;
+
+    // to get the list of modules see generated dist/maplibre-gl-dev.js file (look for `define(` calls)
+    if (moduleName !== 'index') {
+        return;
+    }
+
+    // we assume that when an index module is initializing then other modules are loaded already
+    var workerBundleString = 'var sharedModule = {}; (' + modules.shared + ')(sharedModule); (' + modules.worker + ')(sharedModule);'
+
+    var sharedModule = {};
+    // the order of arguments of a module factory depends on rollup (it decides who is whose dependency)
+    // to check the correct order, see dist/maplibre-gl-dev.js file (look for `define(` calls)
+    // we assume that for our 3 chunks it will generate 3 modules and their order is predefined like the following
+    modules.shared(sharedModule);
+    modules.index(maplibregl, sharedModule);
+
+    if (typeof window !== 'undefined') {
+        maplibregl.setWorkerUrl(window.URL.createObjectURL(new Blob([workerBundleString], { type: 'text/javascript' })));
+    }
+
+    return maplibregl;
+};
+

package/build/rollup/maplibregl.js

@@ -0,0 +1,22 @@
+//
+// Our custom intro provides a specialized "define()" function, called by the
+// AMD modules below, that sets up the worker blob URL and then executes the
+// main module, storing its exported value as 'maplibregl'
+
+// The three "chunks" imported here are produced by a first Rollup pass,
+// which outputs them as AMD modules.
+
+// Shared dependencies
+import '../../staging/maplibregl/shared';
+
+// Worker and its unique dependencies
+// When this wrapper function is passed to our custom define() in build/rollup/bundle_prelude.js,
+// it gets stringified, together with the shared wrapper (using
+// Function.toString()), and the resulting string of code is made into a
+// Blob URL that gets used by the main module to create the web workers.
+import '../../staging/maplibregl/worker';
+
+// Main module and its dependencies
+import '../../staging/maplibregl/index';
+
+export default maplibregl;

package/build/rollup_plugins.ts

@@ -0,0 +1,58 @@
+
+import typescript from '@rollup/plugin-typescript';
+import resolve from '@rollup/plugin-node-resolve';
+import replace from '@rollup/plugin-replace';
+import commonjs from '@rollup/plugin-commonjs';
+import terser from '@rollup/plugin-terser';
+import strip from '@rollup/plugin-strip';
+import {Plugin} from 'rollup';
+import json from '@rollup/plugin-json';
+
+// Common set of plugins/transformations shared across different rollup
+// builds (main maplibre bundle, style-spec package, benchmarks bundle)
+
+export const nodeResolve = resolve({
+    browser: true,
+    preferBuiltins: false
+});
+
+export const plugins = (production: boolean, minified: boolean): Plugin[] => [
+    json(),
+    // https://github.com/zaach/jison/issues/351
+    replace({
+        preventAssignment: true,
+        include: /\/jsonlint-lines-primitives\/lib\/jsonlint.js/,
+        delimiters: ['', ''],
+        values: {
+            '_token_stack:': ''
+        }
+    }),
+    production && strip({
+        sourceMap: true,
+        functions: ['PerformanceUtils.*']
+    }),
+    minified && terser({
+        compress: {
+            // eslint-disable-next-line camelcase
+            pure_getters: true,
+            passes: 3
+        },
+        sourceMap: true
+    }),
+    nodeResolve,
+    typescript(),
+    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) as Plugin[];
+
+export const watchStagingPlugin: Plugin = {
+    name: 'watch-external',
+    buildStart() {
+        this.addWatchFile('staging/maplibregl/index.js');
+        this.addWatchFile('staging/maplibregl/shared.js');
+        this.addWatchFile('staging/maplibregl/worker.js');
+    }
+};

package/dist/LICENSE.txt

@@ -0,0 +1,116 @@
+Copyright (c) 2023, MapLibre contributors
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright notice,
+      this list of conditions and the following disclaimer in the documentation
+      and/or other materials provided with the distribution.
+    * Neither the name of MapLibre GL JS nor the names of its contributors
+      may be used to endorse or promote products derived from this software
+      without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+-------------------------------------------------------------------------------
+
+Contains code from mapbox-gl-js v1.13 and earlier
+
+Version v1.13 of mapbox-gl-js and earlier are licensed under a BSD-3-Clause license
+
+Copyright (c) 2020, Mapbox
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice,
+  this list of conditions and the following disclaimer.
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+* Neither the name of Mapbox GL JS nor the names of its contributors
+  may be used to endorse or promote products derived from this software
+  without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+-------------------------------------------------------------------------------
+
+Contains code from glfx.js
+
+Copyright (C) 2011 by Evan Wallace
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+--------------------------------------------------------------------------------
+
+Contains a portion of d3-color https://github.com/d3/d3-color
+
+Copyright 2010-2016 Mike Bostock
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of the author nor the names of contributors may be used to
+  endorse or promote products derived from this software without specific prior
+  written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.