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

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

@@ -1,80 +1,89 @@
-import transform from 'json-map-transform';
-const COORDINATES = {
-  mbs: {
-    path: 'mbs'
-  },
-  obb: {
-    path: 'obb'
-  }
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-const _href = {
-  href: {
-    path: 'href'
-  }
-};
-const PARENT_NODE = {
-  id: {
-    path: 'id'
-  },
-  ..._href,
-  ...COORDINATES
-};
-export 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 => transform(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
-  }
-};
-//# sourceMappingURL=node.js.map
+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

@@ -1,28 +1,31 @@
-export const SCENE_SERVER_TEMPLATE = {
-  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]
-  }
-};
-//# sourceMappingURL=scene-server.js.map
+"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"}

package/dist/i3s-converter/json-templates/shared-resources.js

@@ -1,130 +1,129 @@
-import transform from 'json-map-transform';
-const MATERIAL_DEFINITION_INFO_PARAMS = {
-  renderMode: {
-    path: 'renderMode',
-    default: 'solid'
-  },
-  shininess: {
-    path: 'shininess',
-    default: 1
-  },
-  reflectivity: {
-    path: 'reflectivity',
-    default: 0
-  },
-  ambient: {
-    path: 'ambient',
-    default: [1, 1, 1, 1]
-  },
-  diffuse: {
-    path: 'diffuse',
-    default: [1, 1, 1, 1]
-  },
-  specular: {
-    path: 'specular',
-    default: [0, 0, 0, 0]
-  },
-  useVertexColorAlpha: {
-    path: 'useVertexColorAlpha',
-    default: false
-  },
-  vertexRegions: {
-    path: 'vertexRegions',
-    default: false
-  },
-  vertexColors: {
-    path: 'vertexColors',
-    default: true
-  }
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-const MATERIAL_DEFINITION_INFO = {
-  name: {
-    path: 'name',
-    default: 'standard'
-  },
-  type: {
-    path: 'type',
-    default: 'standard'
-  },
-  params: {
-    path: 'params',
-    transform: (val, thisObject, originalObject) => transform(originalObject, MATERIAL_DEFINITION_INFO_PARAMS)
-  }
-};
-const TEXTURE_DEFINITION_IMAGE = {
-  id: {
-    path: 'id'
-  },
-  size: {
-    path: 'size'
-  },
-  href: {
-    path: 'href',
-    default: ['../textures/0']
-  },
-  length: {
-    path: 'length'
-  }
-};
-const TEXTURE_DEFINITION_INFO = {
-  encoding: {
-    path: 'encoding'
-  },
-  wrap: {
-    path: 'wrap',
-    default: ['none']
-  },
-  atlas: {
-    path: 'atlas',
-    default: false
-  },
-  uvSet: {
-    path: 'uvSet',
-    default: 'uv0'
-  },
-  channels: {
-    path: 'channels',
-    default: 'rgb'
-  },
-  images: {
-    path: 'images',
-    transform: (val, thisObject, originalObject) => val.map(image => transform(image, TEXTURE_DEFINITION_IMAGE))
-  }
-};
-export const SHARED_RESOURCES_TEMPLATE = {
-  materialDefinitions: {
-    path: 'materialDefinitionInfos',
-    transform: transfromMaterialDefinitions
-  },
-  textureDefinitions: {
-    path: 'textureDefinitionInfos',
-    transform: transfromTextureDefinitions
-  }
-};
-
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SHARED_RESOURCES = void 0;
+const json_map_transform_1 = __importDefault(require("json-map-transform"));
+const MATERIAL_DEFINITION_INFO_PARAMS = () => ({
+    renderMode: {
+        path: 'renderMode',
+        default: 'solid'
+    },
+    shininess: {
+        path: 'shininess',
+        default: 1
+    },
+    reflectivity: {
+        path: 'reflectivity',
+        default: 0
+    },
+    ambient: {
+        path: 'ambient',
+        default: [1, 1, 1]
+    },
+    diffuse: {
+        path: 'diffuse',
+        default: [1, 1, 1]
+    },
+    specular: {
+        path: 'specular',
+        default: [0, 0, 0]
+    },
+    useVertexColorAlpha: {
+        path: 'useVertexColorAlpha',
+        default: false
+    },
+    vertexRegions: {
+        path: 'vertexRegions',
+        default: false
+    },
+    vertexColors: {
+        path: 'vertexColors',
+        default: true
+    }
+});
+const MATERIAL_DEFINITION_INFO = () => ({
+    name: {
+        path: 'name',
+        default: 'standard'
+    },
+    type: {
+        path: 'type',
+        default: 'standard'
+    },
+    params: {
+        path: 'params',
+        transform: (val, thisObject, originalObject) => (0, json_map_transform_1.default)(originalObject, MATERIAL_DEFINITION_INFO_PARAMS())
+    }
+});
+const TEXTURE_DEFINITION_IMAGE = () => ({
+    id: {
+        path: 'id'
+    },
+    size: {
+        path: 'size'
+    },
+    href: {
+        path: 'href',
+        default: ['../textures/0']
+    },
+    length: {
+        path: 'length'
+    }
+});
+const TEXTURE_DEFINITION_INFO = () => ({
+    encoding: {
+        path: 'encoding'
+    },
+    wrap: {
+        path: 'wrap',
+        default: ['none']
+    },
+    atlas: {
+        path: 'atlas',
+        default: false
+    },
+    uvSet: {
+        path: 'uvSet',
+        default: 'uv0'
+    },
+    channels: {
+        path: 'channels',
+        default: 'rgb'
+    },
+    images: {
+        path: 'images',
+        transform: (val, thisObject, originalObject) => val.map((image) => (0, json_map_transform_1.default)(image, TEXTURE_DEFINITION_IMAGE()))
+    }
+});
+const SHARED_RESOURCES = () => ({
+    materialDefinitions: {
+        path: 'materialDefinitionInfos',
+        transform: transfromMaterialDefinitions
+    },
+    textureDefinitions: {
+        path: 'textureDefinitionInfos',
+        transform: transfromTextureDefinitions
+    }
+});
+exports.SHARED_RESOURCES = SHARED_RESOURCES;
 function transfromMaterialDefinitions(materialDefinitionInfos, thisObject, originalObject) {
-  const result = {};
-
-  for (const [index, materialDefinitionInfo] of materialDefinitionInfos.entries()) {
-    result["Mat".concat(originalObject.nodePath).concat(index)] = transform(materialDefinitionInfo, MATERIAL_DEFINITION_INFO);
-  }
-
-  return result;
+    const result = {};
+    for (const [index, materialDefinitionInfo] of materialDefinitionInfos.entries()) {
+        result[`Mat${originalObject.nodePath}${index}`] = (0, json_map_transform_1.default)(materialDefinitionInfo, MATERIAL_DEFINITION_INFO());
+    }
+    return result;
 }
-
 function transfromTextureDefinitions(textureDefinitionInfos, thisObject, originalObject) {
-  if (!textureDefinitionInfos) {
-    return null;
-  }
-
-  const result = {};
-
-  for (const [index, textureDefinitionInfo] of textureDefinitionInfos.entries()) {
-    const imageIndex = "".concat(originalObject.nodePath).concat(index);
-    textureDefinitionInfo.imageIndex = imageIndex;
-    result[imageIndex] = transform(textureDefinitionInfo, TEXTURE_DEFINITION_INFO);
-  }
-
-  return result;
+    if (!textureDefinitionInfos) {
+        return null;
+    }
+    const result = {};
+    for (const [index, textureDefinitionInfo] of textureDefinitionInfos.entries()) {
+        const imageIndex = `${originalObject.nodePath}${index}`;
+        textureDefinitionInfo.imageIndex = imageIndex;
+        result[imageIndex] = (0, json_map_transform_1.default)(textureDefinitionInfo, TEXTURE_DEFINITION_INFO());
+    }
+    return result;
 }
-//# sourceMappingURL=shared-resources.js.map

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

@@ -0,0 +1,95 @@
+export declare const STORE: {
+    id: {
+        path: string;
+        transform: (val: any) => any;
+    };
+    profile: {
+        path: string;
+        default: string;
+    };
+    version: {
+        path: string;
+        default: string;
+    };
+    resourcePattern: {
+        path: string;
+        default: string[];
+    };
+    rootNode: {
+        path: string;
+        default: string;
+    };
+    extent: {
+        path: string;
+    };
+    indexCRS: {
+        path: string;
+        default: string;
+    };
+    vertexCRS: {
+        path: string;
+        default: string;
+    };
+    normalReferenceFrame: {
+        path: string;
+        default: string;
+    };
+    attributeEncoding: {
+        path: string;
+        default: string;
+    };
+    textureEncoding: {
+        path: string;
+        default: string[];
+    };
+    lodType: {
+        path: string;
+        default: string;
+    };
+    lodModel: {
+        path: string;
+        default: string;
+    };
+    defaultGeometrySchema: {
+        path: string;
+        default: {
+            geometryType: string;
+            header: {
+                property: string;
+                type: string;
+            }[];
+            topology: string;
+            ordering: string[];
+            vertexAttributes: {
+                position: {
+                    valueType: string;
+                    valuesPerElement: number;
+                };
+                normal: {
+                    valueType: string;
+                    valuesPerElement: number;
+                };
+                uv0: {
+                    valueType: string;
+                    valuesPerElement: number;
+                };
+                color: {
+                    valueType: string;
+                    valuesPerElement: number;
+                };
+            };
+            featureAttributeOrder: string[];
+            featureAttributes: {
+                id: {
+                    valueType: string;
+                    valuesPerElement: number;
+                };
+                faceRange: {
+                    valueType: string;
+                    valuesPerElement: number;
+                };
+            };
+        };
+    };
+};
+//# sourceMappingURL=store.d.ts.map

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

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