@mapwhit/tilerenderer 0.52.1 → 1.1.0

package/src/data/bucket/line_bucket.js

@@ -1,16 +1,16 @@
-const { LineLayoutArray } = require('../array_types');
-
-const { members: layoutAttributes } = require('./line_attributes');
-const SegmentVector = require('../segment');
-const { ProgramConfigurationSet } = require('../program_configuration');
-const { TriangleIndexArray } = require('../index_array_type');
-const EXTENT = require('../extent');
-const mvt = require('@mapwhit/vector-tile');
-const vectorTileFeatureTypes = mvt.VectorTileFeature.types;
-const { register } = require('../../util/transfer_registry');
-const { hasPattern, addPatternDependencies } = require('./pattern_bucket_features');
-const loadGeometry = require('../load_geometry');
-const EvaluationParameters = require('../../style/evaluation_parameters');
+import { VectorTileFeature } from '@mapwhit/vector-tile';
+import EvaluationParameters from '../../style/evaluation_parameters.js';
+import { LineLayoutArray } from '../array_types.js';
+import EXTENT from '../extent.js';
+import { TriangleIndexArray } from '../index_array_type.js';
+import loadGeometry from '../load_geometry.js';
+import { ProgramConfigurationSet } from '../program_configuration.js';
+import SegmentVector from '../segment.js';
+import layout from './line_attributes.js';
+import { addPatternDependencies, hasPattern } from './pattern_bucket_features.js';
+
+const layoutAttributes = layout.members;
+const vectorTileFeatureTypes = VectorTileFeature.types;
 
 // NOTE ON EXTRUDE SCALE:
 // scale the extrusion vector so that the normal length is this value.
@@ -75,7 +75,6 @@ class LineBucket {
     this.globalState = options.globalState;
     this.overscaling = options.overscaling;
     this.layers = options.layers;
-    this.layerIds = this.layers.map(layer => layer.id);
     this.index = options.index;
     this.features = [];
     this.hasPattern = false;
@@ -93,8 +92,9 @@ class LineBucket {
     for (const { feature, index, sourceLayerIndex } of features) {
       if (
         !this.layers[0]._featureFilter(new EvaluationParameters(this.zoom, { globalState: this.globalState }), feature)
-      )
+      ) {
         continue;
+      }
 
       const geometry = loadGeometry(feature);
 
@@ -112,7 +112,15 @@ class LineBucket {
       }
 
       if (this.hasPattern) {
-        this.features.push(addPatternDependencies('line', this.layers, patternFeature, this.zoom, options));
+        this.features.push(
+          addPatternDependencies(
+            'line',
+            this.layers,
+            patternFeature,
+            { zoom: this.zoom, globalState: this.globalState },
+            options
+          )
+        );
       } else {
         this.addFeature(patternFeature, geometry, index, {});
       }
@@ -122,7 +130,9 @@ class LineBucket {
   }
 
   update(states, vtLayer, imagePositions) {
-    if (!this.stateDependentLayers.length) return;
+    if (!this.stateDependentLayers.length) {
+      return;
+    }
     this.programConfigurations.updatePaintArrays(states, vtLayer, this.stateDependentLayers, {
       imagePositions,
       globalState: this.globalState
@@ -154,7 +164,9 @@ class LineBucket {
   }
 
   destroy() {
-    if (!this.layoutVertexBuffer) return;
+    if (!this.layoutVertexBuffer) {
+      return;
+    }
     this.layoutVertexBuffer.destroy();
     this.indexBuffer.destroy();
     this.programConfigurations.destroy();
@@ -162,7 +174,7 @@ class LineBucket {
   }
 
   addFeature(feature, geometry, index, imagePositions) {
-    const layout = this.layers[0].layout;
+    const layout = this.layers[0]._layout;
     const join = layout.get('line-join').evaluate(feature, {});
     const cap = layout.get('line-cap');
     const miterLimit = layout.get('line-miter-limit');
@@ -190,28 +202,32 @@ class LineBucket {
     const isPolygon = vectorTileFeatureTypes[feature.type] === 'Polygon';
 
     // If the line has duplicate vertices at the ends, adjust start/length to remove them.
+    const firstVertex = vertices[0];
+    const lastVertex = vertices[vertices.length - 1];
     let len = vertices.length;
-    while (len >= 2 && vertices[len - 1].equals(vertices[len - 2])) {
+    while (len >= 2 && lastVertex.equals(vertices[len - 2])) {
       len--;
     }
     let first = 0;
-    while (first < len - 1 && vertices[first].equals(vertices[first + 1])) {
+    while (first < len - 1 && firstVertex.equals(vertices[first + 1])) {
       first++;
     }
 
     // Ignore invalid geometry.
-    if (len < (isPolygon ? 3 : 2)) return;
+    if (len < (isPolygon ? 3 : 2)) {
+      return;
+    }
 
     if (lineDistances) {
       lineDistances.tileTotal = calculateFullDistance(vertices, first, len);
     }
 
-    if (join === 'bevel') miterLimit = 1.05;
+    if (join === 'bevel') {
+      miterLimit = 1.05;
+    }
 
     const sharpCornerOffset = SHARP_CORNER_OFFSET * (EXTENT / (512 * this.overscaling));
 
-    const firstVertex = vertices[first];
-
     // we could be more precise, but it would only save a negligible amount of space
     const segment = this.segments.prepareSegment(len * 10, this.layoutVertexArray, this.indexArray);
 
@@ -222,11 +238,8 @@ class LineBucket {
     let startOfLine = true;
     let currentVertex;
     let prevVertex;
-    let nextVertex;
     let prevNormal;
     let nextNormal;
-    let offsetA;
-    let offsetB;
 
     // the last three vertices added
     this.e1 = this.e2 = this.e3 = -1;
@@ -237,17 +250,23 @@ class LineBucket {
     }
 
     for (let i = first; i < len; i++) {
-      nextVertex =
+      const nextVertex =
         isPolygon && i === len - 1
           ? vertices[first + 1]
           : // if the line is closed, we treat the last vertex like the first
             vertices[i + 1]; // just the next vertex
 
       // if two consecutive vertices exist, skip the current one
-      if (nextVertex && vertices[i].equals(nextVertex)) continue;
+      if (nextVertex && vertices[i].equals(nextVertex)) {
+        continue;
+      }
 
-      if (nextNormal) prevNormal = nextNormal;
-      if (currentVertex) prevVertex = currentVertex;
+      if (nextNormal) {
+        prevNormal = nextNormal;
+      }
+      if (currentVertex) {
+        prevVertex = currentVertex;
+      }
 
       currentVertex = vertices[i];
 
@@ -322,156 +341,179 @@ class LineBucket {
       if (currentJoin === 'bevel') {
         // The maximum extrude length is 128 / 63 = 2 times the width of the line
         // so if miterLength >= 2 we need to draw a different type of bevel here.
-        if (miterLength > 2) currentJoin = 'flipbevel';
+        if (miterLength > 2) {
+          currentJoin = 'flipbevel';
+        }
 
         // If the miterLength is really small and the line bevel wouldn't be visible,
         // just draw a miter join to save a triangle.
-        if (miterLength < miterLimit) currentJoin = 'miter';
+        if (miterLength < miterLimit) {
+          currentJoin = 'miter';
+        }
       }
 
       // Calculate how far along the line the currentVertex is
-      if (prevVertex) this.distance += currentVertex.dist(prevVertex);
-
-      if (currentJoin === 'miter') {
-        joinNormal._mult(miterLength);
-        this.addCurrentVertex(currentVertex, this.distance, joinNormal, 0, 0, false, segment, lineDistances);
-      } else if (currentJoin === 'flipbevel') {
-        // miter is too big, flip the direction to make a beveled join
-
-        if (miterLength > 100) {
-          // Almost parallel lines
-          joinNormal = nextNormal.clone().mult(-1);
-        } else {
-          const direction = prevNormal.x * nextNormal.y - prevNormal.y * nextNormal.x > 0 ? -1 : 1;
-          const bevelLength = (miterLength * prevNormal.add(nextNormal).mag()) / prevNormal.sub(nextNormal).mag();
-          joinNormal._perp()._mult(bevelLength * direction);
-        }
-        this.addCurrentVertex(currentVertex, this.distance, joinNormal, 0, 0, false, segment, lineDistances);
-        this.addCurrentVertex(currentVertex, this.distance, joinNormal.mult(-1), 0, 0, false, segment, lineDistances);
-      } else if (currentJoin === 'bevel' || currentJoin === 'fakeround') {
-        const lineTurnsLeft = prevNormal.x * nextNormal.y - prevNormal.y * nextNormal.x > 0;
-        const offset = -Math.sqrt(miterLength * miterLength - 1);
-        if (lineTurnsLeft) {
-          offsetB = 0;
-          offsetA = offset;
-        } else {
-          offsetA = 0;
-          offsetB = offset;
-        }
+      if (prevVertex) {
+        this.distance += currentVertex.dist(prevVertex);
+      }
 
-        // Close previous segment with a bevel
-        if (!startOfLine) {
-          this.addCurrentVertex(
-            currentVertex,
-            this.distance,
-            prevNormal,
-            offsetA,
-            offsetB,
-            false,
-            segment,
-            lineDistances
-          );
-        }
+      switch (currentJoin) {
+        case 'miter':
+          joinNormal._mult(miterLength);
+          this.addCurrentVertex(currentVertex, this.distance, joinNormal, 0, 0, false, segment, lineDistances);
+          break;
+
+        case 'flipbevel':
+          // miter is too big, flip the direction to make a beveled join
+
+          if (miterLength > 100) {
+            // Almost parallel lines
+            joinNormal = nextNormal.clone().mult(-1);
+          } else {
+            const direction = prevNormal.x * nextNormal.y - prevNormal.y * nextNormal.x > 0 ? -1 : 1;
+            const bevelLength = (miterLength * prevNormal.add(nextNormal).mag()) / prevNormal.sub(nextNormal).mag();
+            joinNormal._perp()._mult(bevelLength * direction);
+          }
+          this.addCurrentVertex(currentVertex, this.distance, joinNormal, 0, 0, false, segment, lineDistances);
+          this.addCurrentVertex(currentVertex, this.distance, joinNormal.mult(-1), 0, 0, false, segment, lineDistances);
+          break;
+
+        case 'bevel':
+        case 'fakeround': {
+          const lineTurnsLeft = prevNormal.x * nextNormal.y - prevNormal.y * nextNormal.x > 0;
+          const offset = -Math.sqrt(miterLength * miterLength - 1);
+          let offsetA;
+          let offsetB;
+
+          if (lineTurnsLeft) {
+            offsetB = 0;
+            offsetA = offset;
+          } else {
+            offsetA = 0;
+            offsetB = offset;
+          }
 
-        if (currentJoin === 'fakeround') {
-          // The join angle is sharp enough that a round join would be visible.
-          // Bevel joins fill the gap between segments with a single pie slice triangle.
-          // Create a round join by adding multiple pie slices. The join isn't actually round, but
-          // it looks like it is at the sizes we render lines at.
-
-          // Add more triangles for sharper angles.
-          // This math is just a good enough approximation. It isn't "correct".
-          const n = Math.floor((0.5 - (cosHalfAngle - 0.5)) * 8);
-          let approxFractionalJoinNormal;
-
-          for (let m = 0; m < n; m++) {
-            approxFractionalJoinNormal = nextNormal
-              .mult((m + 1) / (n + 1))
-              ._add(prevNormal)
-              ._unit();
-            this.addPieSliceVertex(
+          // Close previous segment with a bevel
+          if (!startOfLine) {
+            this.addCurrentVertex(
               currentVertex,
               this.distance,
-              approxFractionalJoinNormal,
-              lineTurnsLeft,
+              prevNormal,
+              offsetA,
+              offsetB,
+              false,
               segment,
               lineDistances
             );
           }
 
-          this.addPieSliceVertex(currentVertex, this.distance, joinNormal, lineTurnsLeft, segment, lineDistances);
+          if (currentJoin === 'fakeround') {
+            // The join angle is sharp enough that a round join would be visible.
+            // Bevel joins fill the gap between segments with a single pie slice triangle.
+            // Create a round join by adding multiple pie slices. The join isn't actually round, but
+            // it looks like it is at the sizes we render lines at.
+
+            // Add more triangles for sharper angles.
+            // This math is just a good enough approximation. It isn't "correct".
+            const n = Math.floor((0.5 - (cosHalfAngle - 0.5)) * 8);
+            let approxFractionalJoinNormal;
+
+            for (let m = 0; m < n; m++) {
+              approxFractionalJoinNormal = nextNormal
+                .mult((m + 1) / (n + 1))
+                ._add(prevNormal)
+                ._unit();
+              this.addPieSliceVertex(
+                currentVertex,
+                this.distance,
+                approxFractionalJoinNormal,
+                lineTurnsLeft,
+                segment,
+                lineDistances
+              );
+            }
+
+            this.addPieSliceVertex(currentVertex, this.distance, joinNormal, lineTurnsLeft, segment, lineDistances);
+
+            for (let k = n - 1; k >= 0; k--) {
+              approxFractionalJoinNormal = prevNormal
+                .mult((k + 1) / (n + 1))
+                ._add(nextNormal)
+                ._unit();
+              this.addPieSliceVertex(
+                currentVertex,
+                this.distance,
+                approxFractionalJoinNormal,
+                lineTurnsLeft,
+                segment,
+                lineDistances
+              );
+            }
+          }
 
-          for (let k = n - 1; k >= 0; k--) {
-            approxFractionalJoinNormal = prevNormal
-              .mult((k + 1) / (n + 1))
-              ._add(nextNormal)
-              ._unit();
-            this.addPieSliceVertex(
+          // Start next segment
+          if (nextVertex) {
+            this.addCurrentVertex(
               currentVertex,
               this.distance,
-              approxFractionalJoinNormal,
-              lineTurnsLeft,
+              nextNormal,
+              -offsetA,
+              -offsetB,
+              false,
               segment,
               lineDistances
             );
           }
+          break;
         }
 
-        // Start next segment
-        if (nextVertex) {
-          this.addCurrentVertex(
-            currentVertex,
-            this.distance,
-            nextNormal,
-            -offsetA,
-            -offsetB,
-            false,
-            segment,
-            lineDistances
-          );
-        }
-      } else if (currentJoin === 'butt') {
-        if (!startOfLine) {
-          // Close previous segment with a butt
-          this.addCurrentVertex(currentVertex, this.distance, prevNormal, 0, 0, false, segment, lineDistances);
-        }
+        case 'butt':
+          if (!startOfLine) {
+            // Close previous segment with a butt
+            this.addCurrentVertex(currentVertex, this.distance, prevNormal, 0, 0, false, segment, lineDistances);
+          }
 
-        // Start next segment with a butt
-        if (nextVertex) {
-          this.addCurrentVertex(currentVertex, this.distance, nextNormal, 0, 0, false, segment, lineDistances);
-        }
-      } else if (currentJoin === 'square') {
-        if (!startOfLine) {
-          // Close previous segment with a square cap
-          this.addCurrentVertex(currentVertex, this.distance, prevNormal, 1, 1, false, segment, lineDistances);
+          // Start next segment with a butt
+          if (nextVertex) {
+            this.addCurrentVertex(currentVertex, this.distance, nextNormal, 0, 0, false, segment, lineDistances);
+          }
+          break;
 
-          // The segment is done. Unset vertices to disconnect segments.
-          this.e1 = this.e2 = -1;
-        }
+        case 'square':
+          if (!startOfLine) {
+            // Close previous segment with a square cap
+            this.addCurrentVertex(currentVertex, this.distance, prevNormal, 1, 1, false, segment, lineDistances);
 
-        // Start next segment
-        if (nextVertex) {
-          this.addCurrentVertex(currentVertex, this.distance, nextNormal, -1, -1, false, segment, lineDistances);
-        }
-      } else if (currentJoin === 'round') {
-        if (!startOfLine) {
-          // Close previous segment with butt
-          this.addCurrentVertex(currentVertex, this.distance, prevNormal, 0, 0, false, segment, lineDistances);
+            // The segment is done. Unset vertices to disconnect segments.
+            this.e1 = this.e2 = -1;
+          }
 
-          // Add round cap or linejoin at end of segment
-          this.addCurrentVertex(currentVertex, this.distance, prevNormal, 1, 1, true, segment, lineDistances);
+          // Start next segment
+          if (nextVertex) {
+            this.addCurrentVertex(currentVertex, this.distance, nextNormal, -1, -1, false, segment, lineDistances);
+          }
+          break;
 
-          // The segment is done. Unset vertices to disconnect segments.
-          this.e1 = this.e2 = -1;
-        }
+        case 'round':
+          if (!startOfLine) {
+            // Close previous segment with butt
+            this.addCurrentVertex(currentVertex, this.distance, prevNormal, 0, 0, false, segment, lineDistances);
 
-        // Start next segment with a butt
-        if (nextVertex) {
-          // Add round cap before first segment
-          this.addCurrentVertex(currentVertex, this.distance, nextNormal, -1, -1, true, segment, lineDistances);
+            // Add round cap or linejoin at end of segment
+            this.addCurrentVertex(currentVertex, this.distance, prevNormal, 1, 1, true, segment, lineDistances);
 
-          this.addCurrentVertex(currentVertex, this.distance, nextNormal, 0, 0, false, segment, lineDistances);
-        }
+            // The segment is done. Unset vertices to disconnect segments.
+            this.e1 = this.e2 = -1;
+          }
+
+          // Start next segment with a butt
+          if (nextVertex) {
+            // Add round cap before first segment
+            this.addCurrentVertex(currentVertex, this.distance, nextNormal, -1, -1, true, segment, lineDistances);
+
+            this.addCurrentVertex(currentVertex, this.distance, nextNormal, 0, 0, false, segment, lineDistances);
+          }
+          break;
       }
 
       if (isSharpCorner && i < len - 1) {
@@ -528,7 +570,9 @@ class LineBucket {
     }
 
     extrude = normal.clone();
-    if (endLeft) extrude._sub(normal.perp()._mult(endLeft));
+    if (endLeft) {
+      extrude._sub(normal.perp()._mult(endLeft));
+    }
     addLineVertex(layoutVertexArray, currentVertex, extrude, round, false, endLeft, distance);
     this.e3 = segment.vertexLength++;
     if (this.e1 >= 0 && this.e2 >= 0) {
@@ -539,7 +583,9 @@ class LineBucket {
     this.e2 = this.e3;
 
     extrude = normal.mult(-1);
-    if (endRight) extrude._sub(normal.perp()._mult(endRight));
+    if (endRight) {
+      extrude._sub(normal.perp()._mult(endRight));
+    }
     addLineVertex(layoutVertexArray, currentVertex, extrude, round, true, -endRight, distance);
     this.e3 = segment.vertexLength++;
     if (this.e1 >= 0 && this.e2 >= 0) {
@@ -574,7 +620,9 @@ class LineBucket {
     const layoutVertexArray = this.layoutVertexArray;
     const indexArray = this.indexArray;
 
-    if (distancesForScaling) distance = scaleDistance(distance, distancesForScaling);
+    if (distancesForScaling) {
+      distance = scaleDistance(distance, distancesForScaling);
+    }
 
     addLineVertex(layoutVertexArray, currentVertex, extrude, false, lineTurnsLeft, 0, distance);
     this.e3 = segment.vertexLength++;
@@ -619,17 +667,14 @@ function scaleDistance(tileDistance, stats) {
  * @private
  */
 function calculateFullDistance(vertices, first, len) {
-  let currentVertex;
-  let nextVertex;
   let total = 0;
-  for (let i = first; i < len - 1; i++) {
-    currentVertex = vertices[i];
-    nextVertex = vertices[i + 1];
-    total += currentVertex.dist(nextVertex);
+  let prev = vertices[first];
+  for (let i = first + 1; i < len; i++) {
+    const next = vertices[i];
+    total += prev.dist(next);
+    prev = next;
   }
   return total;
 }
 
-register('LineBucket', LineBucket, { omit: ['layers', 'features'] });
-
-module.exports = LineBucket;
+export default LineBucket;

package/src/data/bucket/pattern_attributes.js

@@ -1,9 +1,7 @@
-const { createLayout } = require('../../util/struct_array');
+import { createLayout } from '../../util/struct_array.js';
 
-const layout = createLayout([
+export default createLayout([
   // [tl.x, tl.y, br.x, br.y]
   { name: 'a_pattern_from', components: 4, type: 'Uint16' },
   { name: 'a_pattern_to', components: 4, type: 'Uint16' }
 ]);
-
-module.exports = layout;

package/src/data/bucket/pattern_bucket_features.js

@@ -1,9 +1,9 @@
-function hasPattern(type, layers, options) {
+export function hasPattern(type, layers, options) {
   const patterns = options.patternDependencies;
   let hasPattern = false;
 
   for (const layer of layers) {
-    const patternProperty = layer.paint.get(`${type}-pattern`);
+    const patternProperty = layer._paint.get(`${type}-pattern`);
     if (!patternProperty.isConstant()) {
       hasPattern = true;
     }
@@ -19,16 +19,16 @@ function hasPattern(type, layers, options) {
   return hasPattern;
 }
 
-function addPatternDependencies(type, layers, patternFeature, zoom, options) {
+export function addPatternDependencies(type, layers, patternFeature, { zoom, globalState }, options) {
   const patterns = options.patternDependencies;
   for (const layer of layers) {
-    const patternProperty = layer.paint.get(`${type}-pattern`);
+    const patternProperty = layer._paint.get(`${type}-pattern`);
 
     const patternPropertyValue = patternProperty.value;
     if (patternPropertyValue.kind !== 'constant') {
-      const min = patternPropertyValue.evaluate({ zoom: zoom - 1 }, patternFeature, {});
-      const mid = patternPropertyValue.evaluate({ zoom: zoom }, patternFeature, {});
-      const max = patternPropertyValue.evaluate({ zoom: zoom + 1 }, patternFeature, {});
+      const min = patternPropertyValue.evaluate({ zoom: zoom - 1, globalState }, patternFeature, {});
+      const mid = patternPropertyValue.evaluate({ zoom: zoom, globalState }, patternFeature, {});
+      const max = patternPropertyValue.evaluate({ zoom: zoom + 1, globalState }, patternFeature, {});
       // add to patternDependencies
       patterns[min] = true;
       patterns[mid] = true;
@@ -40,5 +40,3 @@ function addPatternDependencies(type, layers, patternFeature, zoom, options) {
   }
   return patternFeature;
 }
-
-module.exports = { hasPattern, addPatternDependencies };

package/src/data/bucket/symbol_attributes.js

@@ -1,17 +1,17 @@
-const { createLayout } = require('../../util/struct_array');
+import { createLayout } from '../../util/struct_array.js';
 
-const symbolLayoutAttributes = createLayout([
+export const symbolLayoutAttributes = createLayout([
   { name: 'a_pos_offset', components: 4, type: 'Int16' },
   { name: 'a_data', components: 4, type: 'Uint16' }
 ]);
 
-const dynamicLayoutAttributes = createLayout([{ name: 'a_projected_pos', components: 3, type: 'Float32' }], 4);
+export const dynamicLayoutAttributes = createLayout([{ name: 'a_projected_pos', components: 3, type: 'Float32' }], 4);
 
-const placementOpacityAttributes = createLayout([{ name: 'a_fade_opacity', components: 1, type: 'Uint32' }], 4);
+export const placementOpacityAttributes = createLayout([{ name: 'a_fade_opacity', components: 1, type: 'Uint32' }], 4);
 
-const collisionVertexAttributes = createLayout([{ name: 'a_placed', components: 2, type: 'Uint8' }], 4);
+export const collisionVertexAttributes = createLayout([{ name: 'a_placed', components: 2, type: 'Uint8' }], 4);
 
-const collisionBox = createLayout([
+export const collisionBox = createLayout([
   // the box is centered around the anchor point
   { type: 'Int16', name: 'anchorPointX' },
   { type: 'Int16', name: 'anchorPointY' },
@@ -36,7 +36,7 @@ const collisionBox = createLayout([
   { type: 'Int16', name: 'signedDistanceFromAnchor' }
 ]);
 
-const collisionBoxLayout = createLayout(
+export const collisionBoxLayout = createLayout(
   [
     // used to render collision boxes for debugging purposes
     { name: 'a_pos', components: 2, type: 'Int16' },
@@ -46,7 +46,7 @@ const collisionBoxLayout = createLayout(
   4
 );
 
-const collisionCircleLayout = createLayout(
+export const collisionCircleLayout = createLayout(
   [
     // used to render collision circles for debugging purposes
     { name: 'a_pos', components: 2, type: 'Int16' },
@@ -56,7 +56,7 @@ const collisionCircleLayout = createLayout(
   4
 );
 
-const placement = createLayout([
+export const placement = createLayout([
   { type: 'Int16', name: 'anchorX' },
   { type: 'Int16', name: 'anchorY' },
   { type: 'Uint16', name: 'glyphStartIndex' },
@@ -73,7 +73,7 @@ const placement = createLayout([
   { type: 'Uint8', name: 'hidden' }
 ]);
 
-const symbolInstance = createLayout([
+export const symbolInstance = createLayout([
   { type: 'Int16', name: 'anchorX' },
   { type: 'Int16', name: 'anchorY' },
   { type: 'Int16', name: 'horizontalPlacedTextSymbolIndex' },
@@ -90,24 +90,10 @@ const symbolInstance = createLayout([
   { type: 'Uint32', name: 'crossTileID' }
 ]);
 
-const glyphOffset = createLayout([{ type: 'Float32', name: 'offsetX' }]);
+export const glyphOffset = createLayout([{ type: 'Float32', name: 'offsetX' }]);
 
-const lineVertex = createLayout([
+export const lineVertex = createLayout([
   { type: 'Int16', name: 'x' },
   { type: 'Int16', name: 'y' },
   { type: 'Int16', name: 'tileUnitDistanceFromAnchor' }
 ]);
-
-module.exports = {
-  symbolLayoutAttributes,
-  dynamicLayoutAttributes,
-  placementOpacityAttributes,
-  collisionVertexAttributes,
-  collisionBox,
-  collisionBoxLayout,
-  collisionCircleLayout,
-  placement,
-  symbolInstance,
-  glyphOffset,
-  lineVertex
-};