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

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

@@ -0,0 +1,95 @@
+export declare const LAYERS: () => {
+    version: {
+        path: string;
+        transform: (val: any) => any;
+    };
+    id: {
+        path: string;
+        default: number;
+    };
+    name: {
+        path: string;
+    };
+    href: {
+        path: string;
+        default: string;
+    };
+    layerType: {
+        path: string;
+        default: string;
+    };
+    spatialReference: {
+        path: string;
+        transform: (val: any) => any;
+    };
+    capabilities: {
+        path: string;
+        default: string[];
+    };
+    store: {
+        path: string;
+        transform: (val: any) => any;
+    };
+    heightModelInfo: {
+        path: string;
+        transform: (val: any) => any;
+    };
+    nodePages: {
+        path: string;
+        transform: (val: any) => any;
+    };
+    materialDefinitions: {
+        path: string;
+        default: never[];
+    };
+    textureSetDefinitions: {
+        path: string;
+        default: never[];
+    };
+    geometryDefinitions: {
+        path: string;
+        transform: (val: any) => {
+            geometryBuffers: never[];
+        }[];
+        default: {
+            geometryBuffers: {
+                offset: number;
+                position: {
+                    type: string;
+                    component: number;
+                };
+                normal: {
+                    type: string;
+                    component: number;
+                };
+                color: {
+                    type: string;
+                    component: number;
+                };
+                featureId: {
+                    binding: string;
+                    type: string;
+                    component: number;
+                };
+                faceRange: {
+                    binding: string;
+                    type: string;
+                    component: number;
+                };
+            }[];
+        }[];
+    };
+    attributeStorageInfo: {
+        path: string;
+        default: never[];
+    };
+    fields: {
+        path: string;
+        default: never[];
+    };
+    popupInfo: {
+        path: string;
+        default: null;
+    };
+};
+//# sourceMappingURL=layers.d.ts.map

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

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

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

@@ -0,0 +1,199 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LAYERS = void 0;
+const json_map_transform_1 = __importDefault(require("json-map-transform"));
+const store_1 = require("./store");
+const PLAIN_GEOMETRY_DEFINITION = () => ({
+    offset: 8,
+    position: {
+        type: 'Float32',
+        component: 3
+    },
+    normal: {
+        type: 'Float32',
+        component: 3
+    },
+    uv0: {
+        type: 'Float32',
+        component: 2
+    },
+    color: {
+        type: 'UInt8',
+        component: 4
+    },
+    featureId: {
+        binding: 'per-feature',
+        type: 'UInt64',
+        component: 1
+    },
+    faceRange: {
+        binding: 'per-feature',
+        type: 'UInt32',
+        component: 2
+    }
+});
+const PLAIN_GEOMETRY_DEFINITION_WITHOUT_UV0 = () => ({
+    offset: 8,
+    position: {
+        type: 'Float32',
+        component: 3
+    },
+    normal: {
+        type: 'Float32',
+        component: 3
+    },
+    color: {
+        type: 'UInt8',
+        component: 4
+    },
+    featureId: {
+        binding: 'per-feature',
+        type: 'UInt64',
+        component: 1
+    },
+    faceRange: {
+        binding: 'per-feature',
+        type: 'UInt32',
+        component: 2
+    }
+});
+const COMPRESSED_GEOMETRY_DEFINITION = () => ({
+    compressedAttributes: {
+        encoding: 'draco',
+        attributes: ['position', 'normal', 'uv0', 'color', 'feature-index']
+    }
+});
+const COMPRESSED_GEOMETRY_DEFINITION_WITHOUT_UV0 = () => ({
+    compressedAttributes: {
+        encoding: 'draco',
+        attributes: ['position', 'normal', 'color', 'feature-index']
+    }
+});
+const SPATIAL_REFERENCE = () => ({
+    wkid: {
+        path: 'wkid',
+        default: 4326
+    },
+    latestWkid: {
+        path: 'latestWkid',
+        default: 4326
+    },
+    vcsWkid: {
+        path: 'vcsWkid',
+        default: 5773
+    },
+    latestVcsWkid: {
+        path: 'latestVcsWkid',
+        default: 5773
+    }
+});
+const HEIGHT_MODEL_INFO = () => ({
+    heightModel: {
+        path: 'heightModel',
+        default: 'gravity_related_height'
+    },
+    vertCRS: {
+        path: 'vertCRS',
+        default: 'EGM96_Geoid'
+    },
+    heightUnit: {
+        path: 'heightUnit',
+        default: 'meter'
+    }
+});
+const NODE_PAGES = () => ({
+    nodesPerPage: {
+        path: 'nodesPerPage'
+    },
+    lodSelectionMetricType: {
+        path: 'lodSelectionMetricType',
+        default: 'maxScreenThresholdSQ'
+    }
+});
+const LAYERS = () => ({
+    version: {
+        path: 'version',
+        transform: (val) => val.toUpperCase()
+    },
+    id: {
+        path: 'id',
+        default: 0
+    },
+    name: {
+        path: 'name'
+    },
+    href: {
+        path: 'href',
+        default: './layers/0'
+    },
+    layerType: {
+        path: 'layerType',
+        default: 'IntegratedMesh'
+    },
+    spatialReference: {
+        path: 'spatialReference',
+        transform: (val) => (0, json_map_transform_1.default)(val, SPATIAL_REFERENCE())
+    },
+    capabilities: {
+        path: 'capabilities',
+        default: ['View', 'Query']
+    },
+    store: {
+        path: 'store',
+        transform: (val) => (0, json_map_transform_1.default)(val, store_1.STORE)
+    },
+    heightModelInfo: {
+        path: 'heightModelInfo',
+        transform: (val) => (0, json_map_transform_1.default)(val, HEIGHT_MODEL_INFO())
+    },
+    nodePages: {
+        path: 'nodePages',
+        transform: (val) => (0, json_map_transform_1.default)(val, NODE_PAGES())
+    },
+    materialDefinitions: {
+        path: 'materialDefinitions',
+        default: []
+    },
+    textureSetDefinitions: {
+        path: 'textureSetDefinitions',
+        default: []
+    },
+    geometryDefinitions: {
+        path: 'compressGeometry',
+        transform: (val) => {
+            const result = [{ geometryBuffers: [] }, { geometryBuffers: [] }];
+            // @ts-expect-error
+            result[0].geometryBuffers.push(PLAIN_GEOMETRY_DEFINITION());
+            // @ts-expect-error
+            result[1].geometryBuffers.push(PLAIN_GEOMETRY_DEFINITION_WITHOUT_UV0());
+            if (val) {
+                // @ts-expect-error
+                result[0].geometryBuffers.push(COMPRESSED_GEOMETRY_DEFINITION());
+                // @ts-expect-error
+                result[1].geometryBuffers.push(COMPRESSED_GEOMETRY_DEFINITION_WITHOUT_UV0());
+            }
+            return result;
+        },
+        default: [
+            {
+                geometryBuffers: [PLAIN_GEOMETRY_DEFINITION(), PLAIN_GEOMETRY_DEFINITION_WITHOUT_UV0()]
+            }
+        ]
+    },
+    attributeStorageInfo: {
+        path: 'attributeStorageInfo',
+        default: []
+    },
+    fields: {
+        path: 'fields',
+        default: []
+    },
+    popupInfo: {
+        path: 'popupInfo',
+        default: null
+    }
+});
+exports.LAYERS = LAYERS;

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

@@ -0,0 +1,22 @@
+export declare const METADATA: () => {
+    folderPattern: {
+        path: string;
+        default: string;
+    };
+    archiveCompressionType: {
+        path: string;
+        default: string;
+    };
+    resourceCompressionType: {
+        path: string;
+        default: string;
+    };
+    I3SVersion: {
+        path: string;
+        default: string;
+    };
+    nodeCount: {
+        path: string;
+    };
+};
+//# sourceMappingURL=metadata.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"metadata.d.ts","sourceRoot":"","sources":["../../../src/i3s-converter/json-templates/metadata.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;CAoBnB,CAAC"}

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

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.METADATA = void 0;
+const METADATA = () => ({
+    folderPattern: {
+        path: 'folderPattern',
+        default: 'BASIC'
+    },
+    archiveCompressionType: {
+        path: 'archiveCompressionType',
+        default: 'STORE'
+    },
+    resourceCompressionType: {
+        path: 'resourceCompressionType',
+        default: 'GZIP'
+    },
+    I3SVersion: {
+        path: 'I3SVersion',
+        default: '1.8'
+    },
+    nodeCount: {
+        path: 'nodeCount'
+    }
+});
+exports.METADATA = METADATA;

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

@@ -0,0 +1,61 @@
+export declare const NODE: () => {
+    lodSelection: {
+        path: string;
+        default: {
+            metricType: string;
+            maxError: number;
+        }[];
+    };
+    children: {
+        path: string;
+        default: null;
+    };
+    neighbors: {
+        path: string;
+        default: null;
+    };
+    parentNode: {
+        path: string;
+        transform: (val: any) => any;
+        default: null;
+    };
+    sharedResource: {
+        path: string;
+        default: null;
+    };
+    featureData: {
+        path: string;
+        default: null;
+    };
+    geometryData: {
+        path: string;
+        default: null;
+    };
+    textureData: {
+        path: string;
+        default: null;
+    };
+    attributeData: {
+        path: string;
+        default: null;
+    };
+    mbs: {
+        path: string;
+    };
+    obb: {
+        path: string;
+    };
+    version: {
+        path: string;
+    };
+    id: {
+        path: string;
+    };
+    path: {
+        path: string;
+    };
+    level: {
+        path: string;
+    };
+};
+//# sourceMappingURL=node.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../../../src/i3s-converter/json-templates/node.ts"],"names":[],"mappings":"AAyBA,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4Df,CAAC"}

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

@@ -0,0 +1,89 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NODE = void 0;
+const json_map_transform_1 = __importDefault(require("json-map-transform"));
+const COORDINATES = () => ({
+    mbs: {
+        path: 'mbs'
+    },
+    obb: {
+        path: 'obb'
+    }
+});
+const HREF = () => ({
+    href: {
+        path: 'href'
+    }
+});
+const PARENT_NODE = () => ({
+    id: {
+        path: 'id'
+    },
+    ...HREF(),
+    ...COORDINATES()
+});
+const NODE = () => ({
+    version: {
+        path: 'version'
+    },
+    id: {
+        path: 'id'
+    },
+    path: {
+        path: 'path'
+    },
+    level: {
+        path: 'level'
+    },
+    ...COORDINATES(),
+    lodSelection: {
+        path: 'lodSelection',
+        default: [
+            {
+                metricType: 'maxScreenThresholdSQ',
+                maxError: 196349.54374999998
+            },
+            {
+                metricType: 'maxScreenThreshold',
+                maxError: 999.99999999999994
+            }
+        ]
+    },
+    children: {
+        path: 'children',
+        default: null
+    },
+    neighbors: {
+        path: 'neighbors',
+        default: null
+    },
+    parentNode: {
+        path: 'parentNode',
+        transform: (val) => (0, json_map_transform_1.default)(val, PARENT_NODE()),
+        default: null
+    },
+    sharedResource: {
+        path: 'sharedResource',
+        default: null
+    },
+    featureData: {
+        path: 'featureData',
+        default: null
+    },
+    geometryData: {
+        path: 'geometryData',
+        default: null
+    },
+    textureData: {
+        path: 'textureData',
+        default: null
+    },
+    attributeData: {
+        path: 'attributeData',
+        default: null
+    }
+});
+exports.NODE = NODE;

package/dist/i3s-converter/json-templates/scene-server.d.ts

@@ -0,0 +1,28 @@
+export declare const SCENE_SERVER: () => {
+    serviceItemId: {
+        path: string;
+    };
+    serviceName: {
+        path: string;
+    };
+    name: {
+        path: string;
+    };
+    currentVersion: {
+        path: string;
+        default: number;
+    };
+    serviceVersion: {
+        path: string;
+        default: string;
+    };
+    supportedBindings: {
+        path: string;
+        default: string[];
+    };
+    layers: {
+        path: string;
+        transform: (layers0: any) => any[];
+    };
+};
+//# sourceMappingURL=scene-server.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"scene-server.d.ts","sourceRoot":"","sources":["../../../src/i3s-converter/json-templates/scene-server.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;CA0BvB,CAAC"}

package/dist/i3s-converter/json-templates/scene-server.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SCENE_SERVER = void 0;
+const SCENE_SERVER = () => ({
+    serviceItemId: {
+        path: 'serviceItemId'
+    },
+    serviceName: {
+        path: 'layerName'
+    },
+    name: {
+        path: 'layerName'
+    },
+    currentVersion: {
+        path: 'currentVersion',
+        default: 10.7
+    },
+    serviceVersion: {
+        path: 'serviceVersion',
+        default: '1.8'
+    },
+    supportedBindings: {
+        path: 'supportedBindings',
+        default: ['REST']
+    },
+    layers: {
+        path: 'layers0',
+        transform: (layers0) => [layers0]
+    }
+});
+exports.SCENE_SERVER = SCENE_SERVER;

package/dist/i3s-converter/json-templates/shared-resources.d.ts

@@ -0,0 +1,14 @@
+export declare const SHARED_RESOURCES: () => {
+    materialDefinitions: {
+        path: string;
+        transform: typeof transfromMaterialDefinitions;
+    };
+    textureDefinitions: {
+        path: string;
+        transform: typeof transfromTextureDefinitions;
+    };
+};
+declare function transfromMaterialDefinitions(materialDefinitionInfos: any, thisObject: any, originalObject: any): {};
+declare function transfromTextureDefinitions(textureDefinitionInfos: any, thisObject: any, originalObject: any): {} | null;
+export {};
+//# sourceMappingURL=shared-resources.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shared-resources.d.ts","sourceRoot":"","sources":["../../../src/i3s-converter/json-templates/shared-resources.ts"],"names":[],"mappings":"AAoGA,eAAO,MAAM,gBAAgB;;;;;;;;;CAS3B,CAAC;AAEH,iBAAS,4BAA4B,CAAC,uBAAuB,KAAA,EAAE,UAAU,KAAA,EAAE,cAAc,KAAA,MASxF;AAED,iBAAS,2BAA2B,CAAC,sBAAsB,KAAA,EAAE,UAAU,KAAA,EAAE,cAAc,KAAA,aAWtF"}