@loaders.gl/flatgeobuf 4.2.0-alpha.4 → 4.2.0-alpha.6

package/dist/flatgeobuf/3.27.2/http-reader.js

@@ -7,187 +7,257 @@ import Logger from "./logger.js";
 import { fromByteBuffer } from "./header-meta.js";
 import { Feature } from "./flat-geobuf/feature.js";
 export class HttpReader {
-  constructor(headerClient, header, headerLength, indexLength) {
-    this.headerClient = void 0;
-    this.header = void 0;
-    this.headerLength = void 0;
-    this.indexLength = void 0;
-    this.headerClient = headerClient;
-    this.header = header;
-    this.headerLength = headerLength;
-    this.indexLength = indexLength;
-  }
-  static async open(url) {
-    const assumedHeaderLength = 2024;
-    const headerClient = new BufferedHttpRangeClient(url);
-    const assumedIndexLength = (() => {
-      const assumedBranchingFactor = DEFAULT_NODE_SIZE;
-      const prefetchedLayers = 3;
-      let result = 0;
-      let i;
-      for (i = 0; i < prefetchedLayers; i++) {
-        const layer_width = assumedBranchingFactor ** i * NODE_ITEM_BYTE_LEN;
-        result += layer_width;
-      }
-      return result;
-    })();
-    const minReqLength = assumedHeaderLength + assumedIndexLength;
-    Logger.debug(`fetching header. minReqLength: ${minReqLength} (assumedHeaderLength: ${assumedHeaderLength}, assumedIndexLength: ${assumedIndexLength})`);
-    {
-      const bytes = new Uint8Array(await headerClient.getRange(0, 8, minReqLength, 'header'));
-      if (!bytes.subarray(0, 3).every((v, i) => magicbytes[i] === v)) {
-        Logger.error(`bytes: ${bytes} != ${magicbytes}`);
-        throw new Error('Not a FlatGeobuf file');
-      }
-      Logger.debug('magic bytes look good');
+    headerClient;
+    header;
+    headerLength;
+    indexLength;
+    constructor(headerClient, header, headerLength, indexLength) {
+        this.headerClient = headerClient;
+        this.header = header;
+        this.headerLength = headerLength;
+        this.indexLength = indexLength;
     }
-    let headerLength;
-    {
-      const bytes = await headerClient.getRange(8, 4, minReqLength, 'header');
-      headerLength = new DataView(bytes).getUint32(0, true);
-      const HEADER_MAX_BUFFER_SIZE = 1048576 * 10;
-      if (headerLength > HEADER_MAX_BUFFER_SIZE || headerLength < 8) {
-        throw new Error('Invalid header size');
-      }
-      Logger.debug(`headerLength: ${headerLength}`);
+    // Fetch the header, preparing the reader to read Feature data.
+    //
+    // and potentially some opportunistic fetching of the index.
+    static async open(url) {
+        // In reality, the header is probably less than half this size, but
+        // better to overshoot and fetch an extra kb rather than have to issue
+        // a second request.
+        const assumedHeaderLength = 2024;
+        const headerClient = new BufferedHttpRangeClient(url);
+        // Immediately following the header is the optional spatial index, we deliberately fetch
+        // a small part of that to skip subsequent requests.
+        const assumedIndexLength = (() => {
+            // The actual branching factor will be in the header, but since we
+            // don't have the header yet, we just guess. The consequence of
+            // getting this wrong isn't terminal, it only means we may be
+            // fetching slightly more than we need or that we need to make an
+            // extra request later.
+            const assumedBranchingFactor = DEFAULT_NODE_SIZE;
+            // NOTE: each layer is exponentially larger
+            const prefetchedLayers = 3;
+            let result = 0;
+            let i;
+            for (i = 0; i < prefetchedLayers; i++) {
+                const layer_width = assumedBranchingFactor ** i * NODE_ITEM_BYTE_LEN;
+                result += layer_width;
+            }
+            return result;
+        })();
+        const minReqLength = assumedHeaderLength + assumedIndexLength;
+        Logger.debug(`fetching header. minReqLength: ${minReqLength} (assumedHeaderLength: ${assumedHeaderLength}, assumedIndexLength: ${assumedIndexLength})`);
+        {
+            const bytes = new Uint8Array(await headerClient.getRange(0, 8, minReqLength, 'header'));
+            if (!bytes.subarray(0, 3).every((v, i) => magicbytes[i] === v)) {
+                Logger.error(`bytes: ${bytes} != ${magicbytes}`);
+                throw new Error('Not a FlatGeobuf file');
+            }
+            Logger.debug('magic bytes look good');
+        }
+        let headerLength;
+        {
+            const bytes = await headerClient.getRange(8, 4, minReqLength, 'header');
+            headerLength = new DataView(bytes).getUint32(0, true);
+            const HEADER_MAX_BUFFER_SIZE = 1048576 * 10;
+            if (headerLength > HEADER_MAX_BUFFER_SIZE || headerLength < 8) {
+                // minimum size check avoids panic in FlatBuffers header decoding
+                throw new Error('Invalid header size');
+            }
+            Logger.debug(`headerLength: ${headerLength}`);
+        }
+        const bytes = await headerClient.getRange(12, headerLength, minReqLength, 'header');
+        const bb = new flatbuffers.ByteBuffer(new Uint8Array(bytes));
+        const header = fromByteBuffer(bb);
+        const indexLength = calcTreeSize(header.featuresCount, header.indexNodeSize);
+        Logger.debug('completed: opening http reader');
+        return new HttpReader(headerClient, header, headerLength, indexLength);
     }
-    const bytes = await headerClient.getRange(12, headerLength, minReqLength, 'header');
-    const bb = new flatbuffers.ByteBuffer(new Uint8Array(bytes));
-    const header = fromByteBuffer(bb);
-    const indexLength = calcTreeSize(header.featuresCount, header.indexNodeSize);
-    Logger.debug('completed: opening http reader');
-    return new HttpReader(headerClient, header, headerLength, indexLength);
-  }
-  async *selectBbox(rect) {
-    const lengthBeforeTree = this.lengthBeforeTree();
-    const bufferedClient = this.headerClient;
-    const readNode = async function (offsetIntoTree, size) {
-      const minReqLength = 0;
-      return bufferedClient.getRange(lengthBeforeTree + offsetIntoTree, size, minReqLength, 'index');
-    };
-    const batches = [];
-    let currentBatch = [];
-    for await (const searchResult of streamSearch(this.header.featuresCount, this.header.indexNodeSize, rect, readNode)) {
-      const [featureOffset,,] = searchResult;
-      let [,, featureLength] = searchResult;
-      if (!featureLength) {
-        Logger.info('final feature');
-        featureLength = 4;
-      }
-      if (currentBatch.length == 0) {
-        currentBatch.push([featureOffset, featureLength]);
-        continue;
-      }
-      const prevFeature = currentBatch[currentBatch.length - 1];
-      const gap = featureOffset - (prevFeature[0] + prevFeature[1]);
-      if (gap > Config.global.extraRequestThreshold()) {
-        Logger.info(`Pushing new feature batch, since gap ${gap} was too large`);
-        batches.push(currentBatch);
-        currentBatch = [];
-      }
-      currentBatch.push([featureOffset, featureLength]);
+    async *selectBbox(rect) {
+        // Read R-Tree index and build filter for features within bbox
+        const lengthBeforeTree = this.lengthBeforeTree();
+        const bufferedClient = this.headerClient;
+        const readNode = async function (offsetIntoTree, size) {
+            const minReqLength = 0;
+            return bufferedClient.getRange(lengthBeforeTree + offsetIntoTree, size, minReqLength, 'index');
+        };
+        const batches = [];
+        let currentBatch = [];
+        for await (const searchResult of streamSearch(this.header.featuresCount, this.header.indexNodeSize, rect, readNode)) {
+            const [featureOffset, ,] = searchResult;
+            let [, , featureLength] = searchResult;
+            if (!featureLength) {
+                Logger.info('final feature');
+                // Normally we get the feature length by subtracting between
+                // adjacent nodes from the index, which we can't do for the
+                // _very_ last feature in a dataset.
+                //
+                // We could *guess* the size, but we'd risk overshooting the length,
+                // which will cause some webservers to return HTTP 416: Unsatisfiable range
+                //
+                // So instead we fetch only the final features byte length, stored in the
+                // first 4 bytes.
+                featureLength = 4;
+            }
+            if (currentBatch.length == 0) {
+                currentBatch.push([featureOffset, featureLength]);
+                continue;
+            }
+            const prevFeature = currentBatch[currentBatch.length - 1];
+            const gap = featureOffset - (prevFeature[0] + prevFeature[1]);
+            if (gap > Config.global.extraRequestThreshold()) {
+                Logger.info(`Pushing new feature batch, since gap ${gap} was too large`);
+                batches.push(currentBatch);
+                currentBatch = [];
+            }
+            currentBatch.push([featureOffset, featureLength]);
+        }
+        this.headerClient.logUsage('header+index');
+        if (currentBatch.length > 0) {
+            batches.push(currentBatch);
+        }
+        const promises = batches.flatMap((batch) => this.readFeatureBatch(batch));
+        // Fetch all batches concurrently, yielding features as they become
+        // available, meaning the results may be intermixed.
+        yield* Repeater.merge(promises);
     }
-    this.headerClient.logUsage('header+index');
-    if (currentBatch.length > 0) {
-      batches.push(currentBatch);
+    lengthBeforeTree() {
+        // FGB Layout is: [magicbytes (fixed), headerLength (i32), header (variable), Tree (variable), Features (variable)]
+        return magicbytes.length + SIZE_PREFIX_LEN + this.headerLength;
     }
-    const promises = batches.flatMap(batch => this.readFeatureBatch(batch));
-    yield* Repeater.merge(promises);
-  }
-  lengthBeforeTree() {
-    return magicbytes.length + SIZE_PREFIX_LEN + this.headerLength;
-  }
-  lengthBeforeFeatures() {
-    return this.lengthBeforeTree() + this.indexLength;
-  }
-  buildFeatureClient() {
-    return new BufferedHttpRangeClient(this.headerClient.httpClient);
-  }
-  async *readFeatureBatch(batch) {
-    const [firstFeatureOffset] = batch[0];
-    const [lastFeatureOffset, lastFeatureLength] = batch[batch.length - 1];
-    const batchStart = firstFeatureOffset;
-    const batchEnd = lastFeatureOffset + lastFeatureLength;
-    const batchSize = batchEnd - batchStart;
-    const featureClient = this.buildFeatureClient();
-    let minFeatureReqLength = batchSize;
-    for (const [featureOffset] of batch) {
-      yield await this.readFeature(featureClient, featureOffset, minFeatureReqLength);
-      minFeatureReqLength = 0;
+    lengthBeforeFeatures() {
+        return this.lengthBeforeTree() + this.indexLength;
     }
-    featureClient.logUsage('feature');
-  }
-  async readFeature(featureClient, featureOffset, minFeatureReqLength) {
-    const offset = featureOffset + this.lengthBeforeFeatures();
-    let featureLength;
-    {
-      const bytes = await featureClient.getRange(offset, 4, minFeatureReqLength, 'feature length');
-      featureLength = new DataView(bytes).getUint32(0, true);
+    buildFeatureClient() {
+        return new BufferedHttpRangeClient(this.headerClient.httpClient);
+    }
+    /**
+     * Fetch a batch of features in a single request, yielding each Feature
+     *
+     * `batch`: [offset, length] of features in the batch
+     */
+    async *readFeatureBatch(batch) {
+        const [firstFeatureOffset] = batch[0];
+        const [lastFeatureOffset, lastFeatureLength] = batch[batch.length - 1];
+        const batchStart = firstFeatureOffset;
+        const batchEnd = lastFeatureOffset + lastFeatureLength;
+        const batchSize = batchEnd - batchStart;
+        // A new feature client is needed for each batch to own the underlying buffer as features are yielded.
+        const featureClient = this.buildFeatureClient();
+        let minFeatureReqLength = batchSize;
+        for (const [featureOffset] of batch) {
+            yield await this.readFeature(featureClient, featureOffset, minFeatureReqLength);
+            // Only set minFeatureReqLength for the first request.
+            //
+            // This should only affect a batch that contains the final feature, otherwise
+            // we've calculated `batchSize` to get all the data we need for the batch.
+            // For the very final feature in a dataset, we don't know it's length, so we
+            // will end up executing an extra request for that batch.
+            minFeatureReqLength = 0;
+        }
+        featureClient.logUsage('feature');
+    }
+    async readFeature(featureClient, featureOffset, minFeatureReqLength) {
+        const offset = featureOffset + this.lengthBeforeFeatures();
+        let featureLength;
+        {
+            const bytes = await featureClient.getRange(offset, 4, minFeatureReqLength, 'feature length');
+            featureLength = new DataView(bytes).getUint32(0, true);
+        }
+        const byteBuffer = await featureClient.getRange(offset + 4, featureLength, minFeatureReqLength, 'feature data');
+        const bytes = new Uint8Array(byteBuffer);
+        const bytesAligned = new Uint8Array(featureLength + SIZE_PREFIX_LEN);
+        bytesAligned.set(bytes, SIZE_PREFIX_LEN);
+        const bb = new flatbuffers.ByteBuffer(bytesAligned);
+        bb.setPosition(SIZE_PREFIX_LEN);
+        return Feature.getRootAsFeature(bb);
     }
-    const byteBuffer = await featureClient.getRange(offset + 4, featureLength, minFeatureReqLength, 'feature data');
-    const bytes = new Uint8Array(byteBuffer);
-    const bytesAligned = new Uint8Array(featureLength + SIZE_PREFIX_LEN);
-    bytesAligned.set(bytes, SIZE_PREFIX_LEN);
-    const bb = new flatbuffers.ByteBuffer(bytesAligned);
-    bb.setPosition(SIZE_PREFIX_LEN);
-    return Feature.getRootAsFeature(bb);
-  }
 }
 class BufferedHttpRangeClient {
-  constructor(source) {
-    this.httpClient = void 0;
-    this.bytesEverUsed = 0;
-    this.bytesEverFetched = 0;
-    this.buffer = new ArrayBuffer(0);
-    this.head = 0;
-    if (typeof source === 'string') {
-      this.httpClient = new HttpRangeClient(source);
-    } else if (source instanceof HttpRangeClient) {
-      this.httpClient = source;
-    } else {
-      throw new Error('Unknown source ');
+    httpClient;
+    bytesEverUsed = 0;
+    bytesEverFetched = 0;
+    buffer = new ArrayBuffer(0);
+    // Byte offset of `buffer` with respect to the beginning of the file being
+    // buffered
+    head = 0;
+    constructor(source) {
+        if (typeof source === 'string') {
+            this.httpClient = new HttpRangeClient(source);
+        }
+        else if (source instanceof HttpRangeClient) {
+            this.httpClient = source;
+        }
+        else {
+            throw new Error('Unknown source ');
+        }
+    }
+    async getRange(start, length, minReqLength, purpose) {
+        this.bytesEverUsed += length;
+        const start_i = start - this.head;
+        const end_i = start_i + length;
+        if (start_i >= 0 && end_i <= this.buffer.byteLength) {
+            return this.buffer.slice(start_i, end_i);
+        }
+        const lengthToFetch = Math.max(length, minReqLength);
+        this.bytesEverFetched += lengthToFetch;
+        Logger.debug(`requesting for new Range: ${start}-${start + lengthToFetch - 1}`);
+        this.buffer = await this.httpClient.getRange(start, lengthToFetch, purpose);
+        this.head = start;
+        return this.buffer.slice(0, length);
     }
-  }
-  async getRange(start, length, minReqLength, purpose) {
-    this.bytesEverUsed += length;
-    const start_i = start - this.head;
-    const end_i = start_i + length;
-    if (start_i >= 0 && end_i <= this.buffer.byteLength) {
-      return this.buffer.slice(start_i, end_i);
+    logUsage(purpose) {
+        const category = purpose.split(' ')[0];
+        const used = this.bytesEverUsed;
+        const requested = this.bytesEverFetched;
+        const efficiency = ((100.0 * used) / requested).toFixed(2);
+        Logger.info(`${category} bytes used/requested: ${used} / ${requested} = ${efficiency}%`);
     }
-    const lengthToFetch = Math.max(length, minReqLength);
-    this.bytesEverFetched += lengthToFetch;
-    Logger.debug(`requesting for new Range: ${start}-${start + lengthToFetch - 1}`);
-    this.buffer = await this.httpClient.getRange(start, lengthToFetch, purpose);
-    this.head = start;
-    return this.buffer.slice(0, length);
-  }
-  logUsage(purpose) {
-    const category = purpose.split(' ')[0];
-    const used = this.bytesEverUsed;
-    const requested = this.bytesEverFetched;
-    const efficiency = (100.0 * used / requested).toFixed(2);
-    Logger.info(`${category} bytes used/requested: ${used} / ${requested} = ${efficiency}%`);
-  }
 }
 class HttpRangeClient {
-  constructor(url) {
-    this.url = void 0;
-    this.requestsEverMade = 0;
-    this.bytesEverRequested = 0;
-    this.url = url;
-  }
-  async getRange(begin, length, purpose) {
-    this.requestsEverMade += 1;
-    this.bytesEverRequested += length;
-    const range = `bytes=${begin}-${begin + length - 1}`;
-    Logger.info(`request: #${this.requestsEverMade}, purpose: ${purpose}), bytes: (this_request: ${length}, ever: ${this.bytesEverRequested}), Range: ${range}`);
-    const response = await fetch(this.url, {
-      headers: {
-        Range: range
-      }
-    });
-    return response.arrayBuffer();
-  }
+    url;
+    requestsEverMade = 0;
+    bytesEverRequested = 0;
+    constructor(url) {
+        this.url = url;
+    }
+    async getRange(begin, length, purpose) {
+        this.requestsEverMade += 1;
+        this.bytesEverRequested += length;
+        const range = `bytes=${begin}-${begin + length - 1}`;
+        Logger.info(`request: #${this.requestsEverMade}, purpose: ${purpose}), bytes: (this_request: ${length}, ever: ${this.bytesEverRequested}), Range: ${range}`);
+        const response = await fetch(this.url, {
+            headers: {
+                Range: range
+                // TODO: better parallelize requests on Chrome
+                //
+                // Safari and Firefox have no issue performing Range requests
+                // for a resource in parallel, but Chrome will stall a
+                // subsequent request to the resource until it's received the
+                // response headers of the prior request. So, it still allows
+                // some limited parallelization, but it's not ideal.
+                //
+                // This is seemingly an artifact of how Chrome manages caching
+                // and it might differ between platforms. We could work around it
+                // by setting the request header:
+                //
+                //      'Cache-Control': 'no-cache, no-store'
+                //
+                // This allows requests to be fully parallelized in Chrome, but
+                // then Chrome won't cache the response, so it seems not a
+                // great trade-off.
+                //
+                // Another work around would be to make each Range request for
+                // a separate URL by appending something like
+                // `?cache_buster=<range>` to the URL, but then Chrome will
+                // require an additional CORS preflight OPTIONS requests per
+                // Range, which is also not a great trade-off.
+                //
+                // See:
+                // https://bugs.chromium.org/p/chromium/issues/detail?id=969828&q=concurrent%20range%20requests&can=2
+                // https://stackoverflow.com/questions/27513994/chrome-stalls-when-making-multiple-requests-to-same-resource
+            }
+        });
+        return response.arrayBuffer();
+    }
 }
-//# sourceMappingURL=http-reader.js.map

package/dist/flatgeobuf/3.27.2/index.d.ts

@@ -1,14 +1,14 @@
-export * as generic from './generic';
-export * as geojson from './geojson';
-export { Column } from './flat-geobuf/column';
-export { Geometry } from './flat-geobuf/geometry';
-export { Feature } from './flat-geobuf/feature';
-export { ISimpleGeometry } from './generic/geometry';
-export { IFeature } from './generic/feature';
-export { FromFeatureFn } from './generic/featurecollection';
-export { IGeoJsonFeature } from './geojson/feature';
-export { default as HeaderMeta } from './header-meta';
-export { default as ColumnMeta } from './column-meta';
-export { default as CrsMeta } from './crs-meta';
-export { Rect } from './packedrtree';
+export * as generic from "./generic.js";
+export * as geojson from "./geojson.js";
+export { Column } from "./flat-geobuf/column.js";
+export { Geometry } from "./flat-geobuf/geometry.js";
+export { Feature } from "./flat-geobuf/feature.js";
+export { ISimpleGeometry } from "./generic/geometry.js";
+export { IFeature } from "./generic/feature.js";
+export { FromFeatureFn } from "./generic/featurecollection.js";
+export { IGeoJsonFeature } from "./geojson/feature.js";
+export { default as HeaderMeta } from "./header-meta.js";
+export { default as ColumnMeta } from "./column-meta.js";
+export { default as CrsMeta } from "./crs-meta.js";
+export { Rect } from "./packedrtree.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/flatgeobuf/3.27.2/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/flatgeobuf/3.27.2/index.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,OAAO,MAAM,WAAW,CAAC;AACrC,OAAO,KAAK,OAAO,MAAM,WAAW,CAAC;AAGrC,OAAO,EAAC,MAAM,EAAC,MAAM,sBAAsB,CAAC;AAC5C,OAAO,EAAC,QAAQ,EAAC,MAAM,wBAAwB,CAAC;AAChD,OAAO,EAAC,OAAO,EAAC,MAAM,uBAAuB,CAAC;AAE9C,OAAO,EAAC,eAAe,EAAC,MAAM,oBAAoB,CAAC;AACnD,OAAO,EAAC,QAAQ,EAAC,MAAM,mBAAmB,CAAC;AAC3C,OAAO,EAAC,aAAa,EAAC,MAAM,6BAA6B,CAAC;AAE1D,OAAO,EAAC,eAAe,EAAC,MAAM,mBAAmB,CAAC;AAElD,OAAO,EAAC,OAAO,IAAI,UAAU,EAAC,MAAM,eAAe,CAAC;AACpD,OAAO,EAAC,OAAO,IAAI,UAAU,EAAC,MAAM,eAAe,CAAC;AACpD,OAAO,EAAC,OAAO,IAAI,OAAO,EAAC,MAAM,YAAY,CAAC;AAE9C,OAAO,EAAC,IAAI,EAAC,MAAM,eAAe,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/flatgeobuf/3.27.2/index.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,OAAO,qBAAkB;AACrC,OAAO,KAAK,OAAO,qBAAkB;AAGrC,OAAO,EAAC,MAAM,EAAC,gCAA6B;AAC5C,OAAO,EAAC,QAAQ,EAAC,kCAA+B;AAChD,OAAO,EAAC,OAAO,EAAC,iCAA8B;AAE9C,OAAO,EAAC,eAAe,EAAC,8BAA2B;AACnD,OAAO,EAAC,QAAQ,EAAC,6BAA0B;AAC3C,OAAO,EAAC,aAAa,EAAC,uCAAoC;AAE1D,OAAO,EAAC,eAAe,EAAC,6BAA0B;AAElD,OAAO,EAAC,OAAO,IAAI,UAAU,EAAC,yBAAsB;AACpD,OAAO,EAAC,OAAO,IAAI,UAAU,EAAC,yBAAsB;AACpD,OAAO,EAAC,OAAO,IAAI,OAAO,EAAC,sBAAmB;AAE9C,OAAO,EAAC,IAAI,EAAC,yBAAsB"}

package/dist/flatgeobuf/3.27.2/index.js

@@ -1,16 +1,8 @@
-import * as _generic from "./generic/index.js";
-export { _generic as generic };
-import * as _geojson from "./geojson/index.js";
-export { _geojson as geojson };
+// SPDX-License-Identifier: BSD-2-Clause AND ISC
+// Copyright (c) 2018, Björn Harrtell
+export * as generic from "./generic.js";
+export * as geojson from "./geojson.js";
+// export * as ol from './ol';
 export { Column } from "./flat-geobuf/column.js";
 export { Geometry } from "./flat-geobuf/geometry.js";
 export { Feature } from "./flat-geobuf/feature.js";
-export { ISimpleGeometry } from "./generic/geometry.js";
-export { IFeature } from "./generic/feature.js";
-export { FromFeatureFn } from "./generic/featurecollection.js";
-export { IGeoJsonFeature } from "./geojson/feature.js";
-export { default as HeaderMeta } from "./header-meta.js";
-export { default as ColumnMeta } from "./column-meta.js";
-export { default as CrsMeta } from "./crs-meta.js";
-export { Rect } from "./packedrtree.js";
-//# sourceMappingURL=index.js.map

package/dist/flatgeobuf/3.27.2/logger.js

@@ -1,65 +1,45 @@
-export let LogLevel = function (LogLevel) {
-  LogLevel[LogLevel["Debug"] = 0] = "Debug";
-  LogLevel[LogLevel["Info"] = 1] = "Info";
-  LogLevel[LogLevel["Warn"] = 2] = "Warn";
-  LogLevel[LogLevel["Error"] = 3] = "Error";
-  return LogLevel;
-}({});
+export var LogLevel;
+(function (LogLevel) {
+    LogLevel[LogLevel["Debug"] = 0] = "Debug";
+    LogLevel[LogLevel["Info"] = 1] = "Info";
+    LogLevel[LogLevel["Warn"] = 2] = "Warn";
+    LogLevel[LogLevel["Error"] = 3] = "Error";
+})(LogLevel || (LogLevel = {}));
 export default class Logger {
-  static debug() {
-    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-      args[_key] = arguments[_key];
+    static logLevel = LogLevel.Warn;
+    static debug(...args) {
+        this.log(LogLevel.Debug, ...args);
     }
-    this.log(LogLevel.Debug, ...args);
-  }
-  static info() {
-    for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
-      args[_key2] = arguments[_key2];
+    static info(...args) {
+        this.log(LogLevel.Info, ...args);
     }
-    this.log(LogLevel.Info, ...args);
-  }
-  static warn() {
-    for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
-      args[_key3] = arguments[_key3];
+    static warn(...args) {
+        this.log(LogLevel.Warn, ...args);
     }
-    this.log(LogLevel.Warn, ...args);
-  }
-  static error() {
-    for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
-      args[_key4] = arguments[_key4];
+    static error(...args) {
+        this.log(LogLevel.Error, ...args);
     }
-    this.log(LogLevel.Error, ...args);
-  }
-  static log(level) {
-    if (this.logLevel > level) {
-      return;
-    }
-    for (var _len5 = arguments.length, args = new Array(_len5 > 1 ? _len5 - 1 : 0), _key5 = 1; _key5 < _len5; _key5++) {
-      args[_key5 - 1] = arguments[_key5];
-    }
-    switch (level) {
-      case LogLevel.Debug:
-        {
-          console.debug(...args);
-          break;
-        }
-      case LogLevel.Info:
-        {
-          console.info(...args);
-          break;
-        }
-      case LogLevel.Warn:
-        {
-          console.warn(...args);
-          break;
+    static log(level, ...args) {
+        if (this.logLevel > level) {
+            return;
         }
-      case LogLevel.Error:
-        {
-          console.error(...args);
-          break;
+        switch (level) {
+            case LogLevel.Debug: {
+                console.debug(...args);
+                break;
+            }
+            case LogLevel.Info: {
+                console.info(...args);
+                break;
+            }
+            case LogLevel.Warn: {
+                console.warn(...args);
+                break;
+            }
+            case LogLevel.Error: {
+                console.error(...args);
+                break;
+            }
         }
     }
-  }
 }
-Logger.logLevel = LogLevel.Warn;
-//# sourceMappingURL=logger.js.map