@loaders.gl/tile-converter 3.2.0-alpha.1 → 3.2.0-alpha.4

package/dist/i3s-converter/helpers/gltf-attributes.d.ts

@@ -0,0 +1,9 @@
+import type { B3DMContent } from '@loaders.gl/3d-tiles';
+import type { B3DMAttributesData } from '../../i3s-attributes-worker';
+/**
+ * Prepare attributes for conversion to avoid binary data breaking in worker thread.
+ * @param tileContent
+ * @returns
+ */
+export declare function prepareDataForAttributesConversion(tileContent: B3DMContent): B3DMAttributesData;
+//# sourceMappingURL=gltf-attributes.d.ts.map

package/dist/i3s-converter/helpers/gltf-attributes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gltf-attributes.d.ts","sourceRoot":"","sources":["../../../src/i3s-converter/helpers/gltf-attributes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,sBAAsB,CAAC;AAEtD,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,6BAA6B,CAAC;AAsBpE;;;;GAIG;AACH,wBAAgB,kCAAkC,CAAC,WAAW,EAAE,WAAW,GAAG,kBAAkB,CAsC/F"}

package/dist/i3s-converter/helpers/gltf-attributes.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepareDataForAttributesConversion = void 0;
+/**
+ * Keep only values for B3DM attributes to pass data to worker thread.
+ * @param attributes
+ */
+function getB3DMAttributesWithoutBufferView(attributes) {
+    const attributesWithoutBufferView = {};
+    for (const attributeName in attributes) {
+        attributesWithoutBufferView[attributeName] = {
+            value: attributes[attributeName].value
+        };
+    }
+    return attributesWithoutBufferView;
+}
+/**
+ * Prepare attributes for conversion to avoid binary data breaking in worker thread.
+ * @param tileContent
+ * @returns
+ */
+function prepareDataForAttributesConversion(tileContent) {
+    const gltfMaterials = tileContent.gltf?.materials?.map((material) => ({ id: material.id }));
+    let nodes = tileContent.gltf?.scene?.nodes ||
+        tileContent.gltf?.scenes?.[0]?.nodes ||
+        tileContent.gltf?.nodes ||
+        [];
+    const prepearedNodes = nodes.map((node) => {
+        if (!node.mesh) {
+            return node;
+        }
+        return {
+            ...node,
+            mesh: {
+                ...node.mesh,
+                primitives: node.mesh?.primitives.map((primitive) => ({
+                    ...primitive,
+                    indices: { value: primitive?.indices?.value },
+                    attributes: getB3DMAttributesWithoutBufferView(primitive.attributes),
+                    material: {
+                        id: primitive?.material?.id
+                    }
+                }))
+            }
+        };
+    });
+    const cartographicOrigin = tileContent.cartographicOrigin;
+    const cartesianModelMatrix = tileContent.cartesianModelMatrix;
+    return {
+        gltfMaterials,
+        nodes: prepearedNodes,
+        cartographicOrigin,
+        cartesianModelMatrix
+    };
+}
+exports.prepareDataForAttributesConversion = prepareDataForAttributesConversion;

package/dist/i3s-converter/helpers/node-pages.d.ts

@@ -1,4 +1,6 @@
+import type { WriteQueueItem } from '../../lib/utils/write-queue';
 import { NodeInPage } from '@loaders.gl/i3s';
+import WriteQueue from '../../lib/utils/write-queue';
 /**
  * class NodePages - wrapper of nodePages array
  *
@@ -106,11 +108,10 @@ export default class NodePages {
     /**
      * Save all the node pages
      * Run this method when all nodes is pushed in nodePages
-     * @param {string} layers0Path - path of layer
-     * @param {Object} fileMap - fileMap which keep info for slpk archive
-     * @param {boolean} slpk
-     * @return {promise}
+     * @param layers0Path - path of layer
+     * @param writeQueue - write queue that controlls files write concurrency
+     * @param slpk
      */
-    save(layers0Path: string, fileMap: Object, slpk?: boolean): Promise<void>;
+    save(layers0Path: string, writeQueue: WriteQueue<WriteQueueItem>, slpk?: boolean): Promise<void>;
 }
 //# sourceMappingURL=node-pages.d.ts.map

package/dist/i3s-converter/helpers/node-pages.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"node-pages.d.ts","sourceRoot":"","sources":["../../../src/i3s-converter/helpers/node-pages.ts"],"names":[],"mappings":"AAGA,OAAO,EAAC,UAAU,EAAC,MAAM,iBAAiB,CAAC;AAG3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,MAAM,CAAC,OAAO,OAAO,SAAS;IAC5B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,QAAQ,CAAC;IACpB,QAAQ,CAAC,SAAS,EAAE;QAAC,KAAK,EAAE,UAAU,EAAE,CAAA;KAAC,EAAE,CAAC;IAE5C;;;;;OAKG;gBACS,aAAa,KAAA,EAAE,YAAY,KAAA;IASvC;;;OAGG;IACH,gBAAgB,CAAC,IAAI,EAAE,QAAQ,GAAG,IAAI;IAItC;;;;OAIG;IACH,WAAW,CAAC,EAAE,EAAE,MAAM,GAAG,UAAU;IAMnC;;;;OAIG;IACH,sBAAsB,CAAC,EAAE,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,IAAI;IAW5D;;;;OAIG;IACH,yBAAyB,CAAC,EAAE,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,IAAI;IAQhE;;;OAGG;IACH,2BAA2B,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAQ7C;;;;OAIG;IACH,0BAA0B,CAAC,EAAE,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,IAAI;IAQlE;;;;OAIG;IACH,4BAA4B,CAAC,EAAE,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,GAAG,IAAI;IAQtE;;;;OAIG;IACH,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI;IAQrE;;;OAGG;IACH,oBAAoB,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI;IAM5C;;;;;OAKG;IACH,IAAI,CAAC,IAAI,EAAE,UAAU,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM;IAajD;;;;;;;OAOG;IACG,IAAI,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,GAAE,OAAe,GAAG,OAAO,CAAC,IAAI,CAAC;CA2BvF"}
+{"version":3,"file":"node-pages.d.ts","sourceRoot":"","sources":["../../../src/i3s-converter/helpers/node-pages.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,6BAA6B,CAAC;AAKhE,OAAO,EAAC,UAAU,EAAC,MAAM,iBAAiB,CAAC;AAC3C,OAAO,UAAU,MAAM,6BAA6B,CAAC;AAGrD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,MAAM,CAAC,OAAO,OAAO,SAAS;IAC5B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,QAAQ,CAAC;IACpB,QAAQ,CAAC,SAAS,EAAE;QAAC,KAAK,EAAE,UAAU,EAAE,CAAA;KAAC,EAAE,CAAC;IAE5C;;;;;OAKG;gBACS,aAAa,KAAA,EAAE,YAAY,KAAA;IASvC;;;OAGG;IACH,gBAAgB,CAAC,IAAI,EAAE,QAAQ,GAAG,IAAI;IAItC;;;;OAIG;IACH,WAAW,CAAC,EAAE,EAAE,MAAM,GAAG,UAAU;IAMnC;;;;OAIG;IACH,sBAAsB,CAAC,EAAE,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,IAAI;IAW5D;;;;OAIG;IACH,yBAAyB,CAAC,EAAE,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,IAAI;IAQhE;;;OAGG;IACH,2BAA2B,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAQ7C;;;;OAIG;IACH,0BAA0B,CAAC,EAAE,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,IAAI;IAQlE;;;;OAIG;IACH,4BAA4B,CAAC,EAAE,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,GAAG,IAAI;IAQtE;;;;OAIG;IACH,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI;IAQrE;;;OAGG;IACH,oBAAoB,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI;IAM5C;;;;;OAKG;IACH,IAAI,CAAC,IAAI,EAAE,UAAU,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM;IAajD;;;;;;OAMG;IACG,IAAI,CACR,WAAW,EAAE,MAAM,EACnB,UAAU,EAAE,UAAU,CAAC,cAAc,CAAC,EACtC,IAAI,GAAE,OAAe,GACpB,OAAO,CAAC,IAAI,CAAC;CA6BjB"}

package/dist/i3s-converter/helpers/node-pages.js

@@ -175,27 +175,32 @@ class NodePages {
     /**
      * Save all the node pages
      * Run this method when all nodes is pushed in nodePages
-     * @param {string} layers0Path - path of layer
-     * @param {Object} fileMap - fileMap which keep info for slpk archive
-     * @param {boolean} slpk
-     * @return {promise}
+     * @param layers0Path - path of layer
+     * @param writeQueue - write queue that controlls files write concurrency
+     * @param slpk
      */
-    async save(layers0Path, fileMap, slpk = false) {
+    async save(layers0Path, writeQueue, slpk = false) {
         if (slpk) {
             for (const [index, nodePage] of this.nodePages.entries()) {
                 const nodePageStr = JSON.stringify(nodePage);
                 const slpkPath = (0, path_1.join)(layers0Path, 'nodepages');
-                fileMap[`nodePages/${index.toString()}.json.gz`] = await this.writeFile(slpkPath, nodePageStr, `${index.toString()}.json`);
+                writeQueue.enqueue({
+                    archiveKey: `nodePages/${index.toString()}.json.gz`,
+                    writePromise: this.writeFile(slpkPath, nodePageStr, `${index.toString()}.json`)
+                });
             }
             const metadata = (0, json_map_transform_1.default)({ nodeCount: this.nodesCounter }, (0, metadata_1.METADATA)());
             const compress = false;
-            fileMap['metadata.json'] = await this.writeFile(layers0Path, JSON.stringify(metadata), 'metadata.json', compress);
+            writeQueue.enqueue({
+                archiveKey: 'metadata.json',
+                writePromise: this.writeFile(layers0Path, JSON.stringify(metadata), 'metadata.json', compress)
+            });
         }
         else {
             for (const [index, nodePage] of this.nodePages.entries()) {
                 const nodePageStr = JSON.stringify(nodePage);
                 const nodePagePath = (0, path_1.join)(layers0Path, 'nodepages', index.toString());
-                await this.writeFile(nodePagePath, nodePageStr);
+                writeQueue.enqueue({ writePromise: this.writeFile(nodePagePath, nodePageStr) });
             }
         }
     }

package/dist/i3s-converter/i3s-converter.d.ts

@@ -1,17 +1,16 @@
+import type { WriteQueueItem } from '../lib/utils/write-queue';
 import type { SceneLayer3D } from '@loaders.gl/i3s';
 import { Tileset3D } from '@loaders.gl/tiles';
 import { Geoid } from '@math.gl/geoid';
 import NodePages from './helpers/node-pages';
 import { LoaderWithParser } from '@loaders.gl/loader-utils';
 import { I3SMaterialDefinition } from '@loaders.gl/i3s/src/types';
+import WriteQueue from '../lib/utils/write-queue';
 /**
  * Converter from 3d-tiles tileset to i3s layer
  */
 export default class I3SConverter {
     nodePages: NodePages;
-    fileMap: {
-        [key: string]: string;
-    };
     options: any;
     layers0Path: string;
     materialMap: Map<any, any>;
@@ -33,6 +32,10 @@ export default class I3SConverter {
     generateTextures: boolean;
     generateBoundingVolumes: boolean;
     layersHasTexture: boolean;
+    workerSource: {
+        [key: string]: string;
+    };
+    writeQueue: WriteQueue<WriteQueueItem>;
     constructor();
     /**
      * Convert a 3d tileset
@@ -61,8 +64,6 @@ export default class I3SConverter {
         validate?: boolean;
         generateTextures?: boolean;
         generateBoundingVolumes?: boolean;
-        /** @deprecated */
-        inputType?: string;
     }): Promise<any>;
     /**
      * Convert and save the layer and embedded tiles
@@ -317,5 +318,6 @@ export default class I3SConverter {
      * @returns
      */
     private isContentSupported;
+    private loadWorkers;
 }
 //# sourceMappingURL=i3s-converter.d.ts.map

package/dist/i3s-converter/i3s-converter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"i3s-converter.d.ts","sourceRoot":"","sources":["../../src/i3s-converter/i3s-converter.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAEV,YAAY,EAab,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EAAC,SAAS,EAAC,MAAM,mBAAmB,CAAC;AAE5C,OAAO,EAAC,KAAK,EAAC,MAAM,gBAAgB,CAAC;AAOrC,OAAO,SAAS,MAAM,sBAAsB,CAAC;AAuB7C,OAAO,EAAC,gBAAgB,EAAC,MAAM,0BAA0B,CAAC;AAC1D,OAAO,EAAC,qBAAqB,EAA8B,MAAM,2BAA2B,CAAC;AAmB7F;;GAEG;AACH,MAAM,CAAC,OAAO,OAAO,YAAY;IAC/B,SAAS,EAAE,SAAS,CAAC;IACrB,OAAO,EAAE;QAAC,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;KAAC,CAAC;IACjC,OAAO,EAAE,GAAG,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,GAAG,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC;IAC3B,mBAAmB,EAAE,qBAAqB,EAAE,CAAC;IAC7C,aAAa,EAAE,MAAM,CAAC;IACtB,OAAO,EAAE,YAAY,GAAG,IAAI,CAAC;IAC7B,iBAAiB,EAAE,MAAM,EAAE,CAAC;IAC5B,iBAAiB,EAAE;QACjB,UAAU,EAAE,MAAM,CAAC;QACnB,uBAAuB,EAAE,MAAM,CAAC;KACjC,CAAC;IACF,QAAQ,EAAE,OAAO,CAAC;IAClB,sBAAsB,CAAC,EAAE,MAAM,EAAE,CAAM;IACvC,mBAAmB,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAU;IAC/C,gBAAgB,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAU;IAC5C,aAAa,EAAE,SAAS,GAAG,IAAI,CAAQ;IACvC,gBAAgB,EAAE,KAAK,GAAG,IAAI,CAAQ;IACtC,MAAM,EAAE,gBAAgB,CAAiB;IACzC,gBAAgB,EAAE,OAAO,CAAC;IAC1B,uBAAuB,EAAE,OAAO,CAAC;IACjC,gBAAgB,EAAE,OAAO,CAAC;;IAsB1B;;;;;;;;;;;;;OAaG;IACG,OAAO,CAAC,OAAO,EAAE;QACrB,QAAQ,EAAE,MAAM,CAAC;QACjB,UAAU,EAAE,MAAM,CAAC;QACnB,WAAW,EAAE,MAAM,CAAC;QACpB,WAAW,EAAE,MAAM,CAAC;QACpB,WAAW,EAAE,MAAM,CAAC;QACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,IAAI,CAAC,EAAE,OAAO,CAAC;QACf,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,KAAK,CAAC,EAAE,OAAO,CAAC;QAChB,QAAQ,CAAC,EAAE,OAAO,CAAC;QACnB,gBAAgB,CAAC,EAAE,OAAO,CAAC;QAC3B,uBAAuB,CAAC,EAAE,OAAO,CAAC;QAClC,kBAAkB;QAClB,SAAS,CAAC,EAAE,MAAM,CAAC;KACpB,GAAG,OAAO,CAAC,GAAG,CAAC;IA6ChB;;;;OAIG;YACW,qBAAqB;IA8CnC;;;OAGG;IACH,OAAO,CAAC,YAAY;IAoBpB;;;;OAIG;IACH,OAAO,CAAC,0BAA0B;IAqBlC;;;;;;OAMG;YACW,iBAAiB;IAqC/B;;OAEG;YACW,aAAa;IAY3B;;OAEG;YACW,uBAAuB;IAgBrC;;;OAGG;YACW,WAAW;IAuCzB;;;;;;;OAOG;YACW,qCAAqC;IAWnD;;;;;;;;OAQG;YACW,YAAY;IAyC1B;;;;OAIG;YACW,yBAAyB;IAiCvC;;;;;;OAMG;YACW,WAAW;IA2FzB;;;;;OAKG;IACH,OAAO,CAAC,4BAA4B;IAQpC;;;;;;;;;;;OAWG;YACW,iBAAiB;IAgB/B;;;;;;;;;;;;;OAaG;IACH,OAAO,CAAC,sBAAsB;IAmD9B;;;;;;;;;;OAUG;IACH,OAAO,CAAC,wBAAwB;IA+ChC;;;;;;;;;OASG;YACW,eAAe;IAiB7B;;;;;;OAMG;YACW,gBAAgB;IAiC9B;;;;;;OAMG;YACW,YAAY;IAsB1B;;;;;OAKG;YACW,aAAa;IAqD3B;;;;;;;OAOG;YACW,gBAAgB;IAuB9B;;;;;OAKG;YACW,gBAAgB;IAyB9B;;;OAGG;IACH,OAAO,CAAC,oBAAoB;IAa5B;;;;OAIG;IACH,OAAO,CAAC,qBAAqB;IAU7B;;;;;;OAMG;IACH,OAAO,CAAC,wBAAwB;IAgChC;;;;OAIG;IACH,OAAO,CAAC,gBAAgB;IAYxB;;;OAGG;IACH,OAAO,CAAC,qBAAqB;IAc7B;;;OAGG;IACH,OAAO,CAAC,iBAAiB;IAOzB;;;OAGG;IACH,OAAO,CAAC,qBAAqB;IAO7B;;;;OAIG;IACH,OAAO,CAAC,qBAAqB;IAQ7B;;;OAGG;IACH,OAAO,CAAC,sCAAsC;IAyB9C;;;OAGG;IACH,OAAO,CAAC,sBAAsB;IAe9B;;;;OAIG;IACH,OAAO,CAAC,gBAAgB;IAgCxB;;;OAGG;YACW,iBAAiB;IAqB/B;;OAEG;YACW,oBAAoB;IAYlC;;OAEG;YACW,qBAAqB;IAkBnC;;OAEG;IACH,OAAO,CAAC,8BAA8B;IAUtC;;;;OAIG;IACH,OAAO,CAAC,kBAAkB;CAG3B"}
+{"version":3,"file":"i3s-converter.d.ts","sourceRoot":"","sources":["../../src/i3s-converter/i3s-converter.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,0BAA0B,CAAC;AAC7D,OAAO,KAAK,EAEV,YAAY,EAYb,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EAAC,SAAS,EAAC,MAAM,mBAAmB,CAAC;AAE5C,OAAO,EAAC,KAAK,EAAC,MAAM,gBAAgB,CAAC;AAOrC,OAAO,SAAS,MAAM,sBAAsB,CAAC;AAuB7C,OAAO,EAAC,gBAAgB,EAAC,MAAM,0BAA0B,CAAC;AAC1D,OAAO,EAAC,qBAAqB,EAA8B,MAAM,2BAA2B,CAAC;AAM7F,OAAO,UAAU,MAAM,0BAA0B,CAAC;AAkBlD;;GAEG;AACH,MAAM,CAAC,OAAO,OAAO,YAAY;IAC/B,SAAS,EAAE,SAAS,CAAC;IACrB,OAAO,EAAE,GAAG,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,GAAG,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC;IAC3B,mBAAmB,EAAE,qBAAqB,EAAE,CAAC;IAC7C,aAAa,EAAE,MAAM,CAAC;IACtB,OAAO,EAAE,YAAY,GAAG,IAAI,CAAC;IAC7B,iBAAiB,EAAE,MAAM,EAAE,CAAC;IAC5B,iBAAiB,EAAE;QACjB,UAAU,EAAE,MAAM,CAAC;QACnB,uBAAuB,EAAE,MAAM,CAAC;KACjC,CAAC;IACF,QAAQ,EAAE,OAAO,CAAC;IAClB,sBAAsB,CAAC,EAAE,MAAM,EAAE,CAAM;IACvC,mBAAmB,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAU;IAC/C,gBAAgB,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAU;IAC5C,aAAa,EAAE,SAAS,GAAG,IAAI,CAAQ;IACvC,gBAAgB,EAAE,KAAK,GAAG,IAAI,CAAQ;IACtC,MAAM,EAAE,gBAAgB,CAAiB;IACzC,gBAAgB,EAAE,OAAO,CAAC;IAC1B,uBAAuB,EAAE,OAAO,CAAC;IACjC,gBAAgB,EAAE,OAAO,CAAC;IAC1B,YAAY,EAAE;QAAC,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;KAAC,CAAM;IAC3C,UAAU,EAAE,UAAU,CAAC,cAAc,CAAC,CAAoB;;IAqB1D;;;;;;;;;;;;;OAaG;IACG,OAAO,CAAC,OAAO,EAAE;QACrB,QAAQ,EAAE,MAAM,CAAC;QACjB,UAAU,EAAE,MAAM,CAAC;QACnB,WAAW,EAAE,MAAM,CAAC;QACpB,WAAW,EAAE,MAAM,CAAC;QACpB,WAAW,EAAE,MAAM,CAAC;QACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,IAAI,CAAC,EAAE,OAAO,CAAC;QACf,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,KAAK,CAAC,EAAE,OAAO,CAAC;QAChB,QAAQ,CAAC,EAAE,OAAO,CAAC;QACnB,gBAAgB,CAAC,EAAE,OAAO,CAAC;QAC3B,uBAAuB,CAAC,EAAE,OAAO,CAAC;KACnC,GAAG,OAAO,CAAC,GAAG,CAAC;IA8DhB;;;;OAIG;YACW,qBAAqB;IA+CnC;;;OAGG;IACH,OAAO,CAAC,YAAY;IAuBpB;;;;OAIG;IACH,OAAO,CAAC,0BAA0B;IAqBlC;;;;;;OAMG;YACW,iBAAiB;IAwC/B;;OAEG;YACW,aAAa;IAiB3B;;OAEG;YACW,uBAAuB;IAerC;;;OAGG;YACW,WAAW;IAsCzB;;;;;;;OAOG;YACW,qCAAqC;IAWnD;;;;;;;;OAQG;YACW,YAAY;IAyC1B;;;;OAIG;YACW,yBAAyB;IAiCvC;;;;;;OAMG;YACW,WAAW;IA2FzB;;;;;OAKG;IACH,OAAO,CAAC,4BAA4B;IAQpC;;;;;;;;;;;OAWG;YACW,iBAAiB;IAiB/B;;;;;;;;;;;;;OAaG;IACH,OAAO,CAAC,sBAAsB;IAmD9B;;;;;;;;;;OAUG;IACH,OAAO,CAAC,wBAAwB;IA+ChC;;;;;;;;;OASG;YACW,eAAe;IAiB7B;;;;;;OAMG;YACW,gBAAgB;IAmC9B;;;;;;OAMG;YACW,YAAY;IAwB1B;;;;;OAKG;YACW,aAAa;IAuD3B;;;;;;;OAOG;YACW,gBAAgB;IAuB9B;;;;;OAKG;YACW,gBAAgB;IA0B9B;;;OAGG;IACH,OAAO,CAAC,oBAAoB;IAa5B;;;;OAIG;IACH,OAAO,CAAC,qBAAqB;IAU7B;;;;;;OAMG;IACH,OAAO,CAAC,wBAAwB;IAgChC;;;;OAIG;IACH,OAAO,CAAC,gBAAgB;IAYxB;;;OAGG;IACH,OAAO,CAAC,qBAAqB;IAc7B;;;OAGG;IACH,OAAO,CAAC,iBAAiB;IAOzB;;;OAGG;IACH,OAAO,CAAC,qBAAqB;IAO7B;;;;OAIG;IACH,OAAO,CAAC,qBAAqB;IAQ7B;;;OAGG;IACH,OAAO,CAAC,sCAAsC;IAyB9C;;;OAGG;IACH,OAAO,CAAC,sBAAsB;IAe9B;;;;OAIG;IACH,OAAO,CAAC,gBAAgB;IAgCxB;;;OAGG;YACW,iBAAiB;IAqB/B;;OAEG;YACW,oBAAoB;IAYlC;;OAEG;YACW,qBAAqB;IAkBnC;;OAEG;IACH,OAAO,CAAC,8BAA8B;IAUtC;;;;OAIG;IACH,OAAO,CAAC,kBAAkB;YAIZ,WAAW;CAsB1B"}

package/dist/i3s-converter/i3s-converter.js

@@ -26,7 +26,12 @@ const shared_resources_1 = require("./json-templates/shared-resources");
 const node_debug_1 = require("./helpers/node-debug");
 const textures_1 = require("@loaders.gl/textures");
 const images_1 = require("@loaders.gl/images");
-const ION_DEFAULT_TOKEN = process_1.default.env.IonToken || // eslint-disable-line
+const worker_utils_1 = require("@loaders.gl/worker-utils");
+const draco_1 = require("@loaders.gl/draco");
+const write_queue_1 = __importDefault(require("../lib/utils/write-queue"));
+const i3s_attributes_worker_1 = require("../i3s-attributes-worker");
+const constants_1 = require("../constants");
+const ION_DEFAULT_TOKEN = process_1.default.env?.IonToken || // eslint-disable-line
     'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJqdGkiOiJlYWMxMzcyYy0zZjJkLTQwODctODNlNi01MDRkZmMzMjIxOWIiLCJpZCI6OTYyMCwic2NvcGVzIjpbImFzbCIsImFzciIsImdjIl0sImlhdCI6MTU2Mjg2NjI3M30.1FNiClUyk00YH_nWfSGpiQAjR5V2OvREDq1PJ5QMjWQ'; // eslint-disable-line
 const HARDCODED_NODES_PER_PAGE = 64;
 const _3D_TILES = '3DTILES';
@@ -49,8 +54,9 @@ class I3SConverter {
         this.sourceTileset = null;
         this.geoidHeightModel = null;
         this.Loader = _3d_tiles_1.Tiles3DLoader;
+        this.workerSource = {};
+        this.writeQueue = new write_queue_1.default();
         this.nodePages = new node_pages_1.default(file_utils_1.writeFile, HARDCODED_NODES_PER_PAGE);
-        this.fileMap = {};
         this.options = {};
         this.layers0Path = '';
         this.materialMap = new Map();
@@ -82,6 +88,10 @@ class I3SConverter {
      * @param options.validate -enable validation
      */
     async convert(options) {
+        if (core_1.isBrowser) {
+            console.log(constants_1.BROWSER_ERROR_MESSAGE);
+            return constants_1.BROWSER_ERROR_MESSAGE;
+        }
         this.conversionStartTime = process_1.default.hrtime();
         const { tilesetName, slpk, egmFilePath, inputUrl, validate, outputPath, draco, sevenZipExe, maxDepth, token, generateTextures, generateBoundingVolumes } = options;
         this.options = { maxDepth, slpk, sevenZipExe, egmFilePath, draco, token, inputUrl };
@@ -89,24 +99,37 @@ class I3SConverter {
         this.Loader = inputUrl.indexOf(CESIUM_DATASET_PREFIX) !== -1 ? _3d_tiles_1.CesiumIonLoader : _3d_tiles_1.Tiles3DLoader;
         this.generateTextures = Boolean(generateTextures);
         this.generateBoundingVolumes = Boolean(generateBoundingVolumes);
+        this.writeQueue = new write_queue_1.default();
+        this.writeQueue.startListening();
         console.log('Loading egm file...'); // eslint-disable-line
         this.geoidHeightModel = await (0, core_1.load)(egmFilePath, pgm_loader_1.PGMLoader);
         console.log('Loading egm file completed!'); // eslint-disable-line
         if (slpk) {
             this.nodePages.useWriteFunction(file_utils_1.writeFileForSlpk);
         }
-        const preloadOptions = await this._fetchPreloadOptions();
-        const tilesetOptions = { loadOptions: { basis: { format: 'rgba32' } } };
-        if (preloadOptions.headers) {
-            tilesetOptions.loadOptions.fetch = { headers: preloadOptions.headers };
+        await this.loadWorkers();
+        try {
+            const preloadOptions = await this._fetchPreloadOptions();
+            const tilesetOptions = { loadOptions: { basis: { format: 'rgba32' } } };
+            if (preloadOptions.headers) {
+                tilesetOptions.loadOptions.fetch = { headers: preloadOptions.headers };
+            }
+            Object.assign(tilesetOptions, preloadOptions);
+            const sourceTilesetJson = await (0, core_1.load)(inputUrl, this.Loader, tilesetOptions.loadOptions);
+            // console.log(tilesetJson); // eslint-disable-line
+            this.sourceTileset = new tiles_1.Tileset3D(sourceTilesetJson, tilesetOptions);
+            await this._createAndSaveTileset(outputPath, tilesetName);
+            await this._finishConversion({ slpk: Boolean(slpk), outputPath, tilesetName });
+            return sourceTilesetJson;
+        }
+        catch (error) {
+            throw error;
+        }
+        finally {
+            // Clean up worker pools
+            const workerFarm = worker_utils_1.WorkerFarm.getWorkerFarm({});
+            workerFarm.destroy();
         }
-        Object.assign(tilesetOptions, preloadOptions);
-        const sourceTilesetJson = await (0, core_1.load)(inputUrl, this.Loader, tilesetOptions.loadOptions);
-        // console.log(tilesetJson); // eslint-disable-line
-        this.sourceTileset = new tiles_1.Tileset3D(sourceTilesetJson, tilesetOptions);
-        await this._createAndSaveTileset(outputPath, tilesetName);
-        await this._finishConversion({ slpk: Boolean(slpk), outputPath, tilesetName });
-        return sourceTilesetJson;
     }
     /**
      * Convert and save the layer and embedded tiles
@@ -145,7 +168,8 @@ class I3SConverter {
         await this._writeLayers0();
         (0, create_scene_server_path_1.createSceneServerPath)(tilesetName, this.layers0, tilesetPath);
         await this._writeNodeIndexDocument(root0, 'root', (0, path_1.join)(this.layers0Path, 'nodes', 'root'));
-        await this.nodePages.save(this.layers0Path, this.fileMap, isCreateSlpk);
+        await this.nodePages.save(this.layers0Path, this.writeQueue, isCreateSlpk);
+        await this.writeQueue.finalize();
         await this._createSlpk(tilesetPath);
     }
     /**
@@ -153,7 +177,8 @@ class I3SConverter {
      * @param  tilesetName - Name of layer
      */
     _formLayers0(tilesetName) {
-        const extent = (0, coordinate_converter_1.convertCommonToI3SExtentCoordinate)(this.sourceTileset);
+        const fullExtent = (0, coordinate_converter_1.convertBoundingVolumeToI3SFullExtent)(this.sourceTileset?.boundingVolume || this.sourceTileset?.root?.boundingVolume);
+        const extent = [fullExtent.xmin, fullExtent.ymin, fullExtent.xmax, fullExtent.ymax];
         const layers0data = {
             version: `{${(0, uuid_1.v4)().toUpperCase()}}`,
             id: 0,
@@ -166,7 +191,8 @@ class I3SConverter {
             nodePages: {
                 nodesPerPage: HARDCODED_NODES_PER_PAGE
             },
-            compressGeometry: this.options.draco
+            compressGeometry: this.options.draco,
+            fullExtent
         };
         this.layers0 = (0, json_map_transform_1.default)(layers0data, (0, layers_1.LAYERS)());
     }
@@ -214,10 +240,13 @@ class I3SConverter {
             const [child] = await this._createNode(root0, sourceRootTile, parentId, 0);
             const childPath = (0, path_1.join)(this.layers0Path, 'nodes', child.path);
             if (this.options.slpk) {
-                this.fileMap['nodes/1/3dNodeIndexDocument.json.gz'] = await (0, file_utils_1.writeFileForSlpk)(childPath, JSON.stringify(child), '3dNodeIndexDocument.json');
+                this.writeQueue.enqueue({
+                    archiveKey: 'nodes/1/3dNodeIndexDocument.json.gz',
+                    writePromise: (0, file_utils_1.writeFileForSlpk)(childPath, JSON.stringify(child), '3dNodeIndexDocument.json')
+                });
             }
             else {
-                await (0, file_utils_1.writeFile)(childPath, JSON.stringify(child));
+                this.writeQueue.enqueue({ writePromise: (0, file_utils_1.writeFile)(childPath, JSON.stringify(child)) });
             }
         }
         else {
@@ -235,10 +264,15 @@ class I3SConverter {
      */
     async _writeLayers0() {
         if (this.options.slpk) {
-            this.fileMap['3dSceneLayer.json.gz'] = await (0, file_utils_1.writeFileForSlpk)(this.layers0Path, JSON.stringify(this.layers0), '3dSceneLayer.json');
+            this.writeQueue.enqueue({
+                archiveKey: '3dSceneLayer.json.gz',
+                writePromise: (0, file_utils_1.writeFileForSlpk)(this.layers0Path, JSON.stringify(this.layers0), '3dSceneLayer.json')
+            });
         }
         else {
-            await (0, file_utils_1.writeFile)(this.layers0Path, JSON.stringify(this.layers0));
+            this.writeQueue.enqueue({
+                writePromise: (0, file_utils_1.writeFile)(this.layers0Path, JSON.stringify(this.layers0))
+            });
         }
     }
     /**
@@ -246,10 +280,13 @@ class I3SConverter {
      */
     async _writeNodeIndexDocument(root0, nodePath, rootPath) {
         if (this.options.slpk) {
-            this.fileMap[`nodes/${nodePath}/3dNodeIndexDocument.json.gz`] = await (0, file_utils_1.writeFileForSlpk)(rootPath, JSON.stringify(root0), '3dNodeIndexDocument.json');
+            this.writeQueue.enqueue({
+                archiveKey: `nodes/${nodePath}/3dNodeIndexDocument.json.gz`,
+                writePromise: (0, file_utils_1.writeFileForSlpk)(rootPath, JSON.stringify(root0), '3dNodeIndexDocument.json')
+            });
         }
         else {
-            await (0, file_utils_1.writeFile)(rootPath, JSON.stringify(root0));
+            this.writeQueue.enqueue({ writePromise: (0, file_utils_1.writeFile)(rootPath, JSON.stringify(root0)) });
         }
     }
     /**
@@ -260,9 +297,7 @@ class I3SConverter {
         if (this.options.slpk) {
             const slpkTilesetPath = (0, path_1.join)(tilesetPath, 'SceneServer', 'layers', '0');
             const slpkFileName = `${tilesetPath}.slpk`;
-            await (0, compress_util_1.compressWithChildProcess)(slpkTilesetPath, slpkFileName, 0, '.', 
-            // @ts-expect-error
-            this.options.sevenZipExe);
+            await (0, compress_util_1.compressWithChildProcess)(slpkTilesetPath, slpkFileName, 0, '.', this.options.sevenZipExe);
             // TODO: `addFileToZip` corrupts archive so it can't be validated with windows i3s_converter.exe
             // const fileHash128Path = `${tilesetPath}/@specialIndexFileHASH128@`;
             // try {
@@ -468,7 +503,7 @@ class I3SConverter {
         if (!this.isContentSupported(sourceTile)) {
             return null;
         }
-        const resourcesData = await (0, geometry_converter_1.default)(sourceTile.content, Number(this.nodePages.nodesCounter), this.featuresHashArray, this.layers0?.attributeStorageInfo, this.options.draco, this.generateBoundingVolumes, this.geoidHeightModel);
+        const resourcesData = await (0, geometry_converter_1.default)(sourceTile.content, Number(this.nodePages.nodesCounter), this.featuresHashArray, this.layers0?.attributeStorageInfo, this.options.draco, this.generateBoundingVolumes, this.geoidHeightModel, this.workerSource);
         return resourcesData;
     }
     /**
@@ -601,20 +636,30 @@ class I3SConverter {
     async _writeGeometries(geometryBuffer, compressedGeometry, childPath, slpkChildPath) {
         if (this.options.slpk) {
             const slpkGeometryPath = (0, path_1.join)(childPath, 'geometries');
-            this.fileMap[`${slpkChildPath}/geometries/0.bin.gz`] = await (0, file_utils_1.writeFileForSlpk)(slpkGeometryPath, geometryBuffer, '0.bin');
+            this.writeQueue.enqueue({
+                archiveKey: `${slpkChildPath}/geometries/0.bin.gz`,
+                writePromise: (0, file_utils_1.writeFileForSlpk)(slpkGeometryPath, geometryBuffer, '0.bin')
+            });
         }
         else {
             const geometryPath = (0, path_1.join)(childPath, 'geometries/0/');
-            await (0, file_utils_1.writeFile)(geometryPath, geometryBuffer, 'index.bin');
+            this.writeQueue.enqueue({
+                writePromise: (0, file_utils_1.writeFile)(geometryPath, geometryBuffer, 'index.bin')
+            });
         }
         if (this.options.draco) {
             if (this.options.slpk) {
                 const slpkCompressedGeometryPath = (0, path_1.join)(childPath, 'geometries');
-                this.fileMap[`${slpkChildPath}/geometries/1.bin.gz`] = await (0, file_utils_1.writeFileForSlpk)(slpkCompressedGeometryPath, compressedGeometry, '1.bin');
+                this.writeQueue.enqueue({
+                    archiveKey: `${slpkChildPath}/geometries/1.bin.gz`,
+                    writePromise: (0, file_utils_1.writeFileForSlpk)(slpkCompressedGeometryPath, compressedGeometry, '1.bin')
+                });
             }
             else {
                 const compressedGeometryPath = (0, path_1.join)(childPath, 'geometries/1/');
-                await (0, file_utils_1.writeFile)(compressedGeometryPath, compressedGeometry, 'index.bin');
+                this.writeQueue.enqueue({
+                    writePromise: (0, file_utils_1.writeFile)(compressedGeometryPath, compressedGeometry, 'index.bin')
+                });
             }
         }
     }
@@ -626,16 +671,22 @@ class I3SConverter {
      * @param nodePath - a node path
      */
     async _writeShared(sharedResources, childPath, slpkChildPath, nodePath) {
+        if (!sharedResources) {
+            return;
+        }
         sharedResources.nodePath = nodePath;
         const sharedData = (0, json_map_transform_1.default)(sharedResources, (0, shared_resources_1.SHARED_RESOURCES)());
         const sharedDataStr = JSON.stringify(sharedData);
         if (this.options.slpk) {
             const slpkSharedPath = (0, path_1.join)(childPath, 'shared');
-            this.fileMap[`${slpkChildPath}/shared/sharedResource.json.gz`] = await (0, file_utils_1.writeFileForSlpk)(slpkSharedPath, sharedDataStr, 'sharedResource.json');
+            this.writeQueue.enqueue({
+                archiveKey: `${slpkChildPath}/shared/sharedResource.json.gz`,
+                writePromise: (0, file_utils_1.writeFileForSlpk)(slpkSharedPath, sharedDataStr, 'sharedResource.json')
+            });
         }
         else {
             const sharedPath = (0, path_1.join)(childPath, 'shared/');
-            await (0, file_utils_1.writeFile)(sharedPath, sharedDataStr);
+            this.writeQueue.enqueue({ writePromise: (0, file_utils_1.writeFile)(sharedPath, sharedDataStr) });
         }
     }
     /**
@@ -656,7 +707,12 @@ class I3SConverter {
                     await this.writeTextureFile(textureData, '0', format, childPath, slpkChildPath);
                     if (this.generateTextures) {
                         formats.push({ name: '1', format: 'ktx2' });
-                        const ktx2TextureData = new Uint8Array(await (0, core_1.encode)(texture.image, textures_1.KTX2BasisUniversalTextureWriter));
+                        const ktx2TextureData = (0, core_1.encode)(texture.image, textures_1.KTX2BasisWriterWorker, {
+                            ...textures_1.KTX2BasisWriterWorker.options,
+                            source: this.workerSource.ktx2,
+                            reuseWorkers: true,
+                            _nodeWorkers: true
+                        });
                         await this.writeTextureFile(ktx2TextureData, '1', 'ktx2', childPath, slpkChildPath);
                     }
                     break;
@@ -666,7 +722,7 @@ class I3SConverter {
                     await this.writeTextureFile(textureData, '1', format, childPath, slpkChildPath);
                     if (this.generateTextures) {
                         formats.push({ name: '0', format: 'jpg' });
-                        const decodedFromKTX2TextureData = new Uint8Array(await (0, core_1.encode)(texture.image.data[0], images_1.ImageWriter));
+                        const decodedFromKTX2TextureData = (0, core_1.encode)(texture.image.data[0], images_1.ImageWriter);
                         await this.writeTextureFile(decodedFromKTX2TextureData, '0', 'jpg', childPath, slpkChildPath);
                     }
                 }
@@ -688,11 +744,16 @@ class I3SConverter {
         if (this.options.slpk) {
             const slpkTexturePath = (0, path_1.join)(childPath, 'textures');
             const compress = false;
-            this.fileMap[`${slpkChildPath}/textures/${name}.${format}`] = await (0, file_utils_1.writeFileForSlpk)(slpkTexturePath, textureData, `${name}.${format}`, compress);
+            this.writeQueue.enqueue({
+                archiveKey: `${slpkChildPath}/textures/${name}.${format}`,
+                writePromise: (0, file_utils_1.writeFileForSlpk)(slpkTexturePath, textureData, `${name}.${format}`, compress)
+            });
         }
         else {
             const texturePath = (0, path_1.join)(childPath, `textures/${name}/`);
-            await (0, file_utils_1.writeFile)(texturePath, textureData, `index.${format}`);
+            this.writeQueue.enqueue({
+                writePromise: (0, file_utils_1.writeFile)(texturePath, textureData, `index.${format}`)
+            });
         }
     }
     /**
@@ -701,18 +762,23 @@ class I3SConverter {
      * @param childPath - a child path to write resources
      * @param slpkChildPath - the resource path inside *slpk file
      */
-    async _writeAttributes(attributes, childPath, slpkChildPath) {
-        if (attributes.length && this.layers0?.attributeStorageInfo?.length) {
+    async _writeAttributes(attributes = [], childPath, slpkChildPath) {
+        if (attributes?.length && this.layers0?.attributeStorageInfo?.length) {
             for (let index = 0; index < attributes.length; index++) {
                 const folderName = this.layers0.attributeStorageInfo[index].key;
                 const fileBuffer = new Uint8Array(attributes[index]);
                 if (this.options.slpk) {
                     const slpkAttributesPath = (0, path_1.join)(childPath, 'attributes', folderName);
-                    this.fileMap[`${slpkChildPath}/attributes/${folderName}.bin.gz`] = await (0, file_utils_1.writeFileForSlpk)(slpkAttributesPath, fileBuffer, '0.bin');
+                    this.writeQueue.enqueue({
+                        archiveKey: `${slpkChildPath}/attributes/${folderName}.bin.gz`,
+                        writePromise: (0, file_utils_1.writeFileForSlpk)(slpkAttributesPath, fileBuffer, '0.bin')
+                    });
                 }
                 else {
                     const attributesPath = (0, path_1.join)(childPath, `attributes/${folderName}/0`);
-                    await (0, file_utils_1.writeFile)(attributesPath, fileBuffer, 'index.bin');
+                    this.writeQueue.enqueue({
+                        writePromise: (0, file_utils_1.writeFile)(attributesPath, fileBuffer, 'index.bin')
+                    });
                 }
             }
         }
@@ -990,5 +1056,25 @@ class I3SConverter {
     isContentSupported(sourceRootTile) {
         return ['b3dm', 'glTF'].includes(sourceRootTile?.content?.type);
     }
+    async loadWorkers() {
+        console.log(`Loading workers source...`); // eslint-disable-line no-undef, no-console
+        if (this.options.draco) {
+            const url = (0, worker_utils_1.getWorkerURL)(draco_1.DracoWriterWorker, { ...(0, core_1.getLoaderOptions)() });
+            const sourceResponse = await (0, core_1.fetchFile)(url);
+            const source = await sourceResponse.text();
+            this.workerSource.draco = source;
+        }
+        if (this.generateTextures) {
+            const url = (0, worker_utils_1.getWorkerURL)(textures_1.KTX2BasisWriterWorker, { ...(0, core_1.getLoaderOptions)() });
+            const sourceResponse = await (0, core_1.fetchFile)(url);
+            const source = await sourceResponse.text();
+            this.workerSource.ktx2 = source;
+        }
+        const i3sAttributesWorkerUrl = (0, worker_utils_1.getWorkerURL)(i3s_attributes_worker_1.I3SAttributesWorker, { ...(0, core_1.getLoaderOptions)() });
+        const sourceResponse = await (0, core_1.fetchFile)(i3sAttributesWorkerUrl);
+        const source = await sourceResponse.text();
+        this.workerSource.I3SAttributes = source;
+        console.log(`Loading workers source completed!`); // eslint-disable-line no-undef, no-console
+    }
 }
 exports.default = I3SConverter;

package/dist/i3s-converter/json-templates/layers.d.ts

@@ -30,6 +30,10 @@ export declare const LAYERS: () => {
         path: string;
         transform: (val: any) => any;
     };
+    fullExtent: {
+        path: string;
+        transform: (val: any) => any;
+    };
     heightModelInfo: {
         path: string;
         transform: (val: any) => any;

package/dist/i3s-converter/json-templates/layers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"layers.d.ts","sourceRoot":"","sources":["../../../src/i3s-converter/json-templates/layers.ts"],"names":[],"mappings":"AAqHA,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmFjB,CAAC"}
+{"version":3,"file":"layers.d.ts","sourceRoot":"","sources":["../../../src/i3s-converter/json-templates/layers.ts"],"names":[],"mappings":"AA0IA,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuFjB,CAAC"}

package/dist/i3s-converter/json-templates/layers.js

@@ -113,6 +113,26 @@ const NODE_PAGES = () => ({
         default: 'maxScreenThresholdSQ'
     }
 });
+const FULL_EXTENT = () => ({
+    xmin: {
+        path: 'xmin'
+    },
+    ymin: {
+        path: 'ymin'
+    },
+    xmax: {
+        path: 'xmax'
+    },
+    ymax: {
+        path: 'ymax'
+    },
+    zmin: {
+        path: 'zmin'
+    },
+    zmax: {
+        path: 'zmax'
+    }
+});
 const LAYERS = () => ({
     version: {
         path: 'version',
@@ -145,6 +165,10 @@ const LAYERS = () => ({
         path: 'store',
         transform: (val) => (0, json_map_transform_1.default)(val, store_1.STORE)
     },
+    fullExtent: {
+        path: 'fullExtent',
+        transform: (val) => (0, json_map_transform_1.default)(val, FULL_EXTENT())
+    },
     heightModelInfo: {
         path: 'heightModelInfo',
         transform: (val) => (0, json_map_transform_1.default)(val, HEIGHT_MODEL_INFO())