@loaders.gl/tile-converter 4.2.0-alpha.4 → 4.2.0-alpha.5

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

@@ -1,123 +1,122 @@
 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]
-  },
-  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
-  }
+    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) => transform(originalObject, MATERIAL_DEFINITION_INFO_PARAMS())
-  }
+    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'
-  }
+    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()))
-  }
+    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 = () => ({
-  materialDefinitions: {
-    path: 'materialDefinitionInfos',
-    transform: transfromMaterialDefinitions
-  },
-  textureDefinitions: {
-    path: 'textureDefinitionInfos',
-    transform: transfromTextureDefinitions
-  }
+    materialDefinitions: {
+        path: 'materialDefinitionInfos',
+        transform: transfromMaterialDefinitions
+    },
+    textureDefinitions: {
+        path: 'textureDefinitionInfos',
+        transform: transfromTextureDefinitions
+    }
 });
 function transfromMaterialDefinitions(materialDefinitionInfos, thisObject, originalObject) {
-  const result = {};
-  for (const [index, materialDefinitionInfo] of materialDefinitionInfos.entries()) {
-    result[`Mat${originalObject.nodePath}${index}`] = transform(materialDefinitionInfo, MATERIAL_DEFINITION_INFO());
-  }
-  return result;
+    const result = {};
+    for (const [index, materialDefinitionInfo] of materialDefinitionInfos.entries()) {
+        result[`Mat${originalObject.nodePath}${index}`] = transform(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 = `${originalObject.nodePath}${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] = transform(textureDefinitionInfo, TEXTURE_DEFINITION_INFO());
+    }
+    return result;
 }
-//# sourceMappingURL=shared-resources.js.map

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

@@ -1,98 +1,100 @@
 export const STORE = {
-  id: {
-    path: 'id',
-    transform: val => val.toUpperCase()
-  },
-  profile: {
-    path: 'profile',
-    default: 'meshpyramids'
-  },
-  version: {
-    path: 'version',
-    default: '1.8'
-  },
-  resourcePattern: {
-    path: 'resourcePattern',
-    default: ['3dNodeIndexDocument', 'Attributes', 'SharedResource', 'Geometry']
-  },
-  rootNode: {
-    path: 'rootNode',
-    default: './nodes/root'
-  },
-  extent: {
-    path: 'extent'
-  },
-  indexCRS: {
-    path: 'indexCRS',
-    default: 'http://www.opengis.net/def/crs/EPSG/0/4326'
-  },
-  vertexCRS: {
-    path: 'vertexCRS',
-    default: 'http://www.opengis.net/def/crs/EPSG/0/4326'
-  },
-  normalReferenceFrame: {
-    path: 'normalReferenceFrame',
-    default: 'east-north-up'
-  },
-  attributeEncoding: {
-    path: 'attributeEncoding',
-    default: 'application/octet-stream; version=1.6'
-  },
-  textureEncoding: {
-    path: 'textureEncoding',
-    default: ['image/jpeg', 'image/ktx2']
-  },
-  lodType: {
-    path: 'lodType',
-    default: 'MeshPyramid'
-  },
-  lodModel: {
-    path: 'lodModel',
-    default: 'node-switching'
-  },
-  defaultGeometrySchema: {
-    path: 'defaultGeometrySchema',
-    default: {
-      geometryType: 'triangles',
-      header: [{
-        property: 'vertexCount',
-        type: 'UInt32'
-      }, {
-        property: 'featureCount',
-        type: 'UInt32'
-      }],
-      topology: 'PerAttributeArray',
-      ordering: ['position', 'normal', 'uv0', 'color'],
-      vertexAttributes: {
-        position: {
-          valueType: 'Float32',
-          valuesPerElement: 3
-        },
-        normal: {
-          valueType: 'Float32',
-          valuesPerElement: 3
-        },
-        uv0: {
-          valueType: 'Float32',
-          valuesPerElement: 2
-        },
-        color: {
-          valueType: 'UInt8',
-          valuesPerElement: 4
+    id: {
+        path: 'id',
+        transform: (val) => val.toUpperCase()
+    },
+    profile: {
+        path: 'profile',
+        default: 'meshpyramids'
+    },
+    version: {
+        path: 'version',
+        default: '1.8'
+    },
+    resourcePattern: {
+        path: 'resourcePattern',
+        default: ['3dNodeIndexDocument', 'Attributes', 'SharedResource', 'Geometry']
+    },
+    rootNode: {
+        path: 'rootNode',
+        default: './nodes/root'
+    },
+    extent: {
+        path: 'extent'
+    },
+    indexCRS: {
+        path: 'indexCRS',
+        default: 'http://www.opengis.net/def/crs/EPSG/0/4326'
+    },
+    vertexCRS: {
+        path: 'vertexCRS',
+        default: 'http://www.opengis.net/def/crs/EPSG/0/4326'
+    },
+    normalReferenceFrame: {
+        path: 'normalReferenceFrame',
+        default: 'east-north-up'
+    },
+    attributeEncoding: {
+        path: 'attributeEncoding',
+        default: 'application/octet-stream; version=1.6'
+    },
+    textureEncoding: {
+        path: 'textureEncoding',
+        default: ['image/jpeg', 'image/ktx2']
+    },
+    lodType: {
+        path: 'lodType',
+        default: 'MeshPyramid'
+    },
+    lodModel: {
+        path: 'lodModel',
+        default: 'node-switching'
+    },
+    defaultGeometrySchema: {
+        path: 'defaultGeometrySchema',
+        default: {
+            geometryType: 'triangles',
+            header: [
+                {
+                    property: 'vertexCount',
+                    type: 'UInt32'
+                },
+                {
+                    property: 'featureCount',
+                    type: 'UInt32'
+                }
+            ],
+            topology: 'PerAttributeArray',
+            ordering: ['position', 'normal', 'uv0', 'color'],
+            vertexAttributes: {
+                position: {
+                    valueType: 'Float32',
+                    valuesPerElement: 3
+                },
+                normal: {
+                    valueType: 'Float32',
+                    valuesPerElement: 3
+                },
+                uv0: {
+                    valueType: 'Float32',
+                    valuesPerElement: 2
+                },
+                color: {
+                    valueType: 'UInt8',
+                    valuesPerElement: 4
+                }
+            },
+            featureAttributeOrder: ['id', 'faceRange'],
+            featureAttributes: {
+                id: {
+                    valueType: 'UInt64',
+                    valuesPerElement: 1
+                },
+                faceRange: {
+                    valueType: 'UInt32',
+                    valuesPerElement: 2
+                }
+            }
         }
-      },
-      featureAttributeOrder: ['id', 'faceRange'],
-      featureAttributes: {
-        id: {
-          valueType: 'UInt64',
-          valuesPerElement: 1
-        },
-        faceRange: {
-          valueType: 'UInt32',
-          valuesPerElement: 2
-        }
-      }
     }
-  }
 };
-//# sourceMappingURL=store.js.map

package/dist/i3s-converter/types.js

@@ -1,25 +1,37 @@
-export let GLTFPrimitiveModeString = function (GLTFPrimitiveModeString) {
-  GLTFPrimitiveModeString["POINTS"] = "POINTS";
-  GLTFPrimitiveModeString["LINES"] = "LINES";
-  GLTFPrimitiveModeString["LINE_LOOP"] = "LINE_LOOP";
-  GLTFPrimitiveModeString["LINE_STRIP"] = "LINE_STRIP";
-  GLTFPrimitiveModeString["TRIANGLES"] = "TRIANGLES";
-  GLTFPrimitiveModeString["TRIANGLE_STRIP"] = "TRIANGLE_STRIP";
-  GLTFPrimitiveModeString["TRIANGLE_FAN"] = "TRIANGLE_FAN";
-  return GLTFPrimitiveModeString;
-}({});
+/**
+ * glTF primitive modes (mesh topology types)
+ * @see https://registry.khronos.org/glTF/specs/2.0/glTF-2.0.html#_mesh_primitive_mode
+ */
+export var GLTFPrimitiveModeString;
+(function (GLTFPrimitiveModeString) {
+    GLTFPrimitiveModeString["POINTS"] = "POINTS";
+    GLTFPrimitiveModeString["LINES"] = "LINES";
+    GLTFPrimitiveModeString["LINE_LOOP"] = "LINE_LOOP";
+    GLTFPrimitiveModeString["LINE_STRIP"] = "LINE_STRIP";
+    GLTFPrimitiveModeString["TRIANGLES"] = "TRIANGLES";
+    GLTFPrimitiveModeString["TRIANGLE_STRIP"] = "TRIANGLE_STRIP";
+    GLTFPrimitiveModeString["TRIANGLE_FAN"] = "TRIANGLE_FAN";
+})(GLTFPrimitiveModeString || (GLTFPrimitiveModeString = {}));
+/**
+ * I3S' types difine the following:
+ *   type Attribute = 'OBJECTID' | 'string' | 'double' | 'Int32' | string;
+ * The AttributeType contains the string values of the Attribute type.
+ */
 export const AttributeType = {
-  OBJECT_ID_TYPE: 'OBJECTID',
-  STRING_TYPE: 'string',
-  DOUBLE_TYPE: 'double',
-  SHORT_INT_TYPE: 'Int32'
+    /** Type of attribute that is linked with feature ids */
+    OBJECT_ID_TYPE: 'OBJECTID',
+    /** String data type name for feature attributes */
+    STRING_TYPE: 'string',
+    /** Double data type name for feature attributes */
+    DOUBLE_TYPE: 'double',
+    /** Integer data type name for feature attributes */
+    SHORT_INT_TYPE: 'Int32'
 };
-export let ResourceType = function (ResourceType) {
-  ResourceType["ATTRIBUTES"] = "ATTRIBUTES";
-  ResourceType["DRACO_GEOMETRY"] = "DRACO_GEOMETRY";
-  ResourceType["GEOMETRY"] = "GEOMETRY";
-  ResourceType["SHARED"] = "SHARED";
-  ResourceType["TEXTURE"] = "TEXTURE";
-  return ResourceType;
-}({});
-//# sourceMappingURL=types.js.map
+export var ResourceType;
+(function (ResourceType) {
+    ResourceType["ATTRIBUTES"] = "ATTRIBUTES";
+    ResourceType["DRACO_GEOMETRY"] = "DRACO_GEOMETRY";
+    ResourceType["GEOMETRY"] = "GEOMETRY";
+    ResourceType["SHARED"] = "SHARED";
+    ResourceType["TEXTURE"] = "TEXTURE";
+})(ResourceType || (ResourceType = {}));

package/dist/i3s-server/app.js

@@ -2,24 +2,27 @@ import express from 'express';
 import path from 'path';
 import logger from 'morgan';
 import cors from 'cors';
+// For local debug
+// import {fileURLToPath} from 'url';
 import { loadArchive } from "./controllers/slpk-controller.js";
-import { router as indexRouter } from "./routes/index.js";
+import { router as indexRouter } from "./routes.js";
 import { sceneServerRouter, router } from "./routes/slpk-router.js";
-const I3S_LAYER_PATH = process.env.I3sLayerPath || '';
-const FULL_LAYER_PATH = path.join(process.cwd(), I3S_LAYER_PATH);
+// For local debug
+// const __filename = fileURLToPath(import.meta.url);
+// const __dirname = path.dirname(__filename);
+const I3S_LAYER_PATH = process.env.I3sLayerPath || ''; // eslint-disable-line no-process-env, no-undef
+const FULL_LAYER_PATH = path.join(process.cwd(), I3S_LAYER_PATH); // eslint-disable-line no-undef
 export const app = express();
 app.use(logger('dev'));
 app.use(express.json());
-app.use(express.urlencoded({
-  extended: false
-}));
+app.use(express.urlencoded({ extended: false }));
 app.use(express.static(path.join(__dirname, 'public')));
 app.use(cors());
 if (/\.slpk$/.test(I3S_LAYER_PATH)) {
-  loadArchive(FULL_LAYER_PATH);
-  app.use('/SceneServer/layers/0', router);
-  app.use('/SceneServer', sceneServerRouter);
-} else {
-  app.use('/', indexRouter);
+    loadArchive(FULL_LAYER_PATH);
+    app.use('/SceneServer/layers/0', router);
+    app.use('/SceneServer', sceneServerRouter);
+}
+else {
+    app.use('/', indexRouter);
 }
-//# sourceMappingURL=app.js.map

package/dist/i3s-server/bin/www.js

@@ -4,27 +4,34 @@ import https from 'https';
 import http from 'http';
 import fs from 'fs';
 import path from 'path';
+// For local debug
+// import {fileURLToPath} from 'url';
 import { formErrorHandler, formListeningHandler, normalizePort } from "../utils/server-utils.js";
+// For local debug
+// const __filename = fileURLToPath(import.meta.url);
+// const __dirname = path.dirname(__filename);
+/** Get port from environment and store in Express. */
 const httpPort = normalizePort(process.env.PORT || '80');
 if (httpPort === false) {
-  console.error(`Incorrect HTTP port`);
-  process.exit(1);
+    console.error(`Incorrect HTTP port`);
+    process.exit(1);
 }
 const httpsPort = normalizePort(process.env.HTTPS_PORT || '443');
 if (httpsPort === false) {
-  console.error(`Incorrect HTTPs port`);
-  process.exit(1);
+    console.error(`Incorrect HTTPs port`);
+    process.exit(1);
 }
+/** Create HTTP server. */
 const options = {
-  key: fs.readFileSync(path.join(__dirname, '../certs/key.pem')),
-  cert: fs.readFileSync(path.join(__dirname, '../certs/cert.pem'))
+    key: fs.readFileSync(path.join(__dirname, '../certs/key.pem')),
+    cert: fs.readFileSync(path.join(__dirname, '../certs/cert.pem'))
 };
 const httpServer = http.createServer(app);
 const httpsServer = https.createServer(options, app);
+/** Listen on provided port, on all network interfaces. */
 httpServer.listen(httpPort);
 httpServer.on('error', formErrorHandler(httpPort));
 httpServer.on('listening', formListeningHandler(httpServer));
 httpsServer.listen(httpsPort);
 httpsServer.on('error', formErrorHandler(httpsPort));
 httpsServer.on('listening', formListeningHandler(httpsServer));
-//# sourceMappingURL=www.js.map

package/dist/i3s-server/controllers/index-controller.js

@@ -1,21 +1,24 @@
 import path from 'path';
 import fs from 'fs';
-const {
-  promises
-} = fs;
+const { promises } = fs;
 const I3S_LAYER_PATH = process.env.I3sLayerPath || '';
+/**
+ * Get local file name by input HTTP URL
+ * @param url - I3S HTTP service url
+ * @returns - local file name
+ */
 export async function getFileNameByUrl(url) {
-  const extensions = ['json', 'bin', 'jpg', 'jpeg', 'png', 'bin.dds', 'ktx2'];
-  const FULL_LAYER_PATH = path.join(process.cwd(), I3S_LAYER_PATH);
-  for (const ext of extensions) {
-    const fileName = `${FULL_LAYER_PATH}${url}/index.${ext}`;
-    try {
-      await promises.access(fileName);
-      return fileName;
-    } catch {
-      continue;
+    const extensions = ['json', 'bin', 'jpg', 'jpeg', 'png', 'bin.dds', 'ktx2'];
+    const FULL_LAYER_PATH = path.join(process.cwd(), I3S_LAYER_PATH);
+    for (const ext of extensions) {
+        const fileName = `${FULL_LAYER_PATH}${url}/index.${ext}`;
+        try {
+            await promises.access(fileName);
+            return fileName;
+        }
+        catch {
+            continue; // eslint-disable-line no-continue
+        }
     }
-  }
-  return null;
+    return null;
 }
-//# sourceMappingURL=index-controller.js.map

package/dist/i3s-server/controllers/slpk-controller.js

@@ -2,18 +2,29 @@ import '@loaders.gl/polyfills';
 import { parseSLPKArchive } from '@loaders.gl/i3s';
 import { FileHandleFile } from '@loaders.gl/loader-utils';
 let slpkArchive;
+/**
+ * Open SLPK file for reading and load HASH file
+ * @param fullLayerPath - full path to SLPK file
+ */
 export async function loadArchive(fullLayerPath) {
-  slpkArchive = await parseSLPKArchive(new FileHandleFile(fullLayerPath), msg => console.log(msg));
-  console.log('The server is ready to use');
+    slpkArchive = await parseSLPKArchive(new FileHandleFile(fullLayerPath), (msg) => console.log(msg));
+    console.log('The server is ready to use');
 }
+/**
+ * Get a file from SLPK
+ * @param url - I3S HTTP URL
+ * @returns  - file content
+ */
 export async function getFileByUrl(url) {
-  const trimmedPath = /^\/?(.*)\/?$/.exec(url);
-  if (trimmedPath) {
-    try {
-      const uncompressedFile = await slpkArchive.getFile(trimmedPath[1], 'http');
-      return uncompressedFile;
-    } catch {}
-  }
-  return null;
+    const trimmedPath = /^\/?(.*)\/?$/.exec(url);
+    if (trimmedPath) {
+        try {
+            const uncompressedFile = await slpkArchive.getFile(trimmedPath[1], 'http');
+            return uncompressedFile;
+        }
+        catch {
+            // TODO - log error?
+        }
+    }
+    return null;
 }
-//# sourceMappingURL=slpk-controller.js.map