@loaders.gl/gis 3.1.3 → 4.0.0-alpha.5

package/dist/lib/flat-geojson-to-binary.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/lib/flat-geojson-to-binary.ts"],"names":["earcut","flatGeojsonToBinary","features","geometryInfo","options","propArrayTypes","extractNumericPropTypes","numericPropKeys","Object","keys","filter","k","Array","fillArrays","PositionDataType","Float32Array","TEST_EXPORTS","feature","properties","key","val","deduceArrayType","pointPositionsCount","pointFeaturesCount","linePositionsCount","linePathsCount","lineFeaturesCount","polygonPositionsCount","polygonObjectsCount","polygonRingsCount","polygonFeaturesCount","coordLength","hasGlobalId","GlobalFeatureIdsDataType","length","Uint32Array","Uint16Array","points","type","positions","globalFeatureIds","featureIds","numericProps","fields","lines","pathIndices","polygons","polygonIndices","primitivePolygonIndices","triangles","object","propName","T","indexMap","pointPosition","pointFeature","linePosition","linePath","lineFeature","polygonPosition","polygonObject","polygonRing","polygonFeature","geometry","handlePoint","push","keepStringProperties","id","handleLineString","handlePolygon","Error","makeAccessorObjects","set","data","nPositions","fillNumericProperties","fill","i","il","indices","start","end","l","ll","startPosition","areas","nextIndices","undefined","endPosition","triangulatePolygon","polygonPositions","subarray","offset","holes","slice","map","n","t","tl","wrapProps","obj","size","returnObj","value","index","numericPropName","numericKeys","props","includes","x","constructor","Number","isFinite","Float64Array","Math","fround"],"mappings":"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","sourcesContent":["/* eslint-disable indent */\nimport {earcut} from '@math.gl/polygon';\nimport type {\n  BinaryAttribute,\n  BinaryFeatures,\n  FlatFeature,\n  FlatPoint,\n  FlatLineString,\n  FlatPolygon,\n  GeojsonGeometryInfo,\n  TypedArray\n} from '@loaders.gl/schema';\nimport {PropArrayConstructor, Lines, Points, Polygons} from './flat-geojson-to-binary-types';\n\n/**\n * Convert binary features to flat binary arrays. Similar to\n * `geojsonToBinary` helper function, except that it expects\n * a binary representation of the feature data, which enables\n * 2X-3X speed increase in parse speed, compared to using\n * geoJSON. See `binary-vector-tile/VectorTileFeature` for\n * data format detais\n *\n * @param features\n * @param geometryInfo\n * @param options\n * @returns filled arrays\n */\nexport function flatGeojsonToBinary(\n  features: FlatFeature[],\n  geometryInfo: GeojsonGeometryInfo,\n  options?: FlatGeojsonToBinaryOptions\n) {\n  const propArrayTypes = extractNumericPropTypes(features);\n  const numericPropKeys = Object.keys(propArrayTypes).filter((k) => propArrayTypes[k] !== Array);\n  return fillArrays(\n    features,\n    {\n      propArrayTypes,\n      ...geometryInfo\n    },\n    {\n      numericPropKeys: (options && options.numericPropKeys) || numericPropKeys,\n      PositionDataType: options ? options.PositionDataType : Float32Array\n    }\n  );\n}\n\n/**\n * Options for `flatGeojsonToBinary`\n */\nexport type FlatGeojsonToBinaryOptions = {\n  numericPropKeys?: string[];\n  PositionDataType?: Float32ArrayConstructor | Float64ArrayConstructor;\n};\n\nexport const TEST_EXPORTS = {\n  extractNumericPropTypes\n};\n\n/**\n * Extracts properties that are always numeric\n *\n * @param features\n * @returns object with numeric types\n */\nfunction extractNumericPropTypes(features: FlatFeature[]): {\n  [key: string]: PropArrayConstructor;\n} {\n  const propArrayTypes = {};\n  for (const feature of features) {\n    if (feature.properties) {\n      for (const key in feature.properties) {\n        // If property has not been seen before, or if property has been numeric\n        // in all previous features, check if numeric in this feature\n        // If not numeric, Array is stored to prevent rechecking in the future\n        // Additionally, detects if 64 bit precision is required\n        const val = feature.properties[key];\n        propArrayTypes[key] = deduceArrayType(val, propArrayTypes[key]);\n      }\n    }\n  }\n\n  return propArrayTypes;\n}\n\n/**\n * Fills coordinates into pre-allocated typed arrays\n *\n * @param features\n * @param geometryInfo\n * @param options\n * @returns an accessor object with value and size keys\n */\n// eslint-disable-next-line complexity\nfunction fillArrays(\n  features: FlatFeature[],\n  geometryInfo: GeojsonGeometryInfo & {\n    propArrayTypes: {[key: string]: PropArrayConstructor};\n  },\n  options: FlatGeojsonToBinaryOptions\n) {\n  const {\n    pointPositionsCount,\n    pointFeaturesCount,\n    linePositionsCount,\n    linePathsCount,\n    lineFeaturesCount,\n    polygonPositionsCount,\n    polygonObjectsCount,\n    polygonRingsCount,\n    polygonFeaturesCount,\n    propArrayTypes,\n    coordLength\n  } = geometryInfo;\n  const {numericPropKeys = [], PositionDataType = Float32Array} = options;\n  const hasGlobalId = features[0] && 'id' in features[0];\n  const GlobalFeatureIdsDataType = features.length > 65535 ? Uint32Array : Uint16Array;\n  const points: Points = {\n    type: 'Point',\n    positions: new PositionDataType(pointPositionsCount * coordLength),\n    globalFeatureIds: new GlobalFeatureIdsDataType(pointPositionsCount),\n    featureIds:\n      pointFeaturesCount > 65535\n        ? new Uint32Array(pointPositionsCount)\n        : new Uint16Array(pointPositionsCount),\n    numericProps: {},\n    properties: [],\n    fields: []\n  };\n  const lines: Lines = {\n    type: 'LineString',\n    pathIndices:\n      linePositionsCount > 65535\n        ? new Uint32Array(linePathsCount + 1)\n        : new Uint16Array(linePathsCount + 1),\n    positions: new PositionDataType(linePositionsCount * coordLength),\n    globalFeatureIds: new GlobalFeatureIdsDataType(linePositionsCount),\n    featureIds:\n      lineFeaturesCount > 65535\n        ? new Uint32Array(linePositionsCount)\n        : new Uint16Array(linePositionsCount),\n    numericProps: {},\n    properties: [],\n    fields: []\n  };\n  const polygons: Polygons = {\n    type: 'Polygon',\n    polygonIndices:\n      polygonPositionsCount > 65535\n        ? new Uint32Array(polygonObjectsCount + 1)\n        : new Uint16Array(polygonObjectsCount + 1),\n    primitivePolygonIndices:\n      polygonPositionsCount > 65535\n        ? new Uint32Array(polygonRingsCount + 1)\n        : new Uint16Array(polygonRingsCount + 1),\n    positions: new PositionDataType(polygonPositionsCount * coordLength),\n    triangles: [],\n    globalFeatureIds: new GlobalFeatureIdsDataType(polygonPositionsCount),\n    featureIds:\n      polygonFeaturesCount > 65535\n        ? new Uint32Array(polygonPositionsCount)\n        : new Uint16Array(polygonPositionsCount),\n    numericProps: {},\n    properties: [],\n    fields: []\n  };\n\n  // Instantiate numeric properties arrays; one value per vertex\n  for (const object of [points, lines, polygons]) {\n    for (const propName of numericPropKeys) {\n      // If property has been numeric in all previous features in which the property existed, check\n      // if numeric in this feature\n      const T = propArrayTypes[propName];\n      object.numericProps[propName] = new T(object.positions.length / coordLength) as TypedArray;\n    }\n  }\n\n  // Set last element of path/polygon indices as positions length\n  lines.pathIndices[linePathsCount] = linePositionsCount;\n  polygons.polygonIndices[polygonObjectsCount] = polygonPositionsCount;\n  polygons.primitivePolygonIndices[polygonRingsCount] = polygonPositionsCount;\n\n  const indexMap = {\n    pointPosition: 0,\n    pointFeature: 0,\n    linePosition: 0,\n    linePath: 0,\n    lineFeature: 0,\n    polygonPosition: 0,\n    polygonObject: 0,\n    polygonRing: 0,\n    polygonFeature: 0,\n    feature: 0\n  };\n\n  for (const feature of features) {\n    const geometry = feature.geometry;\n    const properties = feature.properties || {};\n\n    switch (geometry.type) {\n      case 'Point':\n        handlePoint(geometry, points, indexMap, coordLength, properties);\n        points.properties.push(keepStringProperties(properties, numericPropKeys));\n        if (hasGlobalId) {\n          points.fields.push({id: feature.id});\n        }\n        indexMap.pointFeature++;\n        break;\n      case 'LineString':\n        handleLineString(geometry, lines, indexMap, coordLength, properties);\n        lines.properties.push(keepStringProperties(properties, numericPropKeys));\n        if (hasGlobalId) {\n          lines.fields.push({id: feature.id});\n        }\n        indexMap.lineFeature++;\n        break;\n      case 'Polygon':\n        handlePolygon(geometry, polygons, indexMap, coordLength, properties);\n        polygons.properties.push(keepStringProperties(properties, numericPropKeys));\n        if (hasGlobalId) {\n          polygons.fields.push({id: feature.id});\n        }\n        indexMap.polygonFeature++;\n        break;\n      default:\n        throw new Error('Invalid geometry type');\n    }\n\n    indexMap.feature++;\n  }\n\n  // Wrap each array in an accessor object with value and size keys\n  return makeAccessorObjects(points, lines, polygons, coordLength);\n}\n\n/**\n * Fills (Multi)Point coordinates into points object of arrays\n *\n * @param geometry\n * @param points\n * @param indexMap\n * @param coordLength\n * @param properties\n */\nfunction handlePoint(\n  geometry: FlatPoint,\n  points: Points,\n  indexMap: {\n    pointPosition: number;\n    pointFeature: number;\n    linePosition?: number;\n    linePath?: number;\n    lineFeature?: number;\n    polygonPosition?: number;\n    polygonObject?: number;\n    polygonRing?: number;\n    polygonFeature?: number;\n    feature: number;\n  },\n  coordLength: number,\n  properties: {[x: string]: string | number | boolean | null}\n): void {\n  points.positions.set(geometry.data, indexMap.pointPosition * coordLength);\n\n  const nPositions = geometry.data.length / coordLength;\n  fillNumericProperties(points, properties, indexMap.pointPosition, nPositions);\n  points.globalFeatureIds.fill(\n    indexMap.feature,\n    indexMap.pointPosition,\n    indexMap.pointPosition + nPositions\n  );\n  points.featureIds.fill(\n    indexMap.pointFeature,\n    indexMap.pointPosition,\n    indexMap.pointPosition + nPositions\n  );\n\n  indexMap.pointPosition += nPositions;\n}\n\n/**\n * Fills (Multi)LineString coordinates into lines object of arrays\n *\n * @param geometry\n * @param lines\n * @param indexMap\n * @param coordLength\n * @param properties\n */\nfunction handleLineString(\n  geometry: FlatLineString,\n  lines: Lines,\n  indexMap: {\n    pointPosition?: number;\n    pointFeature?: number;\n    linePosition: number;\n    linePath: number;\n    lineFeature: number;\n    polygonPosition?: number;\n    polygonObject?: number;\n    polygonRing?: number;\n    polygonFeature?: number;\n    feature: number;\n  },\n  coordLength: number,\n  properties: {[x: string]: string | number | boolean | null}\n): void {\n  lines.positions.set(geometry.data, indexMap.linePosition * coordLength);\n\n  const nPositions = geometry.data.length / coordLength;\n  fillNumericProperties(lines, properties, indexMap.linePosition, nPositions);\n\n  lines.globalFeatureIds.fill(\n    indexMap.feature,\n    indexMap.linePosition,\n    indexMap.linePosition + nPositions\n  );\n  lines.featureIds.fill(\n    indexMap.lineFeature,\n    indexMap.linePosition,\n    indexMap.linePosition + nPositions\n  );\n\n  for (let i = 0, il = geometry.indices.length; i < il; ++i) {\n    // Extract range of data we are working with, defined by start\n    // and end indices (these index into the geometry.data array)\n    const start = geometry.indices[i];\n    const end =\n      i === il - 1\n        ? geometry.data.length // last line, so read to end of data\n        : geometry.indices[i + 1]; // start index for next line\n\n    lines.pathIndices[indexMap.linePath++] = indexMap.linePosition;\n    indexMap.linePosition += (end - start) / coordLength;\n  }\n}\n\n/**\n * Fills (Multi)Polygon coordinates into polygons object of arrays\n *\n * @param geometry\n * @param polygons\n * @param indexMap\n * @param coordLength\n * @param properties\n */\nfunction handlePolygon(\n  geometry: FlatPolygon,\n  polygons: Polygons,\n  indexMap: {\n    pointPosition?: number;\n    pointFeature?: number;\n    linePosition?: number;\n    linePath?: number;\n    lineFeature?: number;\n    polygonPosition: number;\n    polygonObject: number;\n    polygonRing: number;\n    polygonFeature: number;\n    feature: number;\n  },\n  coordLength: number,\n  properties: {[x: string]: string | number | boolean | null}\n): void {\n  polygons.positions.set(geometry.data, indexMap.polygonPosition * coordLength);\n\n  const nPositions = geometry.data.length / coordLength;\n  fillNumericProperties(polygons, properties, indexMap.polygonPosition, nPositions);\n  polygons.globalFeatureIds.fill(\n    indexMap.feature,\n    indexMap.polygonPosition,\n    indexMap.polygonPosition + nPositions\n  );\n  polygons.featureIds.fill(\n    indexMap.polygonFeature,\n    indexMap.polygonPosition,\n    indexMap.polygonPosition + nPositions\n  );\n\n  // Unlike Point & LineString geometry.indices is a 2D array\n  for (let l = 0, ll = geometry.indices.length; l < ll; ++l) {\n    const startPosition = indexMap.polygonPosition;\n    polygons.polygonIndices[indexMap.polygonObject++] = startPosition;\n\n    const areas = geometry.areas[l];\n    const indices = geometry.indices[l];\n    const nextIndices = geometry.indices[l + 1];\n\n    for (let i = 0, il = indices.length; i < il; ++i) {\n      const start = indices[i];\n      const end =\n        i === il - 1\n          ? // last line, so either read to:\n            nextIndices === undefined\n            ? geometry.data.length // end of data (no next indices)\n            : nextIndices[0] // start of first line in nextIndices\n          : indices[i + 1]; // start index for next line\n\n      polygons.primitivePolygonIndices[indexMap.polygonRing++] = indexMap.polygonPosition;\n      indexMap.polygonPosition += (end - start) / coordLength;\n    }\n\n    const endPosition = indexMap.polygonPosition;\n    triangulatePolygon(polygons, areas, indices, {startPosition, endPosition, coordLength});\n  }\n}\n\n/**\n * Triangulate polygon using earcut\n *\n * @param polygons\n * @param areas\n * @param indices\n * @param param3\n */\nfunction triangulatePolygon(\n  polygons: Polygons,\n  areas: number[],\n  indices: number[],\n  {\n    startPosition,\n    endPosition,\n    coordLength\n  }: {startPosition: number; endPosition: number; coordLength: number}\n): void {\n  const start = startPosition * coordLength;\n  const end = endPosition * coordLength;\n\n  // Extract positions and holes for just this polygon\n  const polygonPositions = polygons.positions.subarray(start, end);\n\n  // Holes are referenced relative to outer polygon\n  const offset = indices[0];\n  const holes = indices.slice(1).map((n: number) => (n - offset) / coordLength);\n\n  // Compute triangulation\n  const triangles = earcut(polygonPositions, holes, coordLength, areas);\n\n  // Indices returned by triangulation are relative to start\n  // of polygon, so we need to offset\n  for (let t = 0, tl = triangles.length; t < tl; ++t) {\n    polygons.triangles.push(startPosition + triangles[t]);\n  }\n}\n\n/**\n * Wraps an object containing array into accessors\n *\n * @param obj\n * @param size\n */\nfunction wrapProps(\n  obj: {[key: string]: TypedArray},\n  size: number\n): {[key: string]: BinaryAttribute} {\n  const returnObj = {};\n  for (const key in obj) {\n    returnObj[key] = {value: obj[key], size};\n  }\n  return returnObj;\n}\n\n/**\n * Wrap each array in an accessor object with value and size keys\n *\n * @param points\n * @param lines\n * @param polygons\n * @param coordLength\n * @returns object\n */\nfunction makeAccessorObjects(\n  points: Points,\n  lines: Lines,\n  polygons: Polygons,\n  coordLength: number\n): BinaryFeatures {\n  return {\n    points: {\n      ...points,\n      positions: {value: points.positions, size: coordLength},\n      globalFeatureIds: {value: points.globalFeatureIds, size: 1},\n      featureIds: {value: points.featureIds, size: 1},\n      numericProps: wrapProps(points.numericProps, 1)\n    },\n    lines: {\n      ...lines,\n      positions: {value: lines.positions, size: coordLength},\n      pathIndices: {value: lines.pathIndices, size: 1},\n      globalFeatureIds: {value: lines.globalFeatureIds, size: 1},\n      featureIds: {value: lines.featureIds, size: 1},\n      numericProps: wrapProps(lines.numericProps, 1)\n    },\n    polygons: {\n      ...polygons,\n      positions: {value: polygons.positions, size: coordLength},\n      polygonIndices: {value: polygons.polygonIndices, size: 1},\n      primitivePolygonIndices: {value: polygons.primitivePolygonIndices, size: 1},\n      triangles: {value: new Uint32Array(polygons.triangles), size: 1},\n      globalFeatureIds: {value: polygons.globalFeatureIds, size: 1},\n      featureIds: {value: polygons.featureIds, size: 1},\n      numericProps: wrapProps(polygons.numericProps, 1)\n    }\n  };\n}\n\n/**\n * Add numeric properties to object\n *\n * @param object\n * @param properties\n * @param index\n * @param length\n */\nfunction fillNumericProperties(\n  object: Points | Lines | Polygons,\n  properties: {[x: string]: string | number | boolean | null},\n  index: number,\n  length: number\n): void {\n  for (const numericPropName in object.numericProps) {\n    if (numericPropName in properties) {\n      const value = properties[numericPropName] as number;\n      object.numericProps[numericPropName].fill(value, index, index + length);\n    }\n  }\n}\n\n/**\n * Keep string properties in object\n *\n * @param properties\n * @param numericKeys\n * @returns object\n */\nfunction keepStringProperties(\n  properties: {[x: string]: string | number | boolean | null},\n  numericKeys: string[]\n) {\n  const props = {};\n  for (const key in properties) {\n    if (!numericKeys.includes(key)) {\n      props[key] = properties[key];\n    }\n  }\n  return props;\n}\n\n/**\n *\n * Deduce correct array constructor to use for a given value\n *\n * @param x value to test\n * @param constructor previous constructor deduced\n * @returns PropArrayConstructor\n */\nfunction deduceArrayType(x: any, constructor: PropArrayConstructor): PropArrayConstructor {\n  if (constructor === Array || !Number.isFinite(x)) {\n    return Array;\n  }\n\n  // If this or previous value required 64bits use Float64Array\n  return constructor === Float64Array || Math.fround(x) !== x ? Float64Array : Float32Array;\n}\n"],"file":"flat-geojson-to-binary.js"}

package/dist/lib/geojson-to-binary.js

@@ -1,24 +1,21 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.geojsonToBinary = void 0;
-const extract_geometry_info_1 = require("./extract-geometry-info");
-const geojson_to_flat_geojson_1 = require("./geojson-to-flat-geojson");
-const flat_geojson_to_binary_1 = require("./flat-geojson-to-binary");
-/**
- * Convert GeoJSON features to flat binary arrays
- *
- * @param features
- * @param options
- * @returns features in binary format, grouped by geometry type
- */
-function geojsonToBinary(features, options = { fixRingWinding: true }) {
-    const geometryInfo = (0, extract_geometry_info_1.extractGeometryInfo)(features);
-    const coordLength = geometryInfo.coordLength;
-    const { fixRingWinding } = options;
-    const flatFeatures = (0, geojson_to_flat_geojson_1.geojsonToFlatGeojson)(features, { coordLength, fixRingWinding });
-    return (0, flat_geojson_to_binary_1.flatGeojsonToBinary)(flatFeatures, geometryInfo, {
-        numericPropKeys: options.numericPropKeys,
-        PositionDataType: options.PositionDataType || Float32Array
-    });
+import { extractGeometryInfo } from './extract-geometry-info';
+import { geojsonToFlatGeojson } from './geojson-to-flat-geojson';
+import { flatGeojsonToBinary } from './flat-geojson-to-binary';
+export function geojsonToBinary(features, options = {
+  fixRingWinding: true
+}) {
+  const geometryInfo = extractGeometryInfo(features);
+  const coordLength = geometryInfo.coordLength;
+  const {
+    fixRingWinding
+  } = options;
+  const flatFeatures = geojsonToFlatGeojson(features, {
+    coordLength,
+    fixRingWinding
+  });
+  return flatGeojsonToBinary(flatFeatures, geometryInfo, {
+    numericPropKeys: options.numericPropKeys,
+    PositionDataType: options.PositionDataType || Float32Array
+  });
 }
-exports.geojsonToBinary = geojsonToBinary;
+//# sourceMappingURL=geojson-to-binary.js.map

package/dist/lib/geojson-to-binary.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/lib/geojson-to-binary.ts"],"names":["extractGeometryInfo","geojsonToFlatGeojson","flatGeojsonToBinary","geojsonToBinary","features","options","fixRingWinding","geometryInfo","coordLength","flatFeatures","numericPropKeys","PositionDataType","Float32Array"],"mappings":"AAGA,SAAQA,mBAAR,QAAkC,yBAAlC;AACA,SAAQC,oBAAR,QAAmC,2BAAnC;AACA,SAAQC,mBAAR,QAAkC,0BAAlC;AAkBA,OAAO,SAASC,eAAT,CACLC,QADK,EAELC,OAA+B,GAAG;AAACC,EAAAA,cAAc,EAAE;AAAjB,CAF7B,EAGW;AAChB,QAAMC,YAAY,GAAGP,mBAAmB,CAACI,QAAD,CAAxC;AACA,QAAMI,WAAW,GAAGD,YAAY,CAACC,WAAjC;AACA,QAAM;AAACF,IAAAA;AAAD,MAAmBD,OAAzB;AACA,QAAMI,YAAY,GAAGR,oBAAoB,CAACG,QAAD,EAAW;AAACI,IAAAA,WAAD;AAAcF,IAAAA;AAAd,GAAX,CAAzC;AACA,SAAOJ,mBAAmB,CAACO,YAAD,EAAeF,YAAf,EAA6B;AACrDG,IAAAA,eAAe,EAAEL,OAAO,CAACK,eAD4B;AAErDC,IAAAA,gBAAgB,EAAEN,OAAO,CAACM,gBAAR,IAA4BC;AAFO,GAA7B,CAA1B;AAID","sourcesContent":["import type {Feature} from '@loaders.gl/schema';\nimport type {BinaryFeatures} from '@loaders.gl/schema';\n\nimport {extractGeometryInfo} from './extract-geometry-info';\nimport {geojsonToFlatGeojson} from './geojson-to-flat-geojson';\nimport {flatGeojsonToBinary} from './flat-geojson-to-binary';\n\n/**\n * Options for `geojsonToBinary`\n */\nexport type GeojsonToBinaryOptions = {\n  fixRingWinding: boolean;\n  numericPropKeys?: string[];\n  PositionDataType?: Float32ArrayConstructor | Float64ArrayConstructor;\n};\n\n/**\n * Convert GeoJSON features to flat binary arrays\n *\n * @param features\n * @param options\n * @returns features in binary format, grouped by geometry type\n */\nexport function geojsonToBinary(\n  features: Feature[],\n  options: GeojsonToBinaryOptions = {fixRingWinding: true}\n): BinaryFeatures {\n  const geometryInfo = extractGeometryInfo(features);\n  const coordLength = geometryInfo.coordLength;\n  const {fixRingWinding} = options;\n  const flatFeatures = geojsonToFlatGeojson(features, {coordLength, fixRingWinding});\n  return flatGeojsonToBinary(flatFeatures, geometryInfo, {\n    numericPropKeys: options.numericPropKeys,\n    PositionDataType: options.PositionDataType || Float32Array\n  });\n}\n"],"file":"geojson-to-binary.js"}

package/dist/lib/geojson-to-flat-geojson.js

@@ -1,128 +1,116 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.geojsonToFlatGeojson = void 0;
-const polygon_1 = require("@math.gl/polygon");
-/**
- * Convert GeoJSON features to Flat GeoJSON features
- *
- * @param features
- * @param options
- * @returns an Array of Flat GeoJSON features
- */
-function geojsonToFlatGeojson(features, options = { coordLength: 2, fixRingWinding: true }) {
-    return features.map((feature) => flattenFeature(feature, options));
+import { getPolygonSignedArea } from '@math.gl/polygon';
+export function geojsonToFlatGeojson(features, options = {
+  coordLength: 2,
+  fixRingWinding: true
+}) {
+  return features.map(feature => flattenFeature(feature, options));
 }
-exports.geojsonToFlatGeojson = geojsonToFlatGeojson;
-/**
- * Helper function to copy Point values from `coordinates` into `data` & `indices`
- *
- * @param coordinates
- * @param data
- * @param indices
- * @param options
- */
+
 function flattenPoint(coordinates, data, indices, options) {
-    indices.push(data.length);
-    data.push(...coordinates);
-    // Pad up to coordLength
-    for (let i = coordinates.length; i < options.coordLength; i++) {
-        data.push(0);
-    }
+  indices.push(data.length);
+  data.push(...coordinates);
+
+  for (let i = coordinates.length; i < options.coordLength; i++) {
+    data.push(0);
+  }
 }
-/**
- * Helper function to copy LineString values from `coordinates` into `data` & `indices`
- *
- * @param coordinates
- * @param data
- * @param indices
- * @param options
- */
+
 function flattenLineString(coordinates, data, indices, options) {
-    indices.push(data.length);
-    for (const c of coordinates) {
-        data.push(...c);
-        // Pad up to coordLength
-        for (let i = c.length; i < options.coordLength; i++) {
-            data.push(0);
-        }
+  indices.push(data.length);
+
+  for (const c of coordinates) {
+    data.push(...c);
+
+    for (let i = c.length; i < options.coordLength; i++) {
+      data.push(0);
     }
+  }
 }
-/**
- * Helper function to copy Polygon values from `coordinates` into `data` & `indices` & `areas`
- *
- * @param coordinates
- * @param data
- * @param indices
- * @param areas
- * @param options
- */
+
 function flattenPolygon(coordinates, data, indices, areas, options) {
-    let count = 0;
-    const ringAreas = [];
-    const polygons = [];
-    for (const lineString of coordinates) {
-        const lineString2d = lineString.map((p) => p.slice(0, 2));
-        let area = (0, polygon_1.getPolygonSignedArea)(lineString2d.flat());
-        const ccw = area < 0;
-        // Exterior ring must be CCW and interior rings CW
-        if (options.fixRingWinding && ((count === 0 && !ccw) || (count > 0 && ccw))) {
-            lineString.reverse();
-            area = -area;
-        }
-        ringAreas.push(area);
-        flattenLineString(lineString, data, polygons, options);
-        count++;
-    }
-    if (count > 0) {
-        areas.push(ringAreas);
-        indices.push(polygons);
+  let count = 0;
+  const ringAreas = [];
+  const polygons = [];
+
+  for (const lineString of coordinates) {
+    const lineString2d = lineString.map(p => p.slice(0, 2));
+    let area = getPolygonSignedArea(lineString2d.flat());
+    const ccw = area < 0;
+
+    if (options.fixRingWinding && (count === 0 && !ccw || count > 0 && ccw)) {
+      lineString.reverse();
+      area = -area;
     }
+
+    ringAreas.push(area);
+    flattenLineString(lineString, data, polygons, options);
+    count++;
+  }
+
+  if (count > 0) {
+    areas.push(ringAreas);
+    indices.push(polygons);
+  }
 }
-/**
- * Flatten single GeoJSON feature into Flat GeoJSON
- *
- * @param feature
- * @param options
- * @returns A Flat GeoJSON feature
- */
+
 function flattenFeature(feature, options) {
-    const { geometry } = feature;
-    if (geometry.type === 'GeometryCollection') {
-        throw new Error('GeometryCollection type not supported');
-    }
-    const data = [];
-    const indices = [];
-    let areas;
-    let type;
-    switch (geometry.type) {
-        case 'Point':
-            type = 'Point';
-            flattenPoint(geometry.coordinates, data, indices, options);
-            break;
-        case 'MultiPoint':
-            type = 'Point';
-            geometry.coordinates.map((c) => flattenPoint(c, data, indices, options));
-            break;
-        case 'LineString':
-            type = 'LineString';
-            flattenLineString(geometry.coordinates, data, indices, options);
-            break;
-        case 'MultiLineString':
-            type = 'LineString';
-            geometry.coordinates.map((c) => flattenLineString(c, data, indices, options));
-            break;
-        case 'Polygon':
-            type = 'Polygon';
-            areas = [];
-            flattenPolygon(geometry.coordinates, data, indices, areas, options);
-            break;
-        case 'MultiPolygon':
-            type = 'Polygon';
-            areas = [];
-            geometry.coordinates.map((c) => flattenPolygon(c, data, indices, areas, options));
-            break;
-        default:
-            throw new Error(`Unknown type: ${type}`);
+  const {
+    geometry
+  } = feature;
+
+  if (geometry.type === 'GeometryCollection') {
+    throw new Error('GeometryCollection type not supported');
+  }
+
+  const data = [];
+  const indices = [];
+  let areas;
+  let type;
+
+  switch (geometry.type) {
+    case 'Point':
+      type = 'Point';
+      flattenPoint(geometry.coordinates, data, indices, options);
+      break;
+
+    case 'MultiPoint':
+      type = 'Point';
+      geometry.coordinates.map(c => flattenPoint(c, data, indices, options));
+      break;
+
+    case 'LineString':
+      type = 'LineString';
+      flattenLineString(geometry.coordinates, data, indices, options);
+      break;
+
+    case 'MultiLineString':
+      type = 'LineString';
+      geometry.coordinates.map(c => flattenLineString(c, data, indices, options));
+      break;
+
+    case 'Polygon':
+      type = 'Polygon';
+      areas = [];
+      flattenPolygon(geometry.coordinates, data, indices, areas, options);
+      break;
+
+    case 'MultiPolygon':
+      type = 'Polygon';
+      areas = [];
+      geometry.coordinates.map(c => flattenPolygon(c, data, indices, areas, options));
+      break;
+
+    default:
+      throw new Error("Unknown type: ".concat(type));
+  }
+
+  return { ...feature,
+    geometry: {
+      type,
+      indices,
+      data,
+      areas
     }
-    return { ...feature, geometry: { type, indices, data, areas } };
+  };
 }
+//# sourceMappingURL=geojson-to-flat-geojson.js.map

package/dist/lib/geojson-to-flat-geojson.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/lib/geojson-to-flat-geojson.ts"],"names":["getPolygonSignedArea","geojsonToFlatGeojson","features","options","coordLength","fixRingWinding","map","feature","flattenFeature","flattenPoint","coordinates","data","indices","push","length","i","flattenLineString","c","flattenPolygon","areas","count","ringAreas","polygons","lineString","lineString2d","p","slice","area","flat","ccw","reverse","geometry","type","Error"],"mappings":"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","sourcesContent":["import {getPolygonSignedArea} from '@math.gl/polygon';\n\nimport {Feature, Position, FlatFeature} from '@loaders.gl/schema';\n\n/**\n * Options for `geojsonToFlatGeojson`\n */\nexport type GeojsonToFlatGeojsonOptions = {\n  coordLength: number;\n  fixRingWinding: boolean;\n};\n\n// Coordinates defining a Point\ntype PointCoordinates = Position;\n// Coordinates defining a LineString\ntype LineStringCoordinates = Position[];\n// Coordinates defining a Polygon\ntype PolygonCoordinates = Position[][];\n\n/**\n * Convert GeoJSON features to Flat GeoJSON features\n *\n * @param features\n * @param options\n * @returns an Array of Flat GeoJSON features\n */\nexport function geojsonToFlatGeojson(\n  features: Feature[],\n  options: GeojsonToFlatGeojsonOptions = {coordLength: 2, fixRingWinding: true}\n): FlatFeature[] {\n  return features.map((feature) => flattenFeature(feature, options));\n}\n\n/**\n * Helper function to copy Point values from `coordinates` into `data` & `indices`\n *\n * @param coordinates\n * @param data\n * @param indices\n * @param options\n */\nfunction flattenPoint(\n  coordinates: PointCoordinates,\n  data: number[],\n  indices: number[],\n  options: GeojsonToFlatGeojsonOptions\n) {\n  indices.push(data.length);\n  data.push(...coordinates);\n\n  // Pad up to coordLength\n  for (let i = coordinates.length; i < options.coordLength; i++) {\n    data.push(0);\n  }\n}\n\n/**\n * Helper function to copy LineString values from `coordinates` into `data` & `indices`\n *\n * @param coordinates\n * @param data\n * @param indices\n * @param options\n */\nfunction flattenLineString(\n  coordinates: LineStringCoordinates,\n  data: number[],\n  indices: number[],\n  options: GeojsonToFlatGeojsonOptions\n) {\n  indices.push(data.length);\n  for (const c of coordinates) {\n    data.push(...c);\n\n    // Pad up to coordLength\n    for (let i = c.length; i < options.coordLength; i++) {\n      data.push(0);\n    }\n  }\n}\n\n/**\n * Helper function to copy Polygon values from `coordinates` into `data` & `indices` & `areas`\n *\n * @param coordinates\n * @param data\n * @param indices\n * @param areas\n * @param options\n */\nfunction flattenPolygon(\n  coordinates: PolygonCoordinates,\n  data: number[],\n  indices: number[][],\n  areas: number[][],\n  options: GeojsonToFlatGeojsonOptions\n) {\n  let count = 0;\n  const ringAreas: number[] = [];\n  const polygons: number[] = [];\n  for (const lineString of coordinates) {\n    const lineString2d = lineString.map((p) => p.slice(0, 2));\n    let area = getPolygonSignedArea(lineString2d.flat());\n    const ccw = area < 0;\n\n    // Exterior ring must be CCW and interior rings CW\n    if (options.fixRingWinding && ((count === 0 && !ccw) || (count > 0 && ccw))) {\n      lineString.reverse();\n      area = -area;\n    }\n    ringAreas.push(area);\n    flattenLineString(lineString, data, polygons, options);\n    count++;\n  }\n\n  if (count > 0) {\n    areas.push(ringAreas);\n    indices.push(polygons);\n  }\n}\n\n/**\n * Flatten single GeoJSON feature into Flat GeoJSON\n *\n * @param feature\n * @param options\n * @returns A Flat GeoJSON feature\n */\nfunction flattenFeature(feature: Feature, options: GeojsonToFlatGeojsonOptions): FlatFeature {\n  const {geometry} = feature;\n  if (geometry.type === 'GeometryCollection') {\n    throw new Error('GeometryCollection type not supported');\n  }\n  const data = [];\n  const indices = [];\n  let areas;\n  let type;\n\n  switch (geometry.type) {\n    case 'Point':\n      type = 'Point';\n      flattenPoint(geometry.coordinates, data, indices, options);\n      break;\n    case 'MultiPoint':\n      type = 'Point';\n      geometry.coordinates.map((c) => flattenPoint(c, data, indices, options));\n      break;\n    case 'LineString':\n      type = 'LineString';\n      flattenLineString(geometry.coordinates, data, indices, options);\n      break;\n    case 'MultiLineString':\n      type = 'LineString';\n      geometry.coordinates.map((c) => flattenLineString(c, data, indices, options));\n      break;\n    case 'Polygon':\n      type = 'Polygon';\n      areas = [];\n      flattenPolygon(geometry.coordinates, data, indices, areas, options);\n      break;\n    case 'MultiPolygon':\n      type = 'Polygon';\n      areas = [];\n      geometry.coordinates.map((c) => flattenPolygon(c, data, indices, areas, options));\n      break;\n    default:\n      throw new Error(`Unknown type: ${type}`);\n  }\n\n  return {...feature, geometry: {type, indices, data, areas}};\n}\n"],"file":"geojson-to-flat-geojson.js"}

package/dist/lib/transform.js

@@ -1,59 +1,50 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformGeoJsonCoords = exports.transformBinaryCoords = void 0;
-/**
- * Apply transformation to every coordinate of binary features
- * @param  binaryFeatures binary features
- * @param  transformCoordinate Function to call on each coordinate
- * @return Transformed binary features
- */
-function transformBinaryCoords(binaryFeatures, transformCoordinate) {
-    if (binaryFeatures.points) {
-        transformBinaryGeometryPositions(binaryFeatures.points, transformCoordinate);
-    }
-    if (binaryFeatures.lines) {
-        transformBinaryGeometryPositions(binaryFeatures.lines, transformCoordinate);
-    }
-    if (binaryFeatures.polygons) {
-        transformBinaryGeometryPositions(binaryFeatures.polygons, transformCoordinate);
-    }
-    return binaryFeatures;
+export function transformBinaryCoords(binaryFeatures, transformCoordinate) {
+  if (binaryFeatures.points) {
+    transformBinaryGeometryPositions(binaryFeatures.points, transformCoordinate);
+  }
+
+  if (binaryFeatures.lines) {
+    transformBinaryGeometryPositions(binaryFeatures.lines, transformCoordinate);
+  }
+
+  if (binaryFeatures.polygons) {
+    transformBinaryGeometryPositions(binaryFeatures.polygons, transformCoordinate);
+  }
+
+  return binaryFeatures;
 }
-exports.transformBinaryCoords = transformBinaryCoords;
-/** Transform one binary geometry */
+
 function transformBinaryGeometryPositions(binaryGeometry, fn) {
-    const { positions } = binaryGeometry;
-    for (let i = 0; i < positions.value.length; i += positions.size) {
-        // @ts-ignore inclusion of bigint causes problems
-        const coord = Array.from(positions.value.subarray(i, i + positions.size));
-        const transformedCoord = fn(coord);
-        // @ts-ignore typescript typing for .set seems to require bigint?
-        positions.value.set(transformedCoord, i);
-    }
+  const {
+    positions
+  } = binaryGeometry;
+
+  for (let i = 0; i < positions.value.length; i += positions.size) {
+    const coord = Array.from(positions.value.subarray(i, i + positions.size));
+    const transformedCoord = fn(coord);
+    positions.value.set(transformedCoord, i);
+  }
 }
-/**
- * Apply transformation to every coordinate of GeoJSON features
- *
- * @param  features Array of GeoJSON features
- * @param  fn       Function to call on each coordinate
- * @return          Transformed GeoJSON features
- */
-function transformGeoJsonCoords(features, fn) {
-    for (const feature of features) {
-        // @ts-ignore
-        feature.geometry.coordinates = coordMap(feature.geometry.coordinates, fn);
-    }
-    return features;
+
+export function transformGeoJsonCoords(features, fn) {
+  for (const feature of features) {
+    feature.geometry.coordinates = coordMap(feature.geometry.coordinates, fn);
+  }
+
+  return features;
 }
-exports.transformGeoJsonCoords = transformGeoJsonCoords;
+
 function coordMap(array, fn) {
-    if (isCoord(array)) {
-        return fn(array);
-    }
-    return array.map((item) => {
-        return coordMap(item, fn);
-    });
+  if (isCoord(array)) {
+    return fn(array);
+  }
+
+  return array.map(item => {
+    return coordMap(item, fn);
+  });
 }
+
 function isCoord(array) {
-    return Number.isFinite(array[0]) && Number.isFinite(array[1]);
+  return Number.isFinite(array[0]) && Number.isFinite(array[1]);
 }
+//# sourceMappingURL=transform.js.map

package/dist/lib/transform.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/lib/transform.ts"],"names":["transformBinaryCoords","binaryFeatures","transformCoordinate","points","transformBinaryGeometryPositions","lines","polygons","binaryGeometry","fn","positions","i","value","length","size","coord","Array","from","subarray","transformedCoord","set","transformGeoJsonCoords","features","feature","geometry","coordinates","coordMap","array","isCoord","map","item","Number","isFinite"],"mappings":"AAUA,OAAO,SAASA,qBAAT,CACLC,cADK,EAELC,mBAFK,EAGW;AAChB,MAAID,cAAc,CAACE,MAAnB,EAA2B;AACzBC,IAAAA,gCAAgC,CAACH,cAAc,CAACE,MAAhB,EAAwBD,mBAAxB,CAAhC;AACD;;AACD,MAAID,cAAc,CAACI,KAAnB,EAA0B;AACxBD,IAAAA,gCAAgC,CAACH,cAAc,CAACI,KAAhB,EAAuBH,mBAAvB,CAAhC;AACD;;AACD,MAAID,cAAc,CAACK,QAAnB,EAA6B;AAC3BF,IAAAA,gCAAgC,CAACH,cAAc,CAACK,QAAhB,EAA0BJ,mBAA1B,CAAhC;AACD;;AACD,SAAOD,cAAP;AACD;;AAGD,SAASG,gCAAT,CAA0CG,cAA1C,EAA0EC,EAA1E,EAAmG;AACjG,QAAM;AAACC,IAAAA;AAAD,MAAcF,cAApB;;AACA,OAAK,IAAIG,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGD,SAAS,CAACE,KAAV,CAAgBC,MAApC,EAA4CF,CAAC,IAAID,SAAS,CAACI,IAA3D,EAAiE;AAE/D,UAAMC,KAAoB,GAAGC,KAAK,CAACC,IAAN,CAAWP,SAAS,CAACE,KAAV,CAAgBM,QAAhB,CAAyBP,CAAzB,EAA4BA,CAAC,GAAGD,SAAS,CAACI,IAA1C,CAAX,CAA7B;AACA,UAAMK,gBAAgB,GAAGV,EAAE,CAACM,KAAD,CAA3B;AAEAL,IAAAA,SAAS,CAACE,KAAV,CAAgBQ,GAAhB,CAAoBD,gBAApB,EAAsCR,CAAtC;AACD;AACF;;AASD,OAAO,SAASU,sBAAT,CACLC,QADK,EAELb,EAFK,EAGK;AACV,OAAK,MAAMc,OAAX,IAAsBD,QAAtB,EAAgC;AAE9BC,IAAAA,OAAO,CAACC,QAAR,CAAiBC,WAAjB,GAA+BC,QAAQ,CAACH,OAAO,CAACC,QAAR,CAAiBC,WAAlB,EAA+BhB,EAA/B,CAAvC;AACD;;AACD,SAAOa,QAAP;AACD;;AAED,SAASI,QAAT,CAAkBC,KAAlB,EAAyBlB,EAAzB,EAA6B;AAC3B,MAAImB,OAAO,CAACD,KAAD,CAAX,EAAoB;AAClB,WAAOlB,EAAE,CAACkB,KAAD,CAAT;AACD;;AAED,SAAOA,KAAK,CAACE,GAAN,CAAWC,IAAD,IAAU;AACzB,WAAOJ,QAAQ,CAACI,IAAD,EAAOrB,EAAP,CAAf;AACD,GAFM,CAAP;AAGD;;AAED,SAASmB,OAAT,CAAiBD,KAAjB,EAAwB;AACtB,SAAOI,MAAM,CAACC,QAAP,CAAgBL,KAAK,CAAC,CAAD,CAArB,KAA6BI,MAAM,CAACC,QAAP,CAAgBL,KAAK,CAAC,CAAD,CAArB,CAApC;AACD","sourcesContent":["import type {BinaryFeatures, BinaryGeometry} from '@loaders.gl/schema';\n\ntype TransformCoordinate = (coord: number[]) => number[];\n\n/**\n * Apply transformation to every coordinate of binary features\n * @param  binaryFeatures binary features\n * @param  transformCoordinate Function to call on each coordinate\n * @return Transformed binary features\n */\nexport function transformBinaryCoords(\n  binaryFeatures: BinaryFeatures,\n  transformCoordinate: TransformCoordinate\n): BinaryFeatures {\n  if (binaryFeatures.points) {\n    transformBinaryGeometryPositions(binaryFeatures.points, transformCoordinate);\n  }\n  if (binaryFeatures.lines) {\n    transformBinaryGeometryPositions(binaryFeatures.lines, transformCoordinate);\n  }\n  if (binaryFeatures.polygons) {\n    transformBinaryGeometryPositions(binaryFeatures.polygons, transformCoordinate);\n  }\n  return binaryFeatures;\n}\n\n/** Transform one binary geometry */\nfunction transformBinaryGeometryPositions(binaryGeometry: BinaryGeometry, fn: TransformCoordinate) {\n  const {positions} = binaryGeometry;\n  for (let i = 0; i < positions.value.length; i += positions.size) {\n    // @ts-ignore inclusion of bigint causes problems\n    const coord: Array<number> = Array.from(positions.value.subarray(i, i + positions.size));\n    const transformedCoord = fn(coord);\n    // @ts-ignore typescript typing for .set seems to require bigint?\n    positions.value.set(transformedCoord, i);\n  }\n}\n\n/**\n * Apply transformation to every coordinate of GeoJSON features\n *\n * @param  features Array of GeoJSON features\n * @param  fn       Function to call on each coordinate\n * @return          Transformed GeoJSON features\n */\nexport function transformGeoJsonCoords(\n  features: object[],\n  fn: (coord: number[]) => number[]\n): object[] {\n  for (const feature of features) {\n    // @ts-ignore\n    feature.geometry.coordinates = coordMap(feature.geometry.coordinates, fn);\n  }\n  return features;\n}\n\nfunction coordMap(array, fn) {\n  if (isCoord(array)) {\n    return fn(array);\n  }\n\n  return array.map((item) => {\n    return coordMap(item, fn);\n  });\n}\n\nfunction isCoord(array) {\n  return Number.isFinite(array[0]) && Number.isFinite(array[1]);\n}\n"],"file":"transform.js"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@loaders.gl/gis",
   "description": "Helpers for GIS category data",
-  "version": "3.1.3",
+  "version": "4.0.0-alpha.5",
   "license": "MIT",
   "publishConfig": {
     "access": "public"
@@ -15,8 +15,8 @@
     "GeoJSON"
   ],
   "types": "dist/index.d.ts",
-  "main": "dist/es5/index.js",
-  "module": "dist/esm/index.js",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
   "sideEffects": false,
   "files": [
     "src",
@@ -24,8 +24,8 @@
     "README.md"
   ],
   "dependencies": {
-    "@loaders.gl/loader-utils": "3.1.3",
-    "@loaders.gl/schema": "3.1.3",
+    "@loaders.gl/loader-utils": "4.0.0-alpha.5",
+    "@loaders.gl/schema": "4.0.0-alpha.5",
     "@mapbox/vector-tile": "^1.3.1",
     "@math.gl/polygon": "^3.5.1",
     "pbf": "^3.2.1"
@@ -33,5 +33,5 @@
   "devDependencies": {
     "@math.gl/proj4": "^3.5.1"
   },
-  "gitHead": "4a690c369779346d73c9a27395d1c08d77d279a4"
+  "gitHead": "7a71a54bdf1ddf985cc3af3db90b82e7fa97d025"
 }

package/dist/es5/bundle.js

@@ -1,7 +0,0 @@
-"use strict";
-
-var moduleExports = require('./index');
-
-globalThis.loaders = globalThis.loaders || {};
-module.exports = Object.assign(globalThis.loaders, moduleExports);
-//# sourceMappingURL=bundle.js.map

package/dist/es5/bundle.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/bundle.ts"],"names":["moduleExports","require","globalThis","loaders","module","exports","Object","assign"],"mappings":";;AACA,IAAMA,aAAa,GAAGC,OAAO,CAAC,SAAD,CAA7B;;AACAC,UAAU,CAACC,OAAX,GAAqBD,UAAU,CAACC,OAAX,IAAsB,EAA3C;AACAC,MAAM,CAACC,OAAP,GAAiBC,MAAM,CAACC,MAAP,CAAcL,UAAU,CAACC,OAAzB,EAAkCH,aAAlC,CAAjB","sourcesContent":["// @ts-nocheck\nconst moduleExports = require('./index');\nglobalThis.loaders = globalThis.loaders || {};\nmodule.exports = Object.assign(globalThis.loaders, moduleExports);\n"],"file":"bundle.js"}

package/dist/es5/index.js

@@ -1,64 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-Object.defineProperty(exports, "flatGeojsonToBinary", {
-  enumerable: true,
-  get: function get() {
-    return _flatGeojsonToBinary.flatGeojsonToBinary;
-  }
-});
-Object.defineProperty(exports, "geojsonToBinary", {
-  enumerable: true,
-  get: function get() {
-    return _geojsonToBinary.geojsonToBinary;
-  }
-});
-Object.defineProperty(exports, "geojsonToFlatGeojson", {
-  enumerable: true,
-  get: function get() {
-    return _geojsonToFlatGeojson.geojsonToFlatGeojson;
-  }
-});
-Object.defineProperty(exports, "binaryToGeojson", {
-  enumerable: true,
-  get: function get() {
-    return _binaryToGeojson.binaryToGeojson;
-  }
-});
-Object.defineProperty(exports, "binaryToGeoJson", {
-  enumerable: true,
-  get: function get() {
-    return _binaryToGeojson.binaryToGeoJson;
-  }
-});
-Object.defineProperty(exports, "binaryToGeometry", {
-  enumerable: true,
-  get: function get() {
-    return _binaryToGeojson.binaryToGeometry;
-  }
-});
-Object.defineProperty(exports, "transformBinaryCoords", {
-  enumerable: true,
-  get: function get() {
-    return _transform.transformBinaryCoords;
-  }
-});
-Object.defineProperty(exports, "transformGeoJsonCoords", {
-  enumerable: true,
-  get: function get() {
-    return _transform.transformGeoJsonCoords;
-  }
-});
-
-var _flatGeojsonToBinary = require("./lib/flat-geojson-to-binary");
-
-var _geojsonToBinary = require("./lib/geojson-to-binary");
-
-var _geojsonToFlatGeojson = require("./lib/geojson-to-flat-geojson");
-
-var _binaryToGeojson = require("./lib/binary-to-geojson");
-
-var _transform = require("./lib/transform");
-//# sourceMappingURL=index.js.map

package/dist/es5/index.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGA;;AACA;;AACA;;AACA;;AACA","sourcesContent":["// Types from `@loaders.gl/schema`\n\n// Functions\nexport {flatGeojsonToBinary} from './lib/flat-geojson-to-binary';\nexport {geojsonToBinary} from './lib/geojson-to-binary';\nexport {geojsonToFlatGeojson} from './lib/geojson-to-flat-geojson';\nexport {binaryToGeojson, binaryToGeoJson, binaryToGeometry} from './lib/binary-to-geojson';\nexport {transformBinaryCoords, transformGeoJsonCoords} from './lib/transform';\n"],"file":"index.js"}