itowns 2.45.1-next.0 → 2.45.1-next.1

package/lib/Utils/gui/Scale.js

@@ -0,0 +1,104 @@
+import { CONTROL_EVENTS, GLOBE_VIEW_EVENTS, PLANAR_CONTROL_EVENT, VIEW_EVENTS } from 'itowns';
+import Widget from "./Widget.js";
+const DEFAULT_OPTIONS = {
+  width: 200,
+  height: 30,
+  position: 'bottom-left'
+};
+
+/**
+ * A widget for scale
+ *
+ * To use it, you need to link the widgets' stylesheet to your html webpage. This stylesheet is included in
+ * [itowns bundles](https://github.com/iTowns/itowns/releases) if you downloaded them, or it can be found in
+ * `node_modules/itowns/examples/css` if you installed iTowns with npm. Otherwise, it can be found at
+ * [this link](https://raw.githubusercontent.com/iTowns/itowns/master/examples/css/widgets.css). See
+ * [this example](http://www.itowns-project.org/itowns/examples/#widgets_scale) for more details.
+ *
+ * @extends Widget
+ *
+ * @property    {HTMLElement}   domElement      An html div containing the scale.
+ * @property    {HTMLElement}   parentElement   The parent HTML container of `this.domElement`.
+ */
+class Scale extends Widget {
+  /**
+   * @param   {View}                  view                                    The iTowns view the scale should be
+                                                                              * linked to. If it is a
+                                                                              * {@link PlanarView} or a
+                                                                              * {@link GlobeView}, the scale will be
+                                                                              * automatically updated. Otherwise, user
+                                                                              * will need to implement the update
+                                                                              * automation using the `Scale.update`
+                                                                              * method.
+   * @param   {Object}                [options]                               The scale optional configuration.
+   * @param   {HTMLElement}           [options.parentElement=view.domElement] The parent HTML container of the div
+                                                                              * which contains scale widgets.
+   * @param   {number}                [options.width=200]                     The width in pixels of the scale.
+   * @param   {number}                [options.height=30]                     The height in pixels of the scale.
+   * @param   {string}                [options.position='bottom-left']        Defines which position within the
+                                                                              * `parentElement` the scale should be
+                                                                              * displayed to. Possible values are
+                                                                              * `top`, `bottom`, `left`, `right`,
+                                                                              * `top-left`, `top-right`, `bottom-left`
+                                                                              * and `bottom-right`. If the input value
+                                                                              * does not match one of these, it will
+                                                                              * be defaulted to `bottom-left`.
+   * @param   {Object}                [options.translate]                     An optional translation of the scale.
+   * @param   {number}                [options.translate.x=0]                 The scale translation along the page
+                                                                              * x-axis.
+   * @param   {number}                [options.translate.y=0]                 The scale translation along the page
+                                                                              * y-axis.
+   */
+  constructor(view) {
+    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    // ---------- BUILD PROPERTIES ACCORDING TO DEFAULT OPTIONS AND OPTIONS PASSED IN PARAMETERS : ----------
+
+    super(view, options, DEFAULT_OPTIONS);
+
+    // ---------- this.domElement SETTINGS SPECIFIC TO SCALE : ----------
+
+    this.domElement.id = 'widgets-scale';
+    this.view = view;
+
+    // Initialize the text content of the scale, which will later be updated by a numerical value.
+    this.domElement.innerHTML = 'Scale';
+    this.width = options.width || DEFAULT_OPTIONS.width;
+    if (this.view.isGlobeView) {
+      this.view.addEventListener(GLOBE_VIEW_EVENTS.GLOBE_INITIALIZED, () => {
+        this.update();
+      });
+      this.view.controls.addEventListener(CONTROL_EVENTS.RANGE_CHANGED, () => {
+        this.update();
+      });
+    } else if (this.view.isPlanarView) {
+      this.view.addEventListener(VIEW_EVENTS.INITIALIZED, () => {
+        this.update();
+      });
+      this.view.addEventListener(PLANAR_CONTROL_EVENT.MOVED, () => {
+        this.update();
+      });
+    } else {
+      console.warn('The \'view\' linked to scale widget is neither a \'GlobeView\' nor a \'PlanarView\'. The ' + 'scale wont automatically update. You can implement its update automation using \'Scale.update\' ' + 'method.');
+    }
+  }
+  addEventListeners() {}
+
+  /**
+   * Update the scale size and content according to view camera position.
+   */
+  update() {
+    // Calculate the rounded metric distance which matches the scale width in pixels.
+    let metricDistance = Math.round(this.view.getPixelsToMeters(this.width));
+    const digit = 10 ** (metricDistance.toString().length - 1);
+    metricDistance = Math.round(metricDistance / digit) * digit;
+    const pixelDistance = this.view.getMetersToPixels(metricDistance);
+    let unit = 'm';
+    if (metricDistance >= 1000) {
+      metricDistance /= 1000;
+      unit = 'km';
+    }
+    this.domElement.innerHTML = `${metricDistance} ${unit}`;
+    this.domElement.style.width = `${pixelDistance}px`;
+  }
+}
+export default Scale;

package/lib/Utils/gui/Searchbar.js

@@ -0,0 +1,234 @@
+import { Fetcher } from 'itowns';
+import Widget from "./Widget.js";
+const DEFAULT_OPTIONS = {
+  width: 300,
+  height: 38,
+  position: 'top',
+  maxSuggestionNumber: 10,
+  fontSize: 16,
+  placeholder: 'Search location'
+};
+function addActive(htmlElements, index) {
+  if (!htmlElements) {
+    return index;
+  }
+  removeAllActives(htmlElements);
+  if (index >= htmlElements.length) {
+    index = 0;
+  } else if (index < 0) {
+    index = htmlElements.length - 1;
+  }
+  htmlElements[index]?.classList.add('active');
+  return index;
+}
+function removeAllActives(htmlElements) {
+  for (let i = 0; i < htmlElements.length; i++) {
+    htmlElements[i].classList.remove('active');
+  }
+}
+function eraseSuggestionList(form) {
+  while (form.children.length > 1) {
+    form.removeChild(form.lastChild);
+  }
+}
+
+/**
+ * A widget for searchbar
+ *
+ * To use it, you need to link the widgets' stylesheet to your html webpage. This stylesheet is included in
+ * [itowns bundles](https://github.com/iTowns/itowns/releases) if you downloaded them, or it can be found in
+ * `node_modules/itowns/examples/css` if you installed iTowns with npm. Otherwise, it can be found at
+ * [this link](https://raw.githubusercontent.com/iTowns/itowns/master/examples/css/widgets.css). See
+ * [this example](http://www.itowns-project.org/itowns/examples/#widgets_searchbar) for more details.
+ *
+ * @extends Widget
+ *
+ * @property    {HTMLElement}   domElement      An html div containing the searchbar.
+ * @property    {HTMLElement}   parentElement   The parent HTML container of `this.domElement`.
+ */
+class Searchbar extends Widget {
+  #_onSelected;
+
+  /**
+   * @param   {View}          view                                    The iTowns view the searchbar should be linked
+                                                                      * to.
+   *
+   * @param   {Object}        geocodingOptions                        Configuration for geocoding.
+   * @param   {URL}           geocodingOptions.url                    The URL of a geocoding service that should be
+                                                                      * used to build suggestions.
+   * @param   {function}      geocodingOptions.parser                 A method to parse fetched results from geocoding
+                                                                      * url into a Map object. For each entry of this
+                                                                      * Map, the key must be a string that will be
+                                                                      * displayed as the html content of each
+                                                                      * suggestion bellow the searchbar. The value
+                                                                      * associated to the key is whatever the user
+                                                                      * wants. The value is the parameter that is
+                                                                      * passed to the `onSelected` method (specified
+                                                                      * in another `geocodingOptions` parameter).
+   * @param   {function}      [geocodingOptions.onSelected]           A method which describes what should be done
+                                                                      * when user selects a location (by clicking or
+                                                                      * hitting enter on a suggestion). The only
+                                                                      * parameter of this method is the value mapped
+                                                                      * with `geocodingOptions.parser` method.
+   *
+   * @param   {Object}        [options]                               The searchbar optional configuration.
+   * @param   {HTMLElement}   [options.parentElement=view.domElement] The parent HTML container of the div which
+                                                                      * contains searchbar widgets.
+   * @param   {number}        [options.size]                          The size of the searchbar. It is a number that
+                                                                      * describes both width and height in pixels of
+                                                                      * the searchbar.
+   * @param   {number}        [options.width=300]                     The width in pixels of the searchbar.
+   * @param   {number}        [options.height=38]                     The height in pixels of the searchbar.
+   * @param   {string}        [options.position='top']                Defines which position within the
+                                                                      * `parentElement` the searchbar should be
+                                                                      * displayed to. Possible values are `top`,
+                                                                      * `bottom`, `left`, `right`, `top-left`,
+                                                                      * `top-right`, `bottom-left` and `bottom-right`.
+                                                                      * If the input value does not match one of
+                                                                      * these, it will be defaulted to `top`.
+   * @param   {Object}        [options.translate]                     An optional translation of the searchbar.
+   * @param   {number}        [options.translate.x=0]                 The searchbar translation along the page x-axis.
+   * @param   {number}        [options.translate.y=0]                 The searchbar translation along the page y-axis.
+   * @param   {number}        [options.fontSize=16]                   The font size in pixel of the searchbar content.
+   * @param   {number}        [options.maxSuggestionNumber=10]        The maximum number of suggestions that should
+                                                                      * appear under the searchbar.
+   * @param   {string}        [options.placeholder='Search location'] The placeholder that appears in the searchbar
+                                                                      * when nothing has yet been typed.
+   */
+  constructor(view, geocodingOptions) {
+    let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+    // ---------- BUILD PROPERTIES ACCORDING TO DEFAULT OPTIONS AND OPTIONS PASSED IN PARAMETERS : ----------
+    super(view, options, DEFAULT_OPTIONS);
+
+    // Check if `geocodingOptions` parameter was correctly specified.
+    if (!geocodingOptions || !geocodingOptions.url || !geocodingOptions.parser || typeof geocodingOptions.parser !== 'function') {
+      throw new Error('\'geocodingOptions\' parameter for \'Searchbar\' constructor is not a valid option. Please refer to ' + 'the documentation.');
+    }
+    this.#_onSelected = geocodingOptions.onSelected ?? (() => {});
+
+    // ---------- this.domElement SETTINGS SPECIFIC TO SEARCHBAR : ----------
+
+    this.domElement.id = 'widgets-searchbar';
+    this.domElement.style.height = 'auto';
+    const form = document.createElement('form');
+    form.setAttribute('autocomplete', 'off');
+    form.id = 'searchbar-autocompletion-form';
+    this.domElement.appendChild(form);
+    const input = document.createElement('input');
+    input.setAttribute('type', 'text');
+    input.setAttribute('name', 'mySearch');
+    input.setAttribute('placeholder', options.placeholder || DEFAULT_OPTIONS.placeholder);
+    input.style.height = `${options.height || options.size || DEFAULT_OPTIONS.height}px`;
+    input.style.fontSize = `${options.fontSize || DEFAULT_OPTIONS.fontSize}px`;
+    form.appendChild(input);
+
+    // currentFocus variable stores the index of the suggestions that is focused by user, either with mouse or arrow
+    // keys.
+    let currentFocus;
+
+    // ----------  BUILD AUTOCOMPLETION SUGGESTIONS LIST WHEN TYPING THE SEARCHBAR INPUT : ----------
+
+    input.addEventListener('input', () => {
+      const value = input.value;
+
+      // Close any already opened list of autocompleted values
+      eraseSuggestionList(form);
+      currentFocus = -1;
+      if (!value) {
+        return false;
+      }
+      geocodingOptions.url.searchParams.set('text', value);
+      Fetcher.json(geocodingOptions.url).then(geocodingResult => {
+        const result = geocodingOptions.parser(geocodingResult);
+        let i = 0;
+        result.forEach((info, location) => {
+          // Stop looping through the map if enough location have been proceeded.
+          if (i === Math.min(result.size, options.maxSuggestionNumber || DEFAULT_OPTIONS.maxSuggestionNumber)) {
+            return;
+          }
+          const mapIndex = i;
+          i++;
+          const index = location.toUpperCase().indexOf(value.toUpperCase());
+          if (index > -1) {
+            const autocompleteItem = document.createElement('div');
+            autocompleteItem.style.minHeight = input.style.height;
+            autocompleteItem.style.fontSize = `${options.fontSize || DEFAULT_OPTIONS.fontSize}px`;
+
+            // Make the matching letters bold.
+            const start = location.slice(0, index);
+            const bold = location.slice(index, index + value.length);
+            const end = location.slice(index + value.length, location.length);
+            autocompleteItem.innerHTML = `<p>${start}<strong>${bold}</strong>${end}</p>`;
+            // Store the current location value as an attribute of autocompleteItem div.
+            autocompleteItem.setAttribute('location', location);
+            form.appendChild(autocompleteItem);
+
+            // eslint-disable-next-line no-loop-func
+            autocompleteItem.addEventListener('mouseover', () => {
+              removeAllActives(form.children);
+              currentFocus = mapIndex;
+              autocompleteItem.classList.add('active');
+            });
+            autocompleteItem.addEventListener('click', () => {
+              this.#_onSelected(info);
+              input.value = autocompleteItem.getAttribute('location');
+              eraseSuggestionList(form);
+            });
+          }
+        });
+      });
+    });
+
+    // ---------- MANAGE KEYBOARD INTERACTIONS ON AUTOCOMPLETION SUGGESTIONS : ----------
+
+    // When searchbar is positioned at the bottom of the screen (therefore is a flex with `column-reverse`
+    // direction, we must exchange up and down arrow actions.
+    const topOrBottom = (options.position || DEFAULT_OPTIONS.position).includes('top') ? 1 : -1;
+    input.addEventListener('keydown', event => {
+      event.stopPropagation();
+      const completionSuggestions = form.getElementsByTagName('div');
+      switch (event.code) {
+        case 'Escape':
+          eraseSuggestionList(form);
+          input.value = '';
+          view.domElement.focus();
+          break;
+        case 'ArrowDown':
+          event.preventDefault();
+          currentFocus = addActive(completionSuggestions, currentFocus + topOrBottom);
+          break;
+        case 'ArrowUp':
+          event.preventDefault();
+          currentFocus = addActive(completionSuggestions, currentFocus - topOrBottom);
+          break;
+        case 'Enter':
+          event.preventDefault();
+          if (completionSuggestions[Math.max(currentFocus, 0)]) {
+            completionSuggestions[Math.max(currentFocus, 0)].click();
+            view.domElement.focus();
+          }
+          break;
+        default:
+          break;
+      }
+    });
+
+    // ---------- MANAGE FOCUS AND ACTIVE SUGGESTION WHEN USER ENTERS OR LEAVES THE SEARCHBAR : ----------
+
+    // User clicks the searchbar.
+    input.addEventListener('focus', () => {
+      form.classList.add('focus');
+    });
+    // User clicks out of the searchbar.
+    input.addEventListener('blur', () => {
+      form.classList.remove('focus');
+      removeAllActives(form.children);
+    });
+    // Cursor leaves the searchbar.
+    form.addEventListener('mouseleave', () => {
+      removeAllActives(form.children);
+      currentFocus = -1;
+    });
+  }
+}
+export default Searchbar;

package/lib/Utils/gui/Widget.js

@@ -0,0 +1,80 @@
+/**
+ * An interface that stores common methods for all specific widgets.
+ *
+ * @hideconstructor
+ */
+class Widget {
+  #_display;
+  constructor(view) {
+    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    let defaultOptions = arguments.length > 2 ? arguments[2] : undefined;
+    this.parentElement = options.parentElement || view.domElement;
+    this.position = options.position || defaultOptions.position;
+    if (!['top-left', 'top-right', 'bottom-left', 'bottom-right', 'top', 'bottom', 'left', 'right'].includes(this.position)) {
+      console.warn('\'position\' optional parameter for \'Widget\' constructor is not a valid option. ' + `It will be set to '${defaultOptions.position}'.`);
+      this.position = defaultOptions.position;
+    }
+
+    // ---------- CREATE A DomElement WITH id, classes AND style RELEVANT TO THE WIDGET PROPERTIES : ----------
+
+    // Create a div containing minimap widget and add it to its specified parent.
+    this.domElement = document.createElement('div');
+    this.parentElement.appendChild(this.domElement);
+
+    // Size widget according to options.
+    this.domElement.style.width = `${options.width || options.size || defaultOptions.width}px`;
+    this.domElement.style.height = `${options.height || options.size || defaultOptions.height}px`;
+
+    // Position widget according to options.
+    const positionArray = this.position.split('-');
+    this.domElement.classList.add(`${positionArray[0]}-widget`);
+    if (positionArray[1]) {
+      this.domElement.classList.add(`${positionArray[1]}-widget`);
+    } else {
+      // If only one position parameter was given, center the domElement on the other axis.
+      // TODO : at this stage, offsetWidth and offsetHeight do no include borders. This should be worked around.
+      switch (positionArray[0]) {
+        case 'top':
+        case 'bottom':
+          this.domElement.style.left = `calc(50% - ${this.domElement.offsetWidth / 2}px)`;
+          break;
+        case 'left':
+        case 'right':
+          this.domElement.style.top = `calc(50% - ${this.domElement.offsetHeight / 2}px)`;
+          break;
+        default:
+          break;
+      }
+    }
+
+    // Translate widget div according to optional translate parameter.
+    if (options.translate) {
+      this.domElement.style.transform = `translate(${options.translate.x || 0}px, ${options.translate.y || 0}px)`;
+    }
+
+    // Prevent triggering `GlobeControls` and `PlanarControls` mouse or pointer events when clicking the search bar.
+    // For example, this prevents triggering an animated travel when double-clicking search bar in a `GlobeView`.
+    this.domElement.addEventListener('pointerdown', e => {
+      e.stopPropagation();
+    });
+    this.domElement.addEventListener('mousedown', e => {
+      e.stopPropagation();
+    });
+  }
+
+  /**
+   * Change the widget style `display` property so that the widget becomes visible.
+   */
+  show() {
+    this.domElement.style.display = this.#_display;
+  }
+
+  /**
+   * Change the widget style `display` property so that the widget becomes invisible.
+   */
+  hide() {
+    this.#_display = window.getComputedStyle(this.domElement).display;
+    this.domElement.style.display = 'none';
+  }
+}
+export default Widget;

package/lib/Utils/placeObjectOnGround.js

@@ -0,0 +1,136 @@
+import * as THREE from 'three';
+import { Coordinates } from '@itowns/geographic';
+import DEMUtils from "./DEMUtils.js";
+const temp = {
+  v: new THREE.Vector3(),
+  coord1: new Coordinates('EPSG:4978'),
+  coord2: new Coordinates('EPSG:4978'),
+  offset: new THREE.Vector2()
+};
+function _updateVector3(layer, method, nodes, vecCRS, vec, offset) {
+  let matrices = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : {};
+  let coords = arguments.length > 7 ? arguments[7] : undefined;
+  let cache = arguments.length > 8 ? arguments[8] : undefined;
+  const coord = coords || new Coordinates(vecCRS);
+  if (matrices.worldFromLocal) {
+    coord.setFromVector3(temp.v.copy(vec).applyMatrix4(matrices.worldFromLocal));
+  } else {
+    coord.setFromVector3(vec);
+  }
+  const result = DEMUtils.getTerrainObjectAt(layer, coord, method, nodes, cache);
+  if (result) {
+    result.coord.z += offset;
+    result.coord.as(vecCRS, temp.coord2).toVector3(vec);
+    if (matrices.localFromWorld) {
+      vec.applyMatrix4(matrices.localFromWorld);
+    }
+    return {
+      id: result.texture.id,
+      version: result.texture.version,
+      tile: result.tile
+    };
+  }
+}
+
+/**
+ * @deprecated
+ * Helper method that will position an object directly on the ground.
+ *
+ * @param {TiledGeometryLayer} layer - The tile layer owning the elevation
+ * textures we're going to query. This is typically a `GlobeLayer` or
+ * `PlanarLayer` (accessible through `view.tileLayer`).
+ * @param {string} crs - The CRS used by the object coordinates. You
+ * probably want to use `view.referenceCRS` here.
+ * @param {Object3D} obj - the object we want to modify.
+ * @param {Object} options
+ * @param {number} [options.method=FAST_READ_Z] - There are two available methods:
+ * `FAST_READ_Z` (default) or `PRECISE_READ_Z`. The first one is faster,
+ * while the second one is slower but gives better precision.
+ * @param {boolean} options.modifyGeometry - if unset/false, this function
+ * will modify object.position. If true, it will modify
+ * `obj.geometry.vertices` or `obj.geometry.attributes.position`.
+ * @param {TileMesh[]} [tileHint] - Optional array of tiles to speed up the
+ * process. You can give candidates tiles likely to contain `coord`.
+ * Otherwise the lookup process starts from the root of `layer`.
+ *
+ * @return {boolean} true if successful, false if we couldn't lookup the elevation at the given coords
+ */
+function placeObjectOnGround(layer, crs, obj) {
+  let options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+  let tileHint = arguments.length > 4 ? arguments[4] : undefined;
+  console.warn('placeObjectOnGround has been deprecated because it needs review and test');
+  let tiles;
+  if (tileHint) {
+    tiles = tileHint.concat(layer.level0Nodes);
+  } else {
+    tiles = layer.level0Nodes;
+  }
+  if (!options.modifyGeometry) {
+    if (options.cache) {
+      options.cache.length = 1;
+    }
+    const matrices = {
+      worldFromLocal: obj.parent ? obj.parent.matrixWorld : undefined,
+      localFromWorld: obj.parent ? new THREE.Matrix4().copy(obj.parent.matrixWorld).invert() : undefined
+    };
+    const result = _updateVector3(layer, options.method || DEMUtils.FAST_READ_Z, tiles, crs, obj.position, options.offset || 0, matrices, undefined, options.cache ? options.cache[0] : undefined);
+    if (result) {
+      if (options.cache) {
+        options.cache[0] = result;
+      }
+      obj.updateMatrix();
+      obj.updateMatrixWorld();
+      return true;
+    }
+  } else {
+    const matrices = {
+      worldFromLocal: obj.matrixWorld,
+      localFromWorld: new THREE.Matrix4().copy(obj.matrixWorld).invert()
+    };
+    const geometry = obj.geometry;
+    if (geometry.vertices) {
+      if (options.cache) {
+        options.cache.length = geometry.vertices.length;
+      }
+      let success = true;
+      const coord = new Coordinates(crs);
+      for (let i = 0; i < geometry.vertices.length; i++) {
+        const cached = options.cache ? options.cache[i] : undefined;
+        const result = _updateVector3(layer, options.method || DEMUtils.FAST_READ_Z, tiles, crs, geometry.vertices[i], options.offset || 0, matrices, coord, cached);
+        if (options.cache) {
+          options.cache[i] = result;
+        }
+        if (!result) {
+          success = false;
+        }
+      }
+      geometry.verticesNeedUpdate = true;
+      return success;
+    } else if (geometry.isBufferGeometry) {
+      if (options.cache) {
+        options.cache.length = geometry.attributes.position.count;
+      }
+      let success = true;
+      const tmp = new THREE.Vector3();
+      const coord = new Coordinates(crs);
+      for (let i = 0; i < geometry.attributes.position.count; i++) {
+        const cached = options.cache ? options.cache[i] : undefined;
+        tmp.fromBufferAttribute(geometry.attributes.position, i);
+        const prev = tmp.z;
+        const result = _updateVector3(layer, options.method || DEMUtils.FAST_READ_Z, tiles, crs, tmp, options.offset || 0, matrices, coord, cached);
+        if (options.cache) {
+          options.cache[i] = result;
+        }
+        if (!result) {
+          success = false;
+        }
+        if (prev != tmp.z) {
+          geometry.attributes.position.needsUpdate = true;
+        }
+        geometry.attributes.position.setXYZ(i, tmp.x, tmp.y, tmp.z);
+      }
+      return success;
+    }
+  }
+}
+export default placeObjectOnGround;

package/lib/Worker/LASLoaderWorker.js

@@ -0,0 +1,19 @@
+import { expose, Transfer } from 'threads/worker';
+import LASLoader from "../Loader/LASLoader.js";
+const loader = new LASLoader();
+function transferable(attributes) {
+  return Object.values(attributes).filter(ArrayBuffer.isView).map(a => a.buffer);
+}
+expose({
+  lazPerf(path) {
+    loader.lazPerf = path;
+  },
+  async parseChunk(data, options) {
+    const result = await loader.parseChunk(data, options);
+    return Transfer(result, transferable(result.attributes));
+  },
+  async parseFile(data, options) {
+    const result = await loader.parseFile(data, options);
+    return Transfer(result, transferable(result.attributes));
+  }
+});

package/lib/Worker/Potree2Worker.js

@@ -0,0 +1,21 @@
+import load from "../Loader/Potree2Loader.js";
+import loadBrotli from "../Loader/Potree2BrotliLoader.js";
+import { expose, Transfer } from 'threads/worker';
+function transfer(buffer, data) {
+  const transferables = [];
+  Object.keys(data.attributeBuffers).forEach(property => {
+    transferables.push(data.attributeBuffers[property].buffer);
+  });
+  transferables.push(buffer);
+  return transferables;
+}
+expose({
+  async parse(buffer, options) {
+    const data = await load(buffer, options);
+    return Transfer(data, transfer(buffer, data));
+  },
+  async parseBrotli(buffer, options) {
+    const data = await loadBrotli(buffer, options);
+    return Transfer(data, transfer(buffer, data));
+  }
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "itowns",
-  "version": "2.45.1-next.0",
+  "version": "2.45.1-next.1",
   "description": "A JS/WebGL framework for 3D geospatial data visualization",
   "type": "module",
   "main": "lib/Main.js",
@@ -48,7 +48,7 @@
     "url": "https://github.com/iTowns/itowns/issues"
   },
   "dependencies": {
-    "@itowns/geographic": "^2.45.1-next.0",
+    "@itowns/geographic": "^2.45.1-next.1",
     "@mapbox/vector-tile": "^2.0.3",
     "@maplibre/maplibre-gl-style-spec": "^22.0.0",
     "@tmcw/togeojson": "^5.8.1",