@loaders.gl/tile-converter 4.0.0-alpha.4 → 4.0.0-alpha.6

package/dist/lib/utils/lod-conversion-utils.d.ts

@@ -1,10 +1,22 @@
+import { BoundingVolumes } from '@loaders.gl/i3s';
+import { Tile3D } from '@loaders.gl/tiles';
 /**
- * Convert LOD metric from "Screen Space Error" to "Screen Threshold"
- * 
+ * Do conversion from geometric error to screen threshold
+ *
+ * In 3DTiles we have HLOD logic and parent tile also has bigger lodMetric value then its children.
+ * In I3s we have reverse logic related to maxError. Parent has lower maxError than its child.
+ * In nodes where are no children tile.lodMetricValue is 0. This is because of logic of HLOD in 3DTiles
+ * 3DTiles spec:
+ * https://github.com/CesiumGS/3d-tiles/tree/master/specification#geometric-error
+ * I3S spec:
+ * https://github.com/Esri/i3s-spec/blob/master/docs/1.7/lodSelection.cmn.md
+ * To avoid infinity values when we do calculations of maxError we shold replace 0 with value which allows us
+ * to make child maxError bigger than his parent maxError.
+ *
  * @param tile - 3d-tiles tile Object
  * @param coordinates - node converted coordinates
  * @returns An array of LOD metrics in format compatible with i3s 3DNodeIndexDocument.lodSelection
- * @example 
+ * @example
  *  [
         {
             "metricType": "maxScreenThresholdSQ",
@@ -16,17 +28,14 @@
         }
     ]
  */
-export function convertGeometricErrorToScreenThreshold(
-  tile: Object,
-  coordinates: {
-    mbs?: number[];
-  }
-): Array<{metricType: string; maxError: number}>;
-
+export declare function convertGeometricErrorToScreenThreshold(tile: Tile3D, coordinates: BoundingVolumes): {
+    metricType: string;
+    maxError: number;
+}[];
 /**
  * Convert LOD metric from "Screen Threshold" to "Screen Space Error"
  * @param node - i3s node data
  * @returns lod metric in 3d-tiles format
- * @todo implement this function
  */
-export function convertScreenThresholdToGeometricError(node: Object): number;
+export declare function convertScreenThresholdToGeometricError(node: Tile3D): number;
+//# sourceMappingURL=lod-conversion-utils.d.ts.map

package/dist/lib/utils/lod-conversion-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lod-conversion-utils.d.ts","sourceRoot":"","sources":["../../../src/lib/utils/lod-conversion-utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,eAAe,EAAC,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAC,MAAM,EAAC,MAAM,mBAAmB,CAAC;AAIzC;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,sCAAsC,CAAC,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,eAAe;gBAC9D,MAAM;cAAY,MAAM;IAqB1D;AAED;;;;GAIG;AACH,wBAAgB,sCAAsC,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAe3E"}

package/dist/lib/utils/lod-conversion-utils.js

@@ -1,43 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertScreenThresholdToGeometricError = exports.convertGeometricErrorToScreenThreshold = void 0;
+// https://cesium.com/docs/cesiumjs-ref-doc/Cesium3DTileset.html
 const DEFAULT_MAXIMUM_SCREEN_SPACE_ERROR = 16;
-export function convertGeometricErrorToScreenThreshold(tile, coordinates) {
-  const lodSelection = [];
-  const boundingVolume = tile.boundingVolume;
-  const lodMetricValue = tile.lodMetricValue || 0.1;
-  const maxScreenThreshold = {
-    metricType: 'maxScreenThreshold',
-    maxError: coordinates.mbs[3] * 2 * DEFAULT_MAXIMUM_SCREEN_SPACE_ERROR / lodMetricValue
-  };
-  const maxScreenThresholdSQ = {
-    metricType: 'maxScreenThresholdSQ',
-    maxError: Math.PI * 0.25 * maxScreenThreshold.maxError * maxScreenThreshold.maxError
-  };
-
-  if (boundingVolume.constructor.name === 'OrientedBoundingBox') {
-    lodSelection.push(maxScreenThresholdSQ);
-    lodSelection.push(maxScreenThreshold);
-  } else {
-    lodSelection.push(maxScreenThreshold);
-    lodSelection.push(maxScreenThresholdSQ);
-  }
-
-  return lodSelection;
+/**
+ * Do conversion from geometric error to screen threshold
+ *
+ * In 3DTiles we have HLOD logic and parent tile also has bigger lodMetric value then its children.
+ * In I3s we have reverse logic related to maxError. Parent has lower maxError than its child.
+ * In nodes where are no children tile.lodMetricValue is 0. This is because of logic of HLOD in 3DTiles
+ * 3DTiles spec:
+ * https://github.com/CesiumGS/3d-tiles/tree/master/specification#geometric-error
+ * I3S spec:
+ * https://github.com/Esri/i3s-spec/blob/master/docs/1.7/lodSelection.cmn.md
+ * To avoid infinity values when we do calculations of maxError we shold replace 0 with value which allows us
+ * to make child maxError bigger than his parent maxError.
+ *
+ * @param tile - 3d-tiles tile Object
+ * @param coordinates - node converted coordinates
+ * @returns An array of LOD metrics in format compatible with i3s 3DNodeIndexDocument.lodSelection
+ * @example
+ *  [
+        {
+            "metricType": "maxScreenThresholdSQ",
+            "maxError": 870638.071285568
+        },
+        {
+            "metricType": "maxScreenThreshold",
+            "maxError": 1052.8679031638949
+        }
+    ]
+ */
+function convertGeometricErrorToScreenThreshold(tile, coordinates) {
+    const lodSelection = [];
+    const boundingVolume = tile.boundingVolume;
+    const lodMetricValue = tile.lodMetricValue || 0.1;
+    const maxScreenThreshold = {
+        metricType: 'maxScreenThreshold',
+        maxError: (coordinates.mbs[3] * 2 * DEFAULT_MAXIMUM_SCREEN_SPACE_ERROR) / lodMetricValue
+    };
+    const maxScreenThresholdSQ = {
+        metricType: 'maxScreenThresholdSQ',
+        maxError: Math.PI * 0.25 * maxScreenThreshold.maxError * maxScreenThreshold.maxError
+    };
+    if (boundingVolume.constructor.name === 'OrientedBoundingBox') {
+        lodSelection.push(maxScreenThresholdSQ);
+        lodSelection.push(maxScreenThreshold);
+    }
+    else {
+        lodSelection.push(maxScreenThreshold);
+        lodSelection.push(maxScreenThresholdSQ);
+    }
+    return lodSelection;
 }
-export function convertScreenThresholdToGeometricError(node) {
-  const metricData = node.header.lodSelection.maxScreenThreshold || {};
-  let maxError = metricData.maxError;
-
-  if (!maxError) {
-    const sqMetricData = node.header.lodSelection.maxScreenThresholdSQ;
-
-    if (sqMetricData) {
-      maxError = Math.sqrt(sqMetricData.maxError / (Math.PI * 0.25));
+exports.convertGeometricErrorToScreenThreshold = convertGeometricErrorToScreenThreshold;
+/**
+ * Convert LOD metric from "Screen Threshold" to "Screen Space Error"
+ * @param node - i3s node data
+ * @returns lod metric in 3d-tiles format
+ */
+function convertScreenThresholdToGeometricError(node) {
+    const metricData = node.header.lodSelection.maxScreenThreshold || {};
+    let maxError = metricData.maxError;
+    if (!maxError) {
+        const sqMetricData = node.header.lodSelection.maxScreenThresholdSQ;
+        if (sqMetricData) {
+            maxError = Math.sqrt(sqMetricData.maxError / (Math.PI * 0.25));
+        }
+    }
+    if (!maxError) {
+        maxError = DEFAULT_MAXIMUM_SCREEN_SPACE_ERROR;
     }
-  }
-
-  if (!maxError) {
-    maxError = DEFAULT_MAXIMUM_SCREEN_SPACE_ERROR;
-  }
-
-  return node.header.mbs[3] * 2 * DEFAULT_MAXIMUM_SCREEN_SPACE_ERROR / maxError;
+    return (node.header.mbs[3] * 2 * DEFAULT_MAXIMUM_SCREEN_SPACE_ERROR) / maxError;
 }
-//# sourceMappingURL=lod-conversion-utils.js.map
+exports.convertScreenThresholdToGeometricError = convertScreenThresholdToGeometricError;

package/dist/lib/utils/queue.d.ts

@@ -0,0 +1,7 @@
+export declare class Queue<T> extends Array<T> {
+    enqueue(val: T): void;
+    dequeue(): T | undefined;
+    peek(): T;
+    isEmpty(): boolean;
+}
+//# sourceMappingURL=queue.d.ts.map

package/dist/lib/utils/queue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queue.d.ts","sourceRoot":"","sources":["../../../src/lib/utils/queue.ts"],"names":[],"mappings":"AAAA,qBAAa,KAAK,CAAC,CAAC,CAAE,SAAQ,KAAK,CAAC,CAAC,CAAC;IACpC,OAAO,CAAC,GAAG,EAAE,CAAC;IAId,OAAO,IAAI,CAAC,GAAG,SAAS;IAIxB,IAAI,IAAI,CAAC;IAIT,OAAO;CAGR"}

package/dist/lib/utils/queue.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Queue = void 0;
+class Queue extends Array {
+    enqueue(val) {
+        this.push(val);
+    }
+    dequeue() {
+        return this.shift();
+    }
+    peek() {
+        return this[0];
+    }
+    isEmpty() {
+        return this.length === 0;
+    }
+}
+exports.Queue = Queue;

package/dist/lib/utils/statistic-utills.d.ts

@@ -1,25 +1,3 @@
-/**
- * Do milliseconds time conversion to readable time string.
- * @param tile - 3d-tiles tile Object
- * @param coordinates - node converted coordinates
- * @returns String which characterizes conversion time period
- */
-export function timeConverter(time: [number, number]): String;
-
-/**
- * Calculate files sizes after conversion.
- * @param params - Object with params of conversion.
- * @returns Promise with generated files size in bytes.
- */
-export function calculateFilesSize(params: {
-  slpk: boolean;
-  outputPath: string;
-  tilesetName: string;
-}): Number;
-
-/**
- * Reqursivelly calculate files sizes in directory.
- * @param dirPath - Directory path.
- * @returns Promise with files size in directory.
- */
-export function getTotalFilesSize(dirPath: string): Number;
+export declare function timeConverter(time: any): string;
+export declare function calculateFilesSize(params: any): Promise<number | null>;
+//# sourceMappingURL=statistic-utills.d.ts.map

package/dist/lib/utils/statistic-utills.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"statistic-utills.d.ts","sourceRoot":"","sources":["../../../src/lib/utils/statistic-utills.ts"],"names":[],"mappings":"AAIA,wBAAgB,aAAa,CAAC,IAAI,KAAA,UA4BjC;AAED,wBAAsB,kBAAkB,CAAC,MAAM,KAAA,0BAkB9C"}

package/dist/lib/utils/statistic-utills.js

@@ -1,73 +1,64 @@
-import { join } from 'path';
-import { promises as fs } from 'fs';
-import { getAbsoluteFilePath } from './file-utils';
-export function timeConverter(time) {
-  const nanoSecondsInMillisecond = 1e6;
-  let timeInSeconds = time[0];
-  const hours = Math.floor(timeInSeconds / 3600);
-  timeInSeconds = timeInSeconds - hours * 3600;
-  const minutes = Math.floor(timeInSeconds / 60);
-  timeInSeconds = timeInSeconds - minutes * 60;
-  const seconds = Math.floor(timeInSeconds);
-  const milliseconds = time[1] / nanoSecondsInMillisecond;
-  let result = '';
-
-  if (hours) {
-    result += "".concat(hours, "h ");
-  }
-
-  if (minutes) {
-    result += "".concat(minutes, "m ");
-  }
-
-  if (seconds) {
-    result += "".concat(seconds, "s");
-  }
-
-  if (!result) {
-    result += "".concat(milliseconds, "ms");
-  }
-
-  return result;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateFilesSize = exports.timeConverter = void 0;
+const path_1 = require("path");
+const fs_1 = require("fs");
+const file_utils_1 = require("./file-utils");
+function timeConverter(time) {
+    const nanoSecondsInMillisecond = 1e6;
+    let timeInSeconds = time[0];
+    const hours = Math.floor(timeInSeconds / 3600);
+    timeInSeconds = timeInSeconds - hours * 3600;
+    const minutes = Math.floor(timeInSeconds / 60);
+    timeInSeconds = timeInSeconds - minutes * 60;
+    const seconds = Math.floor(timeInSeconds);
+    const milliseconds = time[1] / nanoSecondsInMillisecond;
+    let result = '';
+    if (hours) {
+        result += `${hours}h `;
+    }
+    if (minutes) {
+        result += `${minutes}m `;
+    }
+    if (seconds) {
+        result += `${seconds}s`;
+    }
+    if (!result) {
+        result += `${milliseconds}ms`;
+    }
+    return result;
 }
-export async function calculateFilesSize(params) {
-  const {
-    slpk,
-    outputPath,
-    tilesetName
-  } = params;
-  const fullOutputPath = getAbsoluteFilePath(outputPath);
-
-  try {
-    if (slpk) {
-      const slpkPath = join(fullOutputPath, "".concat(tilesetName, ".slpk"));
-      const stat = await fs.stat(slpkPath);
-      return stat.size;
+exports.timeConverter = timeConverter;
+async function calculateFilesSize(params) {
+    const { slpk, outputPath, tilesetName } = params;
+    const fullOutputPath = (0, file_utils_1.getAbsoluteFilePath)(outputPath);
+    try {
+        if (slpk) {
+            const slpkPath = (0, path_1.join)(fullOutputPath, `${tilesetName}.slpk`);
+            const stat = await fs_1.promises.stat(slpkPath);
+            return stat.size;
+        }
+        const directoryPath = (0, path_1.join)(fullOutputPath, tilesetName);
+        const totalSize = await getTotalFilesSize(directoryPath);
+        return totalSize;
+    }
+    catch (error) {
+        console.log('Calculate file sizes error: ', error); // eslint-disable-line
+        return null;
     }
-
-    const directoryPath = join(fullOutputPath, tilesetName);
-    const totalSize = await getTotalFilesSize(directoryPath);
-    return totalSize;
-  } catch (error) {
-    console.log('Calculate file sizes error: ', error);
-    return null;
-  }
 }
-
+exports.calculateFilesSize = calculateFilesSize;
 async function getTotalFilesSize(dirPath) {
-  let totalFileSize = 0;
-  const files = await fs.readdir(dirPath);
-
-  for (const file of files) {
-    const fileStat = await fs.stat(join(dirPath, file));
-
-    if (fileStat.isDirectory()) {
-      totalFileSize += await getTotalFilesSize(join(dirPath, file));
-    } else {
-      totalFileSize += fileStat.size;
+    let totalFileSize = 0;
+    const files = await fs_1.promises.readdir(dirPath);
+    for (const file of files) {
+        const fileStat = await fs_1.promises.stat((0, path_1.join)(dirPath, file));
+        if (fileStat.isDirectory()) {
+            totalFileSize += await getTotalFilesSize((0, path_1.join)(dirPath, file));
+        }
+        else {
+            totalFileSize += fileStat.size;
+        }
     }
-  }
-
-  return totalFileSize;
+    return totalFileSize;
 }
-//# sourceMappingURL=statistic-utills.js.map

package/dist/lib/utils/write-queue.d.ts

@@ -0,0 +1,39 @@
+import { Queue } from './queue';
+export type WriteQueueItem = {
+    archiveKey?: string;
+    /**
+     * writePromise() returns a Promise that will be awaited in Promise.allSettled(promises);
+     * Arguments for this call are specified in writeQueue.enqueue call like this:
+     * await writeQueue.enqueue({
+     *     archiveKey: `nodePages/xxx.json.gz`,
+     *     writePromise: () => writeFileForSlpk(slpkPath, data, `xxx.json`)
+     * });
+     * Note, a function like writeFileForSlpk should NOT be called when initializing the object for enqueue().
+     * If he function is called, the promise will be created
+     * and the function will allocate resources (file descriptors) for file writing.
+     * It will be done for ALL items in the queue, which is not supposed to happen.
+     * That's why the function should be passed as
+     *   writePromise: () => writeFileForSlpk(slpkPath, content, `xxx.json`)
+     * instead of
+     *  writePromise: writeFileForSlpk(slpkPath, content, `xxx.json`) // INCORRECT !
+     */
+    writePromise: () => Promise<string | null>;
+};
+export default class WriteQueue<T extends WriteQueueItem> extends Queue<T> {
+    private intervalId?;
+    writePromise: Promise<void> | null;
+    fileMap: {
+        [key: string]: string;
+    };
+    listeningInterval: number;
+    writeConcurrency: number;
+    constructor(listeningInterval?: number, writeConcurrency?: number);
+    enqueue(val: T, writeImmediately?: boolean): Promise<void>;
+    startListening(): void;
+    stopListening(): void;
+    startWrite(): Promise<void>;
+    finalize(): Promise<void>;
+    private doWrite;
+    private updateFileMap;
+}
+//# sourceMappingURL=write-queue.d.ts.map

package/dist/lib/utils/write-queue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"write-queue.d.ts","sourceRoot":"","sources":["../../../src/lib/utils/write-queue.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,KAAK,EAAC,MAAM,SAAS,CAAC;AAM9B,MAAM,MAAM,cAAc,GAAG;IAC3B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;;;;;;;;;;;;;OAeG;IACH,YAAY,EAAE,MAAM,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;CAC5C,CAAC;AAEF,MAAM,CAAC,OAAO,OAAO,UAAU,CAAC,CAAC,SAAS,cAAc,CAAE,SAAQ,KAAK,CAAC,CAAC,CAAC;IACxE,OAAO,CAAC,UAAU,CAAC,CAAiB;IAC7B,YAAY,EAAE,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAQ;IAC1C,OAAO,EAAE;QAAC,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;KAAC,CAAM;IACtC,iBAAiB,EAAE,MAAM,CAAC;IAC1B,gBAAgB,EAAE,MAAM,CAAC;gBAEpB,iBAAiB,GAAE,MAAa,EAAE,gBAAgB,GAAE,MAAY;IAMtE,OAAO,CAAC,GAAG,EAAE,CAAC,EAAE,gBAAgB,GAAE,OAAe;IAgBvD,cAAc;IAId,aAAa;IAMP,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAQ3B,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;YAKjB,OAAO;IAmBrB,OAAO,CAAC,aAAa;CAWtB"}

package/dist/lib/utils/write-queue.js

@@ -0,0 +1,80 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const queue_1 = require("./queue");
+const process_1 = __importDefault(require("process"));
+/** Memory limit size is based on testing */
+const MEMORY_LIMIT = 4 * 1024 * 1024 * 1024; // 4GB
+class WriteQueue extends queue_1.Queue {
+    constructor(listeningInterval = 2000, writeConcurrency = 400) {
+        super();
+        this.writePromise = null;
+        this.fileMap = {};
+        this.listeningInterval = listeningInterval;
+        this.writeConcurrency = writeConcurrency;
+    }
+    async enqueue(val, writeImmediately = false) {
+        if (writeImmediately) {
+            const { archiveKey, writePromise } = val;
+            const result = await writePromise();
+            if (archiveKey && result) {
+                this.fileMap[archiveKey] = result;
+            }
+        }
+        else {
+            super.enqueue(val);
+            /** https://nodejs.org/docs/latest-v14.x/api/process.html#process_process_memoryusage */
+            if (process_1.default.memoryUsage().rss > MEMORY_LIMIT) {
+                await this.startWrite();
+            }
+        }
+    }
+    startListening() {
+        this.intervalId = setInterval(this.startWrite.bind(this), this.listeningInterval);
+    }
+    stopListening() {
+        if (this.intervalId) {
+            clearInterval(this.intervalId);
+        }
+    }
+    async startWrite() {
+        if (!this.writePromise) {
+            this.writePromise = this.doWrite();
+        }
+        await this.writePromise;
+        this.writePromise = null;
+    }
+    async finalize() {
+        this.stopListening();
+        await this.startWrite();
+    }
+    async doWrite() {
+        while (this.length) {
+            const promises = [];
+            const archiveKeys = [];
+            for (let i = 0; i < this.writeConcurrency; i++) {
+                const item = this.dequeue();
+                if (!item) {
+                    break;
+                }
+                const { archiveKey, writePromise } = item;
+                archiveKeys.push(archiveKey);
+                const promise = writePromise();
+                promises.push(promise);
+            }
+            const writeResults = await Promise.allSettled(promises);
+            this.updateFileMap(archiveKeys, writeResults);
+        }
+    }
+    updateFileMap(archiveKeys, writeResults) {
+        for (let i = 0; i < archiveKeys.length; i++) {
+            const archiveKey = archiveKeys[i];
+            if (archiveKey && 'value' in writeResults[i]) {
+                this.fileMap[archiveKey] = writeResults[i].value;
+            }
+        }
+    }
+}
+exports.default = WriteQueue;

package/dist/pgm-loader.d.ts

@@ -0,0 +1,6 @@
+import type { LoaderWithParser } from '@loaders.gl/loader-utils';
+/**
+ * Loader for PGM - Netpbm grayscale image format
+ */
+export declare const PGMLoader: LoaderWithParser;
+//# sourceMappingURL=pgm-loader.d.ts.map

package/dist/pgm-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pgm-loader.d.ts","sourceRoot":"","sources":["../src/pgm-loader.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,0BAA0B,CAAC;AAO/D;;GAEG;AACH,eAAO,MAAM,SAAS,EAAE,gBAavB,CAAC"}

package/dist/pgm-loader.js

@@ -1,15 +1,24 @@
-const VERSION = typeof "4.0.0-alpha.4" !== 'undefined' ? "4.0.0-alpha.4" : 'latest';
-import { parsePgm } from './lib/pgm-parser';
-export const PGMLoader = {
-  name: 'PGM - Netpbm grayscale image format',
-  id: 'pgm',
-  module: 'tile-converter',
-  version: VERSION,
-  mimeTypes: ['image/x-portable-graymap'],
-  parse: (arrayBuffer, options) => parsePgm(new Uint8Array(arrayBuffer), options),
-  extensions: ['pgm'],
-  options: {
-    cubic: false
-  }
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PGMLoader = void 0;
+const geoid_1 = require("@math.gl/geoid");
+// __VERSION__ is injected by babel-plugin-version-inline
+// @ts-ignore TS2304: Cannot find name '__VERSION__'.
+const VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';
+/**
+ * Loader for PGM - Netpbm grayscale image format
+ */
+exports.PGMLoader = {
+    name: 'PGM - Netpbm grayscale image format',
+    id: 'pgm',
+    module: 'tile-converter',
+    version: VERSION,
+    mimeTypes: ['image/x-portable-graymap'],
+    // @ts-expect-error LoaderOptions does not have cubic parameter
+    parse: async (arrayBuffer, options) => (0, geoid_1.parsePGM)(new Uint8Array(arrayBuffer), options),
+    extensions: ['pgm'],
+    options: {
+        // TODO - use pgm namespace
+        cubic: false
+    }
 };
-//# sourceMappingURL=pgm-loader.js.map

package/dist/workers/3d-tiles-attributes-worker.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=3d-tiles-attributes-worker.d.ts.map

package/dist/workers/3d-tiles-attributes-worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"3d-tiles-attributes-worker.d.ts","sourceRoot":"","sources":["../../src/workers/3d-tiles-attributes-worker.ts"],"names":[],"mappings":""}

package/dist/workers/3d-tiles-attributes-worker.js

@@ -0,0 +1,9 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const worker_utils_1 = require("@loaders.gl/worker-utils");
+const b3dm_converter_1 = __importDefault(require("../3d-tiles-converter/helpers/b3dm-converter"));
+const b3dmConverter = new b3dm_converter_1.default();
+(0, worker_utils_1.createWorker)(async (data, options = {}) => b3dmConverter.convert(data, options.featureAttributes));

package/dist/workers/i3s-attributes-worker.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=i3s-attributes-worker.d.ts.map

package/dist/workers/i3s-attributes-worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"i3s-attributes-worker.d.ts","sourceRoot":"","sources":["../../src/workers/i3s-attributes-worker.ts"],"names":[],"mappings":""}

package/dist/workers/i3s-attributes-worker.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const worker_utils_1 = require("@loaders.gl/worker-utils");
+const geometry_converter_1 = require("../i3s-converter/helpers/geometry-converter");
+(0, worker_utils_1.createWorker)(async (data, options = {}) => await (0, geometry_converter_1.convertAttributes)(data, options.materialAndTextureList, options.useCartesianPositions));