@loaders.gl/flatgeobuf 4.3.1 → 4.4.0-alpha.1

package/dist/flatgeobuf-worker.js

@@ -206,6 +206,16 @@
     return await parser(data, { ...options }, context, loader);
   }
 
+  // src/flatgeobuf-format.ts
+  var FlatGeobufFormat = {
+    id: "flatgeobuf",
+    name: "FlatGeobuf",
+    module: "flatgeobuf",
+    extensions: ["fgb"],
+    mimeTypes: ["application/octet-stream"],
+    category: "geometry"
+  };
+
   // ../../node_modules/proj4/lib/global.js
   function global_default(defs2) {
     defs2("EPSG:4326", "+title=WGS 84 (long/lat) +proj=longlat +ellps=WGS84 +datum=WGS84 +units=degrees");
@@ -5559,7 +5569,7 @@
     }
   };
 
-  // ../gis/src/lib/binary-features/transform.ts
+  // ../gis/src/lib/binary-geometry-api/transform-coordinates.ts
   function transformGeoJsonCoords(features, fn) {
     for (const feature of features) {
       feature.geometry.coordinates = coordMap(feature.geometry.coordinates, fn);
@@ -5578,209 +5588,6 @@
     return Array.isArray(array) && Number.isFinite(array[0]) && Number.isFinite(array[1]);
   }
 
-  // src/lib/binary-geometries.ts
-  function fgbToBinaryGeometry(geometry, type) {
-    if (geometry === null) {
-      return null;
-    }
-    switch (type) {
-      case GeometryType.Point:
-      case GeometryType.MultiPoint:
-        return parsePoint(geometry);
-      case GeometryType.LineString:
-      case GeometryType.MultiLineString:
-        return parseLines(geometry);
-      case GeometryType.Polygon:
-        return parsePolygons(geometry);
-      case GeometryType.MultiPolygon:
-        return parseMultiPolygons(geometry);
-      default:
-        throw new Error(`Unimplemented geometry type: ${type}`);
-    }
-  }
-  function parsePoint(geometry) {
-    const xy = geometry.xyArray();
-    const z = geometry.zArray();
-    const positions = blitArrays(xy, z);
-    return { positions };
-  }
-  function parseLines(geometry) {
-    const xy = geometry.xyArray();
-    const z = geometry.zArray();
-    const positions = blitArrays(xy, z);
-    const ends = geometry.endsArray() && Array.from(geometry.endsArray()) || [xy.length / 2];
-    ends.unshift(0);
-    const pathIndices = { value: new Uint16Array(ends), size: 1 };
-    return {
-      positions,
-      pathIndices
-    };
-  }
-  function parsePolygons(geometry) {
-    const xy = geometry.xyArray();
-    const z = geometry.zArray();
-    const positions = blitArrays(xy, z);
-    const ends = geometry.endsArray() && Array.from(geometry.endsArray()) || [xy.length / 2];
-    ends.unshift(0);
-    const primitivePolygonIndices = { value: new Uint16Array(ends), size: 1 };
-    const polygonIndices = { value: new Uint16Array([0, xy.length / 2]), size: 1 };
-    return {
-      positions,
-      primitivePolygonIndices,
-      polygonIndices
-    };
-  }
-  function parseMultiPolygons(geometry) {
-    const parsedParts = [];
-    let nPositions = 0;
-    let nPrimitivePolygonIndices = 1;
-    let nPolygonIndices = 1;
-    for (let i = 0; i < geometry.partsLength(); i++) {
-      const part = geometry.parts(i);
-      const polygon = parsePolygons(part);
-      nPositions += polygon.positions.value.length;
-      nPrimitivePolygonIndices += polygon.primitivePolygonIndices.value.length - 1;
-      nPolygonIndices += polygon.polygonIndices.value.length - 1;
-      parsedParts.push(polygon);
-    }
-    const concatPositions = new Float64Array(nPositions);
-    const concatPrimitivePolygonIndices = new Uint32Array(nPrimitivePolygonIndices);
-    const concatPolygonIndices = new Uint32Array(nPolygonIndices);
-    let positionCounter = 0;
-    let primitivePolygonIndicesCounter = 1;
-    let polygonIndicesCounter = 1;
-    const positionSize = parsedParts[0].positions.size;
-    for (const parsedPart of parsedParts) {
-      concatPositions.set(parsedPart.positions.value, positionCounter * positionSize);
-      concatPrimitivePolygonIndices.set(
-        // eslint-disable-next-line
-        parsedPart.primitivePolygonIndices.value.subarray(1).map((x) => x + positionCounter),
-        primitivePolygonIndicesCounter
-      );
-      concatPolygonIndices.set(
-        // eslint-disable-next-line
-        parsedPart.polygonIndices.value.subarray(1).map((x) => x + positionCounter),
-        polygonIndicesCounter
-      );
-      positionCounter += parsedPart.positions.value.length / positionSize;
-      primitivePolygonIndicesCounter += parsedPart.primitivePolygonIndices.value.length - 1;
-      polygonIndicesCounter += parsedPart.polygonIndices.value.length - 1;
-    }
-    return {
-      positions: { value: concatPositions, size: positionSize },
-      primitivePolygonIndices: { value: concatPrimitivePolygonIndices, size: 1 },
-      polygonIndices: { value: concatPolygonIndices, size: 1 }
-    };
-  }
-  function blitArrays(xy, z) {
-    if (!z) {
-      return { value: xy, size: 2 };
-    }
-    if (z.length * 2 !== xy.length) {
-      throw new Error("Z array must be half XY array's length");
-    }
-    const totalLength = xy.length + z.length;
-    const xyz = new Float64Array(totalLength);
-    for (let i = 0; i < xy.length / 2; i++) {
-      xyz[i * 3 + 0] = xy[i * 2 + 0];
-      xyz[i * 3 + 1] = xy[i * 2 + 1];
-      xyz[i * 3 + 2] = z[i];
-    }
-    return { value: xyz, size: 3 };
-  }
-
-  // src/lib/get-schema-from-fgb-header.ts
-  function getSchemaFromFGBHeader(fgbHeader) {
-    const metadata = {
-      title: fgbHeader.title || "",
-      description: fgbHeader.description || "",
-      crs: JSON.stringify(fgbHeader.crs) || "",
-      metadata: fgbHeader.metadata || "",
-      geometryType: String(fgbHeader.geometryType),
-      indexNodeSize: String(fgbHeader.indexNodeSize),
-      featureCount: String(fgbHeader.featuresCount),
-      bounds: fgbHeader.envelope?.join(",") || ""
-    };
-    const fields = fgbHeader.columns?.map((column) => getFieldFromFGBColumn(column)) || [];
-    return { metadata, fields };
-  }
-  function getFieldFromFGBColumn(fgbColumn) {
-    const metadata = {
-      title: fgbColumn.title || "",
-      description: fgbColumn.description || "",
-      width: String(fgbColumn.width),
-      precision: String(fgbColumn.precision),
-      scale: String(fgbColumn.scale),
-      unique: String(fgbColumn.unique),
-      primary_key: String(fgbColumn.primary_key)
-    };
-    return {
-      name: fgbColumn.name,
-      type: getTypeFromFGBType(fgbColumn.type),
-      nullable: fgbColumn.nullable,
-      metadata
-    };
-  }
-  function getTypeFromFGBType(fgbType) {
-    switch (fgbType) {
-      case 0 /* Byte */:
-        return "int8";
-      case 1 /* UByte */:
-        return "uint8";
-      case 2 /* Bool */:
-        return "bool";
-      case 3 /* Short */:
-        return "int16";
-      case 4 /* UShort */:
-        return "uint16";
-      case 5 /* Int */:
-        return "int32";
-      case 6 /* UInt */:
-        return "uint32";
-      case 7 /* Long */:
-        return "int64";
-      case 8 /* ULong */:
-        return "uint64";
-      case 9 /* Float */:
-        return "float32";
-      case 10 /* Double */:
-        return "float64";
-      case 11 /* String */:
-        return "utf8";
-      case 12 /* Json */:
-        return "null";
-      case 13 /* DateTime */:
-        return "date-millisecond";
-      case 14 /* Binary */:
-        return "binary";
-      default:
-        return "null";
-    }
-  }
-
-  // src/flatgeobuf/3.27.2/flat-geobuf/geometry-type.ts
-  var GeometryType2 = /* @__PURE__ */ ((GeometryType3) => {
-    GeometryType3[GeometryType3["Unknown"] = 0] = "Unknown";
-    GeometryType3[GeometryType3["Point"] = 1] = "Point";
-    GeometryType3[GeometryType3["LineString"] = 2] = "LineString";
-    GeometryType3[GeometryType3["Polygon"] = 3] = "Polygon";
-    GeometryType3[GeometryType3["MultiPoint"] = 4] = "MultiPoint";
-    GeometryType3[GeometryType3["MultiLineString"] = 5] = "MultiLineString";
-    GeometryType3[GeometryType3["MultiPolygon"] = 6] = "MultiPolygon";
-    GeometryType3[GeometryType3["GeometryCollection"] = 7] = "GeometryCollection";
-    GeometryType3[GeometryType3["CircularString"] = 8] = "CircularString";
-    GeometryType3[GeometryType3["CompoundCurve"] = 9] = "CompoundCurve";
-    GeometryType3[GeometryType3["CurvePolygon"] = 10] = "CurvePolygon";
-    GeometryType3[GeometryType3["MultiCurve"] = 11] = "MultiCurve";
-    GeometryType3[GeometryType3["MultiSurface"] = 12] = "MultiSurface";
-    GeometryType3[GeometryType3["Curve"] = 13] = "Curve";
-    GeometryType3[GeometryType3["Surface"] = 14] = "Surface";
-    GeometryType3[GeometryType3["PolyhedralSurface"] = 15] = "PolyhedralSurface";
-    GeometryType3[GeometryType3["TIN"] = 16] = "TIN";
-    GeometryType3[GeometryType3["Triangle"] = 17] = "Triangle";
-    return GeometryType3;
-  })(GeometryType2 || {});
-
   // ../../node_modules/flatbuffers/mjs/constants.js
   var SIZEOF_INT = 4;
   var FILE_IDENTIFIER_LENGTH = 4;
@@ -6043,6 +5850,209 @@
     }
   };
 
+  // src/lib/binary-geometries.ts
+  function fgbToBinaryGeometry(geometry, type) {
+    if (geometry === null) {
+      return null;
+    }
+    switch (type) {
+      case GeometryType.Point:
+      case GeometryType.MultiPoint:
+        return parsePoint(geometry);
+      case GeometryType.LineString:
+      case GeometryType.MultiLineString:
+        return parseLines(geometry);
+      case GeometryType.Polygon:
+        return parsePolygons(geometry);
+      case GeometryType.MultiPolygon:
+        return parseMultiPolygons(geometry);
+      default:
+        throw new Error(`Unimplemented geometry type: ${type}`);
+    }
+  }
+  function parsePoint(geometry) {
+    const xy = geometry.xyArray();
+    const z = geometry.zArray();
+    const positions = blitArrays(xy, z);
+    return { positions };
+  }
+  function parseLines(geometry) {
+    const xy = geometry.xyArray();
+    const z = geometry.zArray();
+    const positions = blitArrays(xy, z);
+    const ends = geometry.endsArray() && Array.from(geometry.endsArray()) || [xy.length / 2];
+    ends.unshift(0);
+    const pathIndices = { value: new Uint16Array(ends), size: 1 };
+    return {
+      positions,
+      pathIndices
+    };
+  }
+  function parsePolygons(geometry) {
+    const xy = geometry.xyArray();
+    const z = geometry.zArray();
+    const positions = blitArrays(xy, z);
+    const ends = geometry.endsArray() && Array.from(geometry.endsArray()) || [xy.length / 2];
+    ends.unshift(0);
+    const primitivePolygonIndices = { value: new Uint16Array(ends), size: 1 };
+    const polygonIndices = { value: new Uint16Array([0, xy.length / 2]), size: 1 };
+    return {
+      positions,
+      primitivePolygonIndices,
+      polygonIndices
+    };
+  }
+  function parseMultiPolygons(geometry) {
+    const parsedParts = [];
+    let nPositions = 0;
+    let nPrimitivePolygonIndices = 1;
+    let nPolygonIndices = 1;
+    for (let i = 0; i < geometry.partsLength(); i++) {
+      const part = geometry.parts(i);
+      const polygon = parsePolygons(part);
+      nPositions += polygon.positions.value.length;
+      nPrimitivePolygonIndices += polygon.primitivePolygonIndices.value.length - 1;
+      nPolygonIndices += polygon.polygonIndices.value.length - 1;
+      parsedParts.push(polygon);
+    }
+    const concatPositions = new Float64Array(nPositions);
+    const concatPrimitivePolygonIndices = new Uint32Array(nPrimitivePolygonIndices);
+    const concatPolygonIndices = new Uint32Array(nPolygonIndices);
+    let positionCounter = 0;
+    let primitivePolygonIndicesCounter = 1;
+    let polygonIndicesCounter = 1;
+    const positionSize = parsedParts[0].positions.size;
+    for (const parsedPart of parsedParts) {
+      concatPositions.set(parsedPart.positions.value, positionCounter * positionSize);
+      concatPrimitivePolygonIndices.set(
+        // eslint-disable-next-line
+        parsedPart.primitivePolygonIndices.value.subarray(1).map((x) => x + positionCounter),
+        primitivePolygonIndicesCounter
+      );
+      concatPolygonIndices.set(
+        // eslint-disable-next-line
+        parsedPart.polygonIndices.value.subarray(1).map((x) => x + positionCounter),
+        polygonIndicesCounter
+      );
+      positionCounter += parsedPart.positions.value.length / positionSize;
+      primitivePolygonIndicesCounter += parsedPart.primitivePolygonIndices.value.length - 1;
+      polygonIndicesCounter += parsedPart.polygonIndices.value.length - 1;
+    }
+    return {
+      positions: { value: concatPositions, size: positionSize },
+      primitivePolygonIndices: { value: concatPrimitivePolygonIndices, size: 1 },
+      polygonIndices: { value: concatPolygonIndices, size: 1 }
+    };
+  }
+  function blitArrays(xy, z) {
+    if (!z) {
+      return { value: xy, size: 2 };
+    }
+    if (z.length * 2 !== xy.length) {
+      throw new Error("Z array must be half XY array's length");
+    }
+    const totalLength = xy.length + z.length;
+    const xyz = new Float64Array(totalLength);
+    for (let i = 0; i < xy.length / 2; i++) {
+      xyz[i * 3 + 0] = xy[i * 2 + 0];
+      xyz[i * 3 + 1] = xy[i * 2 + 1];
+      xyz[i * 3 + 2] = z[i];
+    }
+    return { value: xyz, size: 3 };
+  }
+
+  // src/lib/get-schema-from-fgb-header.ts
+  function getSchemaFromFGBHeader(fgbHeader) {
+    const metadata = {
+      title: fgbHeader.title || "",
+      description: fgbHeader.description || "",
+      crs: JSON.stringify(fgbHeader.crs) || "",
+      metadata: fgbHeader.metadata || "",
+      geometryType: String(fgbHeader.geometryType),
+      indexNodeSize: String(fgbHeader.indexNodeSize),
+      featureCount: String(fgbHeader.featuresCount),
+      bounds: fgbHeader.envelope?.join(",") || ""
+    };
+    const fields = fgbHeader.columns?.map((column) => getFieldFromFGBColumn(column)) || [];
+    return { metadata, fields };
+  }
+  function getFieldFromFGBColumn(fgbColumn) {
+    const metadata = {
+      title: fgbColumn.title || "",
+      description: fgbColumn.description || "",
+      width: String(fgbColumn.width),
+      precision: String(fgbColumn.precision),
+      scale: String(fgbColumn.scale),
+      unique: String(fgbColumn.unique),
+      primary_key: String(fgbColumn.primary_key)
+    };
+    return {
+      name: fgbColumn.name,
+      type: getTypeFromFGBType(fgbColumn.type),
+      nullable: fgbColumn.nullable,
+      metadata
+    };
+  }
+  function getTypeFromFGBType(fgbType) {
+    switch (fgbType) {
+      case 0 /* Byte */:
+        return "int8";
+      case 1 /* UByte */:
+        return "uint8";
+      case 2 /* Bool */:
+        return "bool";
+      case 3 /* Short */:
+        return "int16";
+      case 4 /* UShort */:
+        return "uint16";
+      case 5 /* Int */:
+        return "int32";
+      case 6 /* UInt */:
+        return "uint32";
+      case 7 /* Long */:
+        return "int64";
+      case 8 /* ULong */:
+        return "uint64";
+      case 9 /* Float */:
+        return "float32";
+      case 10 /* Double */:
+        return "float64";
+      case 11 /* String */:
+        return "utf8";
+      case 12 /* Json */:
+        return "null";
+      case 13 /* DateTime */:
+        return "date-millisecond";
+      case 14 /* Binary */:
+        return "binary";
+      default:
+        return "null";
+    }
+  }
+
+  // src/flatgeobuf/3.27.2/flat-geobuf/geometry-type.ts
+  var GeometryType2 = /* @__PURE__ */ ((GeometryType3) => {
+    GeometryType3[GeometryType3["Unknown"] = 0] = "Unknown";
+    GeometryType3[GeometryType3["Point"] = 1] = "Point";
+    GeometryType3[GeometryType3["LineString"] = 2] = "LineString";
+    GeometryType3[GeometryType3["Polygon"] = 3] = "Polygon";
+    GeometryType3[GeometryType3["MultiPoint"] = 4] = "MultiPoint";
+    GeometryType3[GeometryType3["MultiLineString"] = 5] = "MultiLineString";
+    GeometryType3[GeometryType3["MultiPolygon"] = 6] = "MultiPolygon";
+    GeometryType3[GeometryType3["GeometryCollection"] = 7] = "GeometryCollection";
+    GeometryType3[GeometryType3["CircularString"] = 8] = "CircularString";
+    GeometryType3[GeometryType3["CompoundCurve"] = 9] = "CompoundCurve";
+    GeometryType3[GeometryType3["CurvePolygon"] = 10] = "CurvePolygon";
+    GeometryType3[GeometryType3["MultiCurve"] = 11] = "MultiCurve";
+    GeometryType3[GeometryType3["MultiSurface"] = 12] = "MultiSurface";
+    GeometryType3[GeometryType3["Curve"] = 13] = "Curve";
+    GeometryType3[GeometryType3["Surface"] = 14] = "Surface";
+    GeometryType3[GeometryType3["PolyhedralSurface"] = 15] = "PolyhedralSurface";
+    GeometryType3[GeometryType3["TIN"] = 16] = "TIN";
+    GeometryType3[GeometryType3["Triangle"] = 17] = "Triangle";
+    return GeometryType3;
+  })(GeometryType2 || {});
+
   // src/flatgeobuf/3.27.2/flat-geobuf/geometry.ts
   var Geometry = class {
     bb = null;
@@ -8826,19 +8836,14 @@
   }
 
   // src/flatgeobuf-loader.ts
-  var VERSION = true ? "4.3.0" : "latest";
+  var VERSION = true ? "4.4.0-alpha.0" : "latest";
   var FGB_MAGIC_NUMBER = [102, 103, 98, 3, 102, 103, 98, 1];
   var FlatGeobufWorkerLoader = {
+    ...FlatGeobufFormat,
     dataType: null,
     batchType: null,
-    id: "flatgeobuf",
-    name: "FlatGeobuf",
-    module: "flatgeobuf",
     version: VERSION,
     worker: true,
-    extensions: ["fgb"],
-    mimeTypes: ["application/octet-stream"],
-    category: "geometry",
     tests: [new Uint8Array(FGB_MAGIC_NUMBER).buffer],
     options: {
       flatgeobuf: {

package/dist/index.cjs

@@ -35,11 +35,23 @@ var __publicField = (obj, key, value) => {
 // dist/index.js
 var dist_exports = {};
 __export(dist_exports, {
+  FlatGeobufFormat: () => FlatGeobufFormat,
   FlatGeobufLoader: () => FlatGeobufLoader,
-  FlatGeobufWorkerLoader: () => FlatGeobufWorkerLoader
+  FlatGeobufWorkerLoader: () => FlatGeobufWorkerLoader,
+  _FlatGeobufSource: () => FlatGeobufSource
 });
 module.exports = __toCommonJS(dist_exports);
 
+// dist/flatgeobuf-format.js
+var FlatGeobufFormat = {
+  id: "flatgeobuf",
+  name: "FlatGeobuf",
+  module: "flatgeobuf",
+  extensions: ["fgb"],
+  mimeTypes: ["application/octet-stream"],
+  category: "geometry"
+};
+
 // dist/lib/parse-flatgeobuf.js
 var import_proj4 = require("@math.gl/proj4");
 var import_gis = require("@loaders.gl/gis");
@@ -1847,19 +1859,14 @@ function binaryFromFeature(feature, header) {
 }
 
 // dist/flatgeobuf-loader.js
-var VERSION = true ? "4.3.0" : "latest";
+var VERSION = true ? "4.4.0-alpha.0" : "latest";
 var FGB_MAGIC_NUMBER = [102, 103, 98, 3, 102, 103, 98, 1];
 var FlatGeobufWorkerLoader = {
+  ...FlatGeobufFormat,
   dataType: null,
   batchType: null,
-  id: "flatgeobuf",
-  name: "FlatGeobuf",
-  module: "flatgeobuf",
   version: VERSION,
   worker: true,
-  extensions: ["fgb"],
-  mimeTypes: ["application/octet-stream"],
-  category: "geometry",
   tests: [new Uint8Array(FGB_MAGIC_NUMBER).buffer],
   options: {
     flatgeobuf: {
@@ -1898,4 +1905,44 @@ function getOptions(options) {
     reproject: ((_d = options == null ? void 0 : options.gis) == null ? void 0 : _d.reproject) || false
   };
 }
+
+// dist/flatgeobuf-source.js
+var import_loader_utils = require("@loaders.gl/loader-utils");
+var FlatGeobufSource = {
+  ...FlatGeobufFormat,
+  version: "0.0.0",
+  type: "flatgeobuf-server",
+  fromUrl: true,
+  fromBlob: false,
+  // TODO check if supported by library?
+  defaultOptions: {
+    flatgeobuf: {}
+  },
+  testURL: (url) => url.toLowerCase().includes("FeatureServer"),
+  createDataSource: (url, options) => new FlatGeobufVectorSource(url, options)
+};
+var FlatGeobufVectorSource = class extends import_loader_utils.DataSource {
+  formatSpecificMetadata = null;
+  constructor(data, options) {
+    super(data, options, FlatGeobufSource.defaultOptions);
+  }
+  /** TODO - not yet clear if we can find schema information in the FeatureServer metadata or if we need to request a feature */
+  async getSchema() {
+    await this.getMetadata({ formatSpecificMetadata: true });
+    return { metadata: {}, fields: [] };
+  }
+  async getMetadata(options) {
+    if (!this.formatSpecificMetadata) {
+    }
+    if (options.formatSpecificMetadata) {
+    }
+    return {};
+  }
+  async getFeatures(parameters) {
+    const response = await this.fetch(this.url);
+    const arrayBuffer = await response.arrayBuffer();
+    const table = await FlatGeobufLoader.parse(arrayBuffer, {});
+    return table;
+  }
+};
 //# sourceMappingURL=index.cjs.map