@loaders.gl/tile-converter 4.0.0-alpha.1 → 4.0.0-alpha.10

package/dist/lib/utils/file-utils.js

@@ -1,41 +1,139 @@
-import { promises as fs } from 'fs';
-import { isAbsolute, join } from 'path';
-import { compressFileWithGzip } from './compress-util';
-export async function writeFile(path, data, fileName = 'index.json') {
-  await fs.mkdir(path, {
-    recursive: true
-  });
-  const pathFile = join(path, fileName);
-
-  try {
-    await fs.writeFile(pathFile, data);
-  } catch (err) {
-    throw err;
-  }
-
-  console.log("".concat(pathFile, " saved."));
-  return pathFile;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAbsoluteFilePath = exports.removeFile = exports.removeDir = exports.isFileExists = exports.openJson = exports.writeFileForSlpk = exports.writeFile = void 0;
+const core_1 = require("@loaders.gl/core");
+const loader_utils_1 = require("@loaders.gl/loader-utils");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const compress_util_1 = require("./compress-util");
+/**
+ * Write a file with data and name fileName to path
+ *
+ * @param path - output path
+ * @param data - file content
+ * @param fileName - name of output file (default: index.json)
+ */
+async function writeFile(path, data, fileName = 'index.json') {
+    let toWriteData;
+    if (data instanceof Promise) {
+        toWriteData = new Uint8Array(await data);
+    }
+    else if (data instanceof ArrayBuffer) {
+        toWriteData = new Uint8Array(data);
+    }
+    else {
+        toWriteData = data;
+    }
+    await fs_1.promises.mkdir(path, { recursive: true });
+    const pathFile = (0, path_1.join)(path, fileName);
+    try {
+        await fs_1.promises.writeFile(pathFile, toWriteData);
+    }
+    catch (err) {
+        throw err;
+    }
+    console.log(`${pathFile} saved.`); // eslint-disable-line
+    return pathFile;
 }
-export async function writeFileForSlpk(path, data, fileName = 'index.json', compress = true) {
-  const pathFile = await writeFile(path, data, fileName);
-
-  if (compress) {
-    const pathGzFile = await compressFileWithGzip(pathFile);
-    await removeFile(pathFile);
-    return pathGzFile;
-  }
-
-  return pathFile;
+exports.writeFile = writeFile;
+/**
+ * Write a file with data and name fileName to path - specific one for further packaging into slpk
+ *
+ * @param path - output path
+ * @param data - file content
+ * @param fileName - name of output file (default: index.json)
+ * @param compress - if need to compress file with gzip (default: true)
+ * @param compressList - if set - the file should be added to this list and compressed in the end of conversion
+ */
+async function writeFileForSlpk(path, data, fileName = 'index.json', compress = true, compressList) {
+    const pathFile = await writeFile(path, data, fileName);
+    if (compress) {
+        if (compressList) {
+            if (!compressList.includes(pathFile)) {
+                compressList.push(pathFile);
+                return `${pathFile}.gz`;
+            }
+            else {
+                return null;
+            }
+        }
+        else {
+            const pathGzFile = await (0, compress_util_1.compressFileWithGzip)(pathFile);
+            // After compression, we don't need an uncompressed file
+            await removeFile(pathFile);
+            return pathGzFile;
+        }
+    }
+    return pathFile;
 }
-export function removeDir(path) {
-  return fs.rmdir(path, {
-    recursive: true
-  });
+exports.writeFileForSlpk = writeFileForSlpk;
+/**
+ * Open json file
+ * @param path - path to the file
+ * @param fileName - file name
+ * @returns object
+ */
+async function openJson(path, fileName) {
+    return new Promise((resolve, reject) => {
+        let count = 0;
+        console.log(`load ${path}/${fileName}.`); // eslint-disable-line
+        const intervalId = setInterval(() => {
+            const pathFile = (0, path_1.join)(path, fileName);
+            (0, core_1.load)(pathFile, loader_utils_1.JSONLoader)
+                .then((result) => {
+                clearInterval(intervalId);
+                resolve(result);
+            })
+                .catch(() => {
+                count++;
+                if (count > 100) {
+                    clearInterval(intervalId);
+                    reject(new Error(`Cannon load ${path}/${fileName}.`));
+                }
+            });
+        }, 200);
+    });
 }
-export function removeFile(path) {
-  return fs.unlink(path);
+exports.openJson = openJson;
+/**
+ * Check if the file exists
+ * @param fileName - full name of file
+ * @returns true if file exists, otherwise - false
+ */
+async function isFileExists(fileName) {
+    try {
+        await fs_1.promises.stat(fileName);
+        return true;
+    }
+    catch {
+        return false;
+    }
 }
-export function getAbsoluteFilePath(filePath) {
-  return isAbsolute(filePath) ? filePath : join(process.cwd(), filePath);
+exports.isFileExists = isFileExists;
+/**
+ * Remove dir with path
+ *
+ * @param path
+ */
+function removeDir(path) {
+    // (node:35607) [DEP0147] DeprecationWarning: In future versions of Node.js, fs.rmdir(path, { recursive: true }) will be removed. Use fs.rm(path, { recursive: true }) instead
+    return fs_1.promises.rm(path, { recursive: true });
 }
-//# sourceMappingURL=file-utils.js.map
+exports.removeDir = removeDir;
+/**
+ * Remove file with path
+ *
+ * @param path
+ */
+function removeFile(path) {
+    return fs_1.promises.unlink(path);
+}
+exports.removeFile = removeFile;
+/**
+ * Generates absolute file path
+ * @param filePath
+ */
+function getAbsoluteFilePath(filePath) {
+    return (0, path_1.isAbsolute)(filePath) ? filePath : (0, path_1.join)(process.cwd(), filePath);
+}
+exports.getAbsoluteFilePath = getAbsoluteFilePath;

package/dist/lib/utils/geometry-utils.d.ts

@@ -0,0 +1,9 @@
+/**
+ * luma.gl can not work without indices now:
+ * https://github.com/visgl/luma.gl/blob/d8cad75b9f8ca3e578cf078ed9d19e619c2ddbc9/modules/experimental/src/gltf/gltf-instantiator.js#L115
+ * This method generates syntetic indices array: [0, 1, 2, 3, .... , vertexCount-1]
+ * @param {number} vertexCount - vertex count in the geometry
+ * @returns {Uint32Array} indices array.
+ */
+export declare const generateSyntheticIndices: (vertexCount: number) => Uint32Array;
+//# sourceMappingURL=geometry-utils.d.ts.map

package/dist/lib/utils/geometry-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geometry-utils.d.ts","sourceRoot":"","sources":["../../../src/lib/utils/geometry-utils.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,eAAO,MAAM,wBAAwB,gBAAiB,MAAM,KAAG,WAM9D,CAAC"}

package/dist/lib/utils/geometry-utils.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateSyntheticIndices = void 0;
+/**
+ * luma.gl can not work without indices now:
+ * https://github.com/visgl/luma.gl/blob/d8cad75b9f8ca3e578cf078ed9d19e619c2ddbc9/modules/experimental/src/gltf/gltf-instantiator.js#L115
+ * This method generates syntetic indices array: [0, 1, 2, 3, .... , vertexCount-1]
+ * @param {number} vertexCount - vertex count in the geometry
+ * @returns {Uint32Array} indices array.
+ */
+const generateSyntheticIndices = (vertexCount) => {
+    const result = new Uint32Array(vertexCount);
+    for (let index = 0; index < vertexCount; index++) {
+        result[index] = index;
+    }
+    return result;
+};
+exports.generateSyntheticIndices = generateSyntheticIndices;

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

@@ -1,10 +1,23 @@
+import { Tiles3DTileJSONPostprocessed } from '@loaders.gl/3d-tiles';
+import { BoundingVolumes } from '@loaders.gl/i3s';
+import { Tile3D } from '@loaders.gl/tiles';
 /**
- * Convert LOD metric from "Screen Space Error" to "Screen Threshold"
- * 
- * @param tile - 3d-tiles tile Object
+ * 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 JSON
  * @param coordinates - node converted coordinates
  * @returns An array of LOD metrics in format compatible with i3s 3DNodeIndexDocument.lodSelection
- * @example 
+ * @example
  *  [
         {
             "metricType": "maxScreenThresholdSQ",
@@ -16,17 +29,14 @@
         }
     ]
  */
-export function convertGeometricErrorToScreenThreshold(
-  tile: Object,
-  coordinates: {
-    mbs?: number[];
-  }
-): Array<{metricType: string; maxError: number}>;
-
+export declare function convertGeometricErrorToScreenThreshold(tile: Tiles3DTileJSONPostprocessed, 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,4BAA4B,EAAC,MAAM,sBAAsB,CAAC;AAClE,OAAO,EAAC,eAAe,EAAC,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAC,MAAM,EAAC,MAAM,mBAAmB,CAAC;AAIzC;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,sCAAsC,CACpD,IAAI,EAAE,4BAA4B,EAClC,WAAW,EAAE,eAAe;gBAEK,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 JSON
+ * @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"}