@loaders.gl/pmtiles 4.3.0-alpha.2 → 4.3.0-alpha.4

package/dist/dist.dev.js

@@ -793,7 +793,9 @@ var __exports__ = (() => {
   // bundle.ts
   var bundle_exports = {};
   __export(bundle_exports, {
-    PMTilesSource: () => PMTilesSource
+    PMTilesSource: () => PMTilesSource,
+    PMTilesTileSource: () => PMTilesTileSource,
+    _PMTilesLoader: () => PMTilesLoader
   });
   __reExport(bundle_exports, __toESM(require_core(), 1));
 
@@ -1426,6 +1428,33 @@ var __exports__ = (() => {
     return filename;
   }
 
+  // ../loader-utils/src/lib/files/blob-file.ts
+  var BlobFile = class {
+    handle;
+    size;
+    bigsize;
+    url;
+    constructor(blob) {
+      this.handle = blob instanceof ArrayBuffer ? new Blob([blob]) : blob;
+      this.size = blob instanceof ArrayBuffer ? blob.byteLength : blob.size;
+      this.bigsize = BigInt(this.size);
+      this.url = blob instanceof File ? blob.name : "";
+    }
+    async close() {
+    }
+    async stat() {
+      return {
+        size: this.handle.size,
+        bigsize: BigInt(this.handle.size),
+        isDirectory: false
+      };
+    }
+    async read(start, length) {
+      const arrayBuffer = await this.handle.slice(start, start + length).arrayBuffer();
+      return arrayBuffer;
+    }
+  };
+
   // ../loader-utils/src/lib/sources/data-source.ts
   var DataSource = class {
     /** A resolved fetch function extracted from loadOptions prop */
@@ -1879,6 +1908,293 @@ var __exports__ = (() => {
     options: DEFAULT_IMAGE_LOADER_OPTIONS
   };
 
+  // ../mvt/src/lib/get-schemas-from-tilejson.ts
+  function getSchemaFromTileJSONLayer(layer) {
+    const fields = [];
+    if (layer.fields) {
+      for (const field of layer.fields) {
+        fields.push({
+          name: field.name,
+          type: getDataTypeFromTileJSONField(field),
+          metadata: getMetadataFromTileJSONField(field)
+        });
+      }
+    }
+    return {
+      metadata: getMetadataFromTileJSONLayer(layer),
+      fields
+    };
+  }
+  function getMetadataFromTileJSONLayer(layer) {
+    const metadata = {};
+    for (const [key, value] of Object.entries(layer)) {
+      if (key !== "fields" && value) {
+        metadata[key] = JSON.stringify(value);
+      }
+    }
+    return metadata;
+  }
+  function getDataTypeFromTileJSONField(field) {
+    switch (field.type.toLowerCase()) {
+      case "float32":
+        return "float32";
+      case "number":
+      case "float64":
+        return "float64";
+      case "string":
+      case "utf8":
+        return "utf8";
+      case "boolean":
+        return "bool";
+      default:
+        return "null";
+    }
+  }
+  function getMetadataFromTileJSONField(field) {
+    const metadata = {};
+    for (const [key, value] of Object.entries(field)) {
+      if (key !== "name" && value) {
+        metadata[key] = JSON.stringify(value);
+      }
+    }
+    return metadata;
+  }
+
+  // ../mvt/src/lib/parse-tilejson.ts
+  var isObject = (x2) => x2 !== null && typeof x2 === "object";
+  function parseTileJSON(jsonMetadata, options) {
+    if (!jsonMetadata || !isObject(jsonMetadata)) {
+      return null;
+    }
+    let tileJSON = {
+      name: jsonMetadata.name || "",
+      description: jsonMetadata.description || ""
+    };
+    if (typeof jsonMetadata.generator === "string") {
+      tileJSON.generator = jsonMetadata.generator;
+    }
+    if (typeof jsonMetadata.generator_options === "string") {
+      tileJSON.generatorOptions = jsonMetadata.generator_options;
+    }
+    tileJSON.boundingBox = parseBounds(jsonMetadata.bounds) || parseBounds(jsonMetadata.antimeridian_adjusted_bounds);
+    tileJSON.center = parseCenter(jsonMetadata.center);
+    tileJSON.maxZoom = safeParseFloat(jsonMetadata.maxzoom);
+    tileJSON.minZoom = safeParseFloat(jsonMetadata.minzoom);
+    if (typeof jsonMetadata?.json === "string") {
+      try {
+        tileJSON.metaJson = JSON.parse(jsonMetadata.json);
+      } catch (error) {
+        console.warn("Failed to parse tilejson.json field", error);
+      }
+    }
+    const tilestats = jsonMetadata.tilestats || tileJSON.metaJson?.tilestats;
+    const tileStatsLayers = parseTilestatsLayers(tilestats, options);
+    const tileJSONlayers = parseTileJSONLayers(jsonMetadata.vector_layers);
+    const layers = mergeLayers(tileJSONlayers, tileStatsLayers);
+    tileJSON = {
+      ...tileJSON,
+      layers
+    };
+    if (tileJSON.maxZoom === null && layers.length > 0) {
+      tileJSON.maxZoom = layers[0].maxZoom || null;
+    }
+    if (tileJSON.minZoom === null && layers.length > 0) {
+      tileJSON.minZoom = layers[0].minZoom || null;
+    }
+    return tileJSON;
+  }
+  function parseTileJSONLayers(layers) {
+    if (!Array.isArray(layers)) {
+      return [];
+    }
+    return layers.map((layer) => parseTileJSONLayer(layer));
+  }
+  function parseTileJSONLayer(layer) {
+    const fields = Object.entries(layer.fields || []).map(([key, datatype]) => ({
+      name: key,
+      ...attributeTypeToFieldType(String(datatype))
+    }));
+    const layer2 = { ...layer };
+    delete layer2.fields;
+    return {
+      name: layer.id || "",
+      ...layer2,
+      fields
+    };
+  }
+  function parseTilestatsLayers(tilestats, options) {
+    if (isObject(tilestats) && Array.isArray(tilestats.layers)) {
+      return tilestats.layers.map((layer) => parseTilestatsForLayer(layer, options));
+    }
+    return [];
+  }
+  function parseTilestatsForLayer(layer, options) {
+    const fields = [];
+    const indexedAttributes = {};
+    const attributes = layer.attributes || [];
+    for (const attribute of attributes) {
+      const name = attribute.attribute;
+      if (typeof name === "string") {
+        if (name.split("|").length > 1) {
+          const fname = name.split("|")[0];
+          indexedAttributes[fname] = indexedAttributes[fname] || [];
+          indexedAttributes[fname].push(attribute);
+          console.warn("ignoring tilestats indexed field", fname);
+        } else if (!fields[name]) {
+          fields.push(attributeToField(attribute, options));
+        } else {
+        }
+      }
+    }
+    return {
+      name: layer.layer || "",
+      dominantGeometry: layer.geometry,
+      fields
+    };
+  }
+  function mergeLayers(layers, tilestatsLayers) {
+    return layers.map((layer) => {
+      const tilestatsLayer = tilestatsLayers.find((tsLayer) => tsLayer.name === layer.name);
+      const fields = tilestatsLayer?.fields || layer.fields || [];
+      const mergedLayer = {
+        ...layer,
+        ...tilestatsLayer,
+        fields
+      };
+      mergedLayer.schema = getSchemaFromTileJSONLayer(mergedLayer);
+      return mergedLayer;
+    });
+  }
+  function parseBounds(bounds) {
+    const result = fromArrayOrString(bounds);
+    if (Array.isArray(result) && result.length === 4 && [result[0], result[2]].every(isLng) && [result[1], result[3]].every(isLat)) {
+      return [
+        [result[0], result[1]],
+        [result[2], result[3]]
+      ];
+    }
+    return void 0;
+  }
+  function parseCenter(center) {
+    const result = fromArrayOrString(center);
+    if (Array.isArray(result) && result.length === 3 && isLng(result[0]) && isLat(result[1]) && isZoom(result[2])) {
+      return result;
+    }
+    return null;
+  }
+  function safeParseFloat(input) {
+    const result = typeof input === "string" ? parseFloat(input) : typeof input === "number" ? input : null;
+    return result === null || isNaN(result) ? null : result;
+  }
+  function isLat(num) {
+    return Number.isFinite(num) && num <= 90 && num >= -90;
+  }
+  function isLng(num) {
+    return Number.isFinite(num) && num <= 180 && num >= -180;
+  }
+  function isZoom(num) {
+    return Number.isFinite(num) && num >= 0 && num <= 22;
+  }
+  function fromArrayOrString(data) {
+    if (typeof data === "string") {
+      return data.split(",").map(parseFloat);
+    } else if (Array.isArray(data)) {
+      return data;
+    }
+    return null;
+  }
+  var attrTypeMap = {
+    number: {
+      type: "float32"
+    },
+    numeric: {
+      type: "float32"
+    },
+    string: {
+      type: "utf8"
+    },
+    vachar: {
+      type: "utf8"
+    },
+    float: {
+      type: "float32"
+    },
+    int: {
+      type: "int32"
+    },
+    int4: {
+      type: "int32"
+    },
+    boolean: {
+      type: "boolean"
+    },
+    bool: {
+      type: "boolean"
+    }
+  };
+  function attributeToField(attribute = {}, options) {
+    const fieldTypes = attributeTypeToFieldType(attribute.type);
+    const field = {
+      name: attribute.attribute,
+      // what happens if attribute type is string...
+      // filterProps: getFilterProps(fieldTypes.type, attribute),
+      ...fieldTypes
+    };
+    if (typeof attribute.min === "number") {
+      field.min = attribute.min;
+    }
+    if (typeof attribute.max === "number") {
+      field.max = attribute.max;
+    }
+    if (typeof attribute.count === "number") {
+      field.uniqueValueCount = attribute.count;
+    }
+    if (attribute.values) {
+      field.values = attribute.values;
+    }
+    if (field.values && typeof options.maxValues === "number") {
+      field.values = field.values?.slice(0, options.maxValues);
+    }
+    return field;
+  }
+  function attributeTypeToFieldType(aType) {
+    const type = aType.toLowerCase();
+    if (!type || !attrTypeMap[type]) {
+    }
+    return attrTypeMap[type] || { type: "string" };
+  }
+
+  // ../mvt/src/tilejson-loader.ts
+  var VERSION4 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+  var TileJSONLoader = {
+    dataType: null,
+    batchType: null,
+    name: "TileJSON",
+    id: "tilejson",
+    module: "pmtiles",
+    version: VERSION4,
+    worker: true,
+    extensions: ["json"],
+    mimeTypes: ["application/json"],
+    text: true,
+    options: {
+      tilejson: {
+        maxValues: void 0
+      }
+    },
+    parse: async (arrayBuffer, options) => {
+      const jsonString = new TextDecoder().decode(arrayBuffer);
+      const json = JSON.parse(jsonString);
+      const tilejsonOptions = { ...TileJSONLoader.options.tilejson, ...options?.tilejson };
+      return parseTileJSON(json, tilejsonOptions);
+    },
+    parseTextSync: (text, options) => {
+      const json = JSON.parse(text);
+      const tilejsonOptions = { ...TileJSONLoader.options.tilejson, ...options?.tilejson };
+      return parseTileJSON(json, tilejsonOptions);
+    }
+  };
+
   // ../../node_modules/@math.gl/polygon/dist/polygon-utils.js
   var DimIndex = {
     x: 0,
@@ -2705,7 +3021,7 @@ var __exports__ = (() => {
     p[1] /= extent;
   }
   function convertToLocalCoordinatesFlat(data, extent) {
-    for (let i2 = 0, il = data.length; i2 < il; ++i2) {
+    for (let i2 = 0; i2 < data.length; ++i2) {
       data[i2] /= extent;
     }
   }
@@ -3340,14 +3656,14 @@ var __exports__ = (() => {
   }
 
   // ../mvt/src/mvt-loader.ts
-  var VERSION4 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+  var VERSION5 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
   var MVTWorkerLoader = {
     dataType: null,
     batchType: null,
     name: "Mapbox Vector Tile",
     id: "mvt",
     module: "mvt",
-    version: VERSION4,
+    version: VERSION5,
     // Note: ArcGIS uses '.pbf' extension and 'application/octet-stream'
     extensions: ["mvt", "pbf"],
     mimeTypes: [
@@ -3375,241 +3691,6 @@ var __exports__ = (() => {
     binary: true
   };
 
-  // ../mvt/src/lib/parse-tilejson.ts
-  var isObject = (x2) => x2 !== null && typeof x2 === "object";
-  function parseTileJSON(jsonMetadata, options) {
-    if (!jsonMetadata || !isObject(jsonMetadata)) {
-      return null;
-    }
-    let tileJSON = {
-      name: jsonMetadata.name || "",
-      description: jsonMetadata.description || ""
-    };
-    if (typeof jsonMetadata.generator === "string") {
-      tileJSON.generator = jsonMetadata.generator;
-    }
-    if (typeof jsonMetadata.generator_options === "string") {
-      tileJSON.generatorOptions = jsonMetadata.generator_options;
-    }
-    tileJSON.boundingBox = parseBounds(jsonMetadata.bounds) || parseBounds(jsonMetadata.antimeridian_adjusted_bounds);
-    tileJSON.center = parseCenter(jsonMetadata.center);
-    tileJSON.maxZoom = safeParseFloat(jsonMetadata.maxzoom);
-    tileJSON.minZoom = safeParseFloat(jsonMetadata.minzoom);
-    if (typeof jsonMetadata?.json === "string") {
-      try {
-        tileJSON.metaJson = JSON.parse(jsonMetadata.json);
-      } catch (error) {
-        console.warn("Failed to parse tilejson.json field", error);
-      }
-    }
-    const tilestats = jsonMetadata.tilestats || tileJSON.metaJson?.tilestats;
-    const tileStatsLayers = parseTilestatsLayers(tilestats, options);
-    const tileJSONlayers = parseTileJSONLayers(jsonMetadata.vector_layers);
-    const layers = mergeLayers(tileJSONlayers, tileStatsLayers);
-    tileJSON = {
-      ...tileJSON,
-      layers
-    };
-    if (tileJSON.maxZoom === null && layers.length > 0) {
-      tileJSON.maxZoom = layers[0].maxZoom || null;
-    }
-    if (tileJSON.minZoom === null && layers.length > 0) {
-      tileJSON.minZoom = layers[0].minZoom || null;
-    }
-    return tileJSON;
-  }
-  function parseTileJSONLayers(layers) {
-    if (!Array.isArray(layers)) {
-      return [];
-    }
-    return layers.map((layer) => parseTileJSONLayer(layer));
-  }
-  function parseTileJSONLayer(layer) {
-    const fields = Object.entries(layer.fields || []).map(([key, datatype]) => ({
-      name: key,
-      ...attributeTypeToFieldType(String(datatype))
-    }));
-    const layer2 = { ...layer };
-    delete layer2.fields;
-    return {
-      name: layer.id || "",
-      ...layer2,
-      fields
-    };
-  }
-  function parseTilestatsLayers(tilestats, options) {
-    if (isObject(tilestats) && Array.isArray(tilestats.layers)) {
-      return tilestats.layers.map((layer) => parseTilestatsForLayer(layer, options));
-    }
-    return [];
-  }
-  function parseTilestatsForLayer(layer, options) {
-    const fields = [];
-    const indexedAttributes = {};
-    const attributes = layer.attributes || [];
-    for (const attribute of attributes) {
-      const name = attribute.attribute;
-      if (typeof name === "string") {
-        if (name.split("|").length > 1) {
-          const fname = name.split("|")[0];
-          indexedAttributes[fname] = indexedAttributes[fname] || [];
-          indexedAttributes[fname].push(attribute);
-          console.warn("ignoring tilestats indexed field", fname);
-        } else if (!fields[name]) {
-          fields.push(attributeToField(attribute, options));
-        } else {
-        }
-      }
-    }
-    return {
-      name: layer.layer || "",
-      dominantGeometry: layer.geometry,
-      fields
-    };
-  }
-  function mergeLayers(layers, tilestatsLayers) {
-    return layers.map((layer) => {
-      const tilestatsLayer = tilestatsLayers.find((tsLayer) => tsLayer.name === layer.name);
-      const fields = tilestatsLayer?.fields || [];
-      const layer2 = { ...layer };
-      delete layer2.fields;
-      return {
-        ...layer2,
-        ...tilestatsLayer,
-        fields
-      };
-    });
-  }
-  function parseBounds(bounds) {
-    const result = fromArrayOrString(bounds);
-    if (Array.isArray(result) && result.length === 4 && [result[0], result[2]].every(isLng) && [result[1], result[3]].every(isLat)) {
-      return [
-        [result[0], result[1]],
-        [result[2], result[3]]
-      ];
-    }
-    return void 0;
-  }
-  function parseCenter(center) {
-    const result = fromArrayOrString(center);
-    if (Array.isArray(result) && result.length === 3 && isLng(result[0]) && isLat(result[1]) && isZoom(result[2])) {
-      return result;
-    }
-    return null;
-  }
-  function safeParseFloat(input) {
-    const result = typeof input === "string" ? parseFloat(input) : typeof input === "number" ? input : null;
-    return result === null || isNaN(result) ? null : result;
-  }
-  function isLat(num) {
-    return Number.isFinite(num) && num <= 90 && num >= -90;
-  }
-  function isLng(num) {
-    return Number.isFinite(num) && num <= 180 && num >= -180;
-  }
-  function isZoom(num) {
-    return Number.isFinite(num) && num >= 0 && num <= 22;
-  }
-  function fromArrayOrString(data) {
-    if (typeof data === "string") {
-      return data.split(",").map(parseFloat);
-    } else if (Array.isArray(data)) {
-      return data;
-    }
-    return null;
-  }
-  var attrTypeMap = {
-    number: {
-      type: "float32"
-    },
-    numeric: {
-      type: "float32"
-    },
-    string: {
-      type: "utf8"
-    },
-    vachar: {
-      type: "utf8"
-    },
-    float: {
-      type: "float32"
-    },
-    int: {
-      type: "int32"
-    },
-    int4: {
-      type: "int32"
-    },
-    boolean: {
-      type: "boolean"
-    },
-    bool: {
-      type: "boolean"
-    }
-  };
-  function attributeToField(attribute = {}, options) {
-    const fieldTypes = attributeTypeToFieldType(attribute.type);
-    const field = {
-      name: attribute.attribute,
-      // what happens if attribute type is string...
-      // filterProps: getFilterProps(fieldTypes.type, attribute),
-      ...fieldTypes
-    };
-    if (typeof attribute.min === "number") {
-      field.min = attribute.min;
-    }
-    if (typeof attribute.max === "number") {
-      field.max = attribute.max;
-    }
-    if (typeof attribute.count === "number") {
-      field.uniqueValueCount = attribute.count;
-    }
-    if (attribute.values) {
-      field.values = attribute.values;
-    }
-    if (field.values && typeof options.maxValues === "number") {
-      field.values = field.values?.slice(0, options.maxValues);
-    }
-    return field;
-  }
-  function attributeTypeToFieldType(aType) {
-    const type = aType.toLowerCase();
-    if (!type || !attrTypeMap[type]) {
-    }
-    return attrTypeMap[type] || { type: "string" };
-  }
-
-  // ../mvt/src/tilejson-loader.ts
-  var VERSION5 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
-  var TileJSONLoader = {
-    dataType: null,
-    batchType: null,
-    name: "TileJSON",
-    id: "tilejson",
-    module: "pmtiles",
-    version: VERSION5,
-    worker: true,
-    extensions: ["json"],
-    mimeTypes: ["application/json"],
-    text: true,
-    options: {
-      tilejson: {
-        maxValues: void 0
-      }
-    },
-    parse: async (arrayBuffer, options) => {
-      const jsonString = new TextDecoder().decode(arrayBuffer);
-      const json = JSON.parse(jsonString);
-      const tilejsonOptions = { ...TileJSONLoader.options.tilejson, ...options?.tilejson };
-      return parseTileJSON(json, tilejsonOptions);
-    },
-    parseTextSync: (text, options) => {
-      const json = JSON.parse(text);
-      const tilejsonOptions = { ...TileJSONLoader.options.tilejson, ...options?.tilejson };
-      return parseTileJSON(json, tilejsonOptions);
-    }
-  };
-
   // ../../node_modules/pmtiles/dist/index.js
   var dist_exports = {};
   __export(dist_exports, {
@@ -5239,8 +5320,7 @@ var __exports__ = (() => {
 
   // src/lib/parse-pmtiles.ts
   var { TileType: TileType2 } = dist_exports;
-  function parsePMTilesHeader(header, pmmetadata, options, loadOptions) {
-    const pmtilesMetadata = pmmetadata;
+  function parsePMTilesHeader(header, pmtilesMetadata, options, loadOptions) {
     let tilejson = null;
     if (pmtilesMetadata) {
       try {
@@ -5325,17 +5405,32 @@ var __exports__ = (() => {
 
   // src/pmtiles-source.ts
   var { PMTiles: PMTiles2 } = dist_exports;
-  var PMTilesSource = class extends DataSource {
+  var VERSION6 = "1.0.0";
+  var PMTilesSource = {
+    name: "PMTiles",
+    id: "pmtiles",
+    module: "pmtiles",
+    version: VERSION6,
+    extensions: ["pmtiles"],
+    mimeTypes: ["application/octet-stream"],
+    options: { url: void 0, pmtiles: {} },
+    type: "pmtiles",
+    fromUrl: true,
+    fromBlob: true,
+    testURL: (url) => url.endsWith(".pmtiles"),
+    createDataSource: (url, props) => new PMTilesTileSource(url, props)
+  };
+  var PMTilesTileSource = class extends DataSource {
     data;
     props;
     mimeType = null;
     pmtiles;
     metadata;
-    constructor(props) {
+    constructor(data, props) {
       super(props);
       this.props = props;
-      const url = typeof props.url === "string" ? resolvePath(props.url) : new BlobSource(props.url, "pmtiles");
-      this.data = props.url;
+      const url = typeof data === "string" ? resolvePath(data) : new BlobSource(data, "pmtiles");
+      this.data = data;
       this.pmtiles = new PMTiles2(url);
       this.getTileData = this.getTileData.bind(this);
       this.metadata = this.getMetadata();
@@ -5345,7 +5440,7 @@ var __exports__ = (() => {
     }
     async getMetadata() {
       const pmtilesHeader = await this.pmtiles.getHeader();
-      const pmtilesMetadata = await this.pmtiles.getMetadata();
+      const pmtilesMetadata = await this.pmtiles.getMetadata() || {};
       const metadata = parsePMTilesHeader(
         pmtilesHeader,
         pmtilesMetadata,
@@ -5401,6 +5496,47 @@ var __exports__ = (() => {
       return arrayBuffer ? await MVTLoader.parse(arrayBuffer, loadOptions) : null;
     }
   };
+
+  // src/lib/version.ts
+  var VERSION7 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+
+  // src/pmtiles-loader.ts
+  var PMTilesLoader = {
+    name: "PMTiles",
+    id: "pmtiles",
+    module: "pmtiles",
+    version: VERSION7,
+    extensions: ["pmtiles"],
+    mimeTypes: ["application/octet-stream"],
+    tests: ["PMTiles"],
+    options: {
+      pmtiles: {}
+    },
+    parse: async (arrayBuffer, options) => parseFileAsPMTiles(new BlobFile(new Blob([arrayBuffer])), options),
+    parseFile: parseFileAsPMTiles
+  };
+  async function parseFileAsPMTiles(file, options) {
+    const source = new PMTilesTileSource(file.handle, {
+      pmtiles: options?.pmtiles || {}
+    });
+    const formatSpecificMetadata = await source.getMetadata();
+    const { tileMIMEType, tilejson = {} } = formatSpecificMetadata;
+    const { layers = [] } = tilejson;
+    switch (tileMIMEType) {
+      case "application/vnd.mapbox-vector-tile":
+        return {
+          shape: "vector-source",
+          layers: layers.map((layer) => ({ name: layer.name, schema: layer.schema })),
+          tables: [],
+          formatSpecificMetadata
+        };
+      case "image/png":
+      case "image/jpeg":
+        return { shape: "image-source", formatSpecificMetadata };
+      default:
+        throw new Error(`PMTilesLoader: Unsupported tile MIME type ${tileMIMEType}`);
+    }
+  }
   return __toCommonJS(bundle_exports);
 })();
 /*! Bundled license information: