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

package/dist/i3s-converter/json-templates/geometry-definitions.d.ts

@@ -0,0 +1,7 @@
+export declare const GEOMETRY_DEFINITION: () => {
+    geometryBuffers: {
+        path: string;
+        transform: (val: any) => any[];
+    };
+};
+//# sourceMappingURL=geometry-definitions.d.ts.map

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

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

package/dist/i3s-converter/json-templates/geometry-definitions.js

@@ -0,0 +1,87 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GEOMETRY_DEFINITION = void 0;
+const json_map_transform_1 = __importDefault(require("json-map-transform"));
+const PLAIN_GEOMETRY_DEFINITION = () => ({
+    offset: {
+        default: 8
+    },
+    position: {
+        default: {
+            type: 'Float32',
+            component: 3
+        }
+    },
+    normal: {
+        default: {
+            type: 'Float32',
+            component: 3
+        }
+    },
+    uv0: {
+        path: 'hasTexture',
+        transform: (val) => (val && { type: 'Float32', component: 2 }) || false,
+        omitValues: [false]
+    },
+    color: {
+        default: {
+            type: 'UInt8',
+            component: 4
+        }
+    },
+    uvRegion: {
+        path: 'hasUvRegions',
+        transform: (val) => (val && { type: 'UInt16', component: 4 }) || false,
+        omitValues: [false]
+    },
+    featureId: {
+        default: {
+            binding: 'per-feature',
+            type: 'UInt64',
+            component: 1
+        }
+    },
+    faceRange: {
+        default: {
+            binding: 'per-feature',
+            type: 'UInt32',
+            component: 2
+        }
+    }
+});
+const COMPRESSED_GEOMETRY_DEFINITION = () => ({
+    'compressedAttributes.encoding': {
+        default: 'draco'
+    },
+    'compressedAttributes.attributes': {
+        path: 'geometryConfig',
+        transform: (val) => {
+            const result = ['position', 'normal'];
+            if (val.hasTexture) {
+                result.push('uv0');
+            }
+            result.push('color');
+            if (val.hasUvRegions) {
+                result.push('uv-region');
+            }
+            result.push('feature-index');
+            return result;
+        }
+    }
+});
+const GEOMETRY_DEFINITION = () => ({
+    geometryBuffers: {
+        path: 'geometryConfig',
+        transform: (val) => {
+            const result = [(0, json_map_transform_1.default)(val, PLAIN_GEOMETRY_DEFINITION())];
+            if (val.draco) {
+                result.push((0, json_map_transform_1.default)({ geometryConfig: val }, COMPRESSED_GEOMETRY_DEFINITION()));
+            }
+            return result;
+        }
+    }
+});
+exports.GEOMETRY_DEFINITION = GEOMETRY_DEFINITION;

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

@@ -0,0 +1,70 @@
+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;
+    };
+    fullExtent: {
+        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;
+        default: never[];
+    };
+    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":"AAoEA,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoEjB,CAAC"}

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

@@ -1,191 +1,139 @@
-import transform from 'json-map-transform';
-import { STORE } from './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
-  }
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-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'
-  }
-};
-export 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 => transform(val, SPATIAL_REFERENCE)
-  },
-  capabilities: {
-    path: 'capabilities',
-    default: ['View', 'Query']
-  },
-  store: {
-    path: 'store',
-    transform: val => transform(val, STORE)
-  },
-  heightModelInfo: {
-    path: 'heightModelInfo',
-    transform: val => transform(val, HEIGHT_MODEL_INFO)
-  },
-  nodePages: {
-    path: 'nodePages',
-    transform: val => transform(val, NODE_PAGES)
-  },
-  materialDefinitions: {
-    path: 'materialDefinitions',
-    default: []
-  },
-  textureSetDefinitions: {
-    path: 'textureSetDefinitions',
-    default: []
-  },
-  geometryDefinitions: {
-    path: 'compressGeometry',
-    transform: val => {
-      const result = [{}, {}];
-      result[0].geometryBuffers = [];
-      result[1].geometryBuffers = [];
-      result[0].geometryBuffers.push(PLAIN_GEOMETRY_DEFINITION);
-      result[1].geometryBuffers.push(PLAIN_GEOMETRY_DEFINITION_WITHOUT_UV0);
-
-      if (val) {
-        result[0].geometryBuffers.push(COMPRESSED_GEOMETRY_DEFINITION);
-        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
-  }
-};
-//# sourceMappingURL=layers.js.map
+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 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 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',
+        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)
+    },
+    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())
+    },
+    nodePages: {
+        path: 'nodePages',
+        transform: (val) => (0, json_map_transform_1.default)(val, NODE_PAGES())
+    },
+    materialDefinitions: {
+        path: 'materialDefinitions',
+        default: []
+    },
+    textureSetDefinitions: {
+        path: 'textureSetDefinitions',
+        default: []
+    },
+    geometryDefinitions: {
+        path: 'geometryDefinitions',
+        default: []
+    },
+    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

@@ -1,22 +1,25 @@
-export 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'
-  }
-};
-//# sourceMappingURL=metadata.js.map
+"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"}