@vcmap/core 5.0.0-rc.3 → 5.0.0-rc.30

package/src/vcs/vcm/layer/vectorHelpers.js

@@ -1,206 +0,0 @@
-import { unByKey } from 'ol/Observable.js';
-import Feature from 'ol/Feature.js';
-import GeometryType from 'ol/geom/GeometryType.js';
-import { HeightReference } from '@vcmap/cesium';
-import { FeatureVisibilityAction } from './featureVisibility.js';
-import Projection from '../util/projection.js';
-import { getHeightInfo } from '../util/featureconverter/featureconverterHelper.js';
-import { getFlatCoordinatesFromGeometry } from '../util/geometryHelpers.js';
-import { createOrUpdateFromGeometry, createOrUpdateFromHeightInfo } from '../util/featureconverter/extent3d.js';
-
-/**
- * Added to ol.source.Vector to determine, when the source has last had an update to its features visibility.
- * @type {symbol}
- */
-export const fvLastUpdated = Symbol('FVlastUpdated');
-
-/**
- * Added to ol.source.Vector to determine, when the source has last had an update to its features global visibility.
- * @type {symbol}
- */
-export const globalHiderLastUpdated = Symbol('GlobalHiderLastUpdated');
-
-/**
- * @param {import("@vcmap/core").FeatureVisibility} featureVisibility
- * @param {import("ol/source").Vector<import("ol/geom/Geometry").default>} source
- */
-export function updateFeatureVisibility(featureVisibility, source) {
-  Object.keys(featureVisibility.highlightedObjects)
-    .forEach((id) => {
-      const feat = source.getFeatureById(id);
-      if (feat && !featureVisibility.hasHighlightFeature(id, feat)) {
-        featureVisibility.addHighlightFeature(id, feat);
-      }
-    });
-
-  Object.keys(featureVisibility.hiddenObjects)
-    .forEach((id) => {
-      const feat = source.getFeatureById(id);
-      if (feat && !featureVisibility.hasHiddenFeature(id, feat)) {
-        featureVisibility.addHiddenFeature(id, feat);
-      }
-    });
-  source[fvLastUpdated] = Date.now();
-}
-
-/**
- * @param {import("@vcmap/core").GlobalHider} globalHider
- * @param {import("ol/source").Vector<import("ol/geom/Geometry").default>} source
- */
-export function updateGlobalHider(globalHider, source) {
-  Object.keys(globalHider.hiddenObjects)
-    .forEach((id) => {
-      const feat = source.getFeatureById(id);
-      if (feat && !globalHider.hasFeature(id, feat)) {
-        globalHider.addFeature(id, feat);
-      }
-    });
-  source[globalHiderLastUpdated] = Date.now();
-}
-
-/**
- * @param {import("@vcmap/core").FeatureVisibility} featureVisibility
- * @param {import("ol/source").Vector<import("ol/geom/Geometry").default>} source
- * @param {import("@vcmap/core").GlobalHider} globalHider
- * @returns {Array<Function>}
- */
-export function synchronizeFeatureVisibilityWithSource(featureVisibility, source, globalHider) {
-  const sourceListener = source.on('addfeature', ({ feature }) => {
-    const id = feature.getId();
-    if (featureVisibility.highlightedObjects[id]) {
-      featureVisibility.addHighlightFeature(id, feature);
-    }
-
-    if (featureVisibility.hiddenObjects[id]) {
-      featureVisibility.addHiddenFeature(id, feature);
-    }
-
-    if (globalHider.hiddenObjects[id]) {
-      globalHider.addFeature(id, feature);
-    }
-    const now = Date.now();
-    source[fvLastUpdated] = now;
-    source[globalHiderLastUpdated] = now;
-  });
-
-  if (!source[fvLastUpdated] || source[fvLastUpdated] < featureVisibility.lastUpdated) {
-    updateFeatureVisibility(featureVisibility, source);
-  }
-
-  if (!source[globalHiderLastUpdated] || source[globalHiderLastUpdated] < featureVisibility.lastUpdated) {
-    updateGlobalHider(globalHider, source);
-  }
-
-  return [
-    featureVisibility.changed.addEventListener(({ action, ids }) => {
-      if (action === FeatureVisibilityAction.HIGHLIGHT) {
-        ids.forEach((id) => {
-          const feat = source.getFeatureById(id);
-          if (feat) {
-            featureVisibility.addHighlightFeature(id, feat);
-          }
-        });
-        source[fvLastUpdated] = Date.now();
-      } else if (action === FeatureVisibilityAction.HIDE) {
-        ids.forEach((id) => {
-          const feat = source.getFeatureById(id);
-          if (feat) {
-            featureVisibility.addHiddenFeature(id, feat);
-          }
-        });
-        source[fvLastUpdated] = Date.now();
-      }
-    }),
-    globalHider.changed.addEventListener(({ action, ids }) => {
-      if (action === FeatureVisibilityAction.HIDE) {
-        ids.forEach((id) => {
-          const feat = source.getFeatureById(id);
-          if (feat) {
-            globalHider.addFeature(id, feat);
-          }
-        });
-        source[globalHiderLastUpdated] = Date.now();
-      }
-    }),
-    () => { unByKey(sourceListener); },
-  ];
-}
-
-/**
- * @param {VectorClickedObject} object
- * @param {import("@vcmap/core").Vector|import("@vcmap/core").VectorTile} layer
- * @returns {?GenericFeature}
- */
-export function getGenericFeatureFromClickedObject(object, layer) {
-  if (!(object instanceof Feature)) {
-    return null;
-  }
-  const attributes = object.getProperties();
-  delete attributes[object.getGeometryName()];
-
-  const { clickedPosition } = object;
-  if (!clickedPosition) {
-    return null;
-  }
-  let { latitude, longitude } = clickedPosition;
-  const geometry = object.getGeometry();
-  let heightOffset = clickedPosition.height;
-  let calculateHeight = !heightOffset;
-  if (!geometry) {
-    calculateHeight = false; // we cannot calculate the height without geometry;
-  }
-
-  let relativeToGround = !heightOffset;
-  // Edge Case ClickedPosition is next to the feature and Feature got detected in clickToleranz.
-  // if the clicked Position does not intersect the feature the closestPoint will be used.
-  // also if the clickedPosition is not on the Feature we do not trust the Height Value;
-  const mercatorPoint =
-    Projection.wgs84ToMercator([clickedPosition.longitude, clickedPosition.latitude, clickedPosition.height]);
-  if (geometry && !geometry.intersectsCoordinate(mercatorPoint)) {
-    const closestPoint = geometry.getClosestPoint(mercatorPoint);
-    [longitude, latitude] = Projection.mercatorToWgs84(closestPoint);
-    calculateHeight = true;
-  }
-
-  // edge case oblique in this case we do get a height value but not of the feature but the underlying terrain.
-  // this is necessary to calculate the correct position of the balloon
-
-  // if we do not have a height value from the clickedPosition we calculate the height based in the feature;
-  if (calculateHeight) {
-    const coordinates = getFlatCoordinatesFromGeometry(geometry);
-    const heightInfo = getHeightInfo(object, layer.vectorProperties, coordinates);
-    if (heightInfo.perPositionHeight || heightInfo.extruded) {
-      const extent = createOrUpdateFromGeometry(geometry);
-      createOrUpdateFromHeightInfo(heightInfo, extent);
-      heightOffset = extent[5];
-    }
-    // edge case points are rendered depending on the terrain, so we set relativeToGround to true.
-    // In this case the heightAboveGroundAdjustment is also just an Offset.
-    if (
-      !heightInfo.extruded &&
-      (geometry.getType() === GeometryType.POINT || geometry.getType() === GeometryType.MULTI_POINT) &&
-      (
-        heightInfo.heightReference === HeightReference.RELATIVE_TO_GROUND ||
-        heightInfo.heightReference === HeightReference.CLAMP_TO_GROUND)
-    ) {
-      heightOffset = heightInfo.heightAboveGroundAdjustment;
-      relativeToGround = true;
-    } else {
-      heightOffset += heightInfo.heightAboveGroundAdjustment;
-    }
-
-    // if we have to calculate the height we have to take heightAboveGround into account
-  }
-
-  delete attributes.clickedPosition;
-  heightOffset = Number.isFinite(heightOffset) ? heightOffset : 0;
-  return {
-    layerName: layer.name,
-    layerClass: layer.className,
-    attributes: { ...layer.genericFeatureProperties, ...attributes },
-    longitude,
-    latitude,
-    height: heightOffset + layer.balloonHeightOffset,
-    relativeToGround,
-  };
-}

package/src/vcs/vcm/util/dateTime.js

@@ -1,60 +0,0 @@
-/**
- * @param {Date} date
- * @param {string=} locale
- * @returns {string}
- */
-export function getShortLocaleDate(date, locale) {
-  // dateStyle is not within the standard yet
-  // @ts-ignore
-  return new Intl.DateTimeFormat(locale, { dateStyle: 'short' }).format(date);
-}
-
-/**
- * @param {Date} date
- * @param {string=} locale
- * @returns {string}
- */
-export function getShortLocaleTime(date, locale) {
-  // timeStyle is not within the standard yet
-  // @ts-ignore
-  return new Intl.DateTimeFormat(locale, { timeStyle: 'short' }).format(date);
-}
-
-/**
- * @param {Date} date
- * @returns {string}
- */
-export function getISODateString(date) {
-  const month = date.getMonth() + 1;
-  const day = date.getDate();
-  return `${date.getFullYear()}-${month > 9 ? '' : 0}${month}-${day > 9 ? '' : 0}${day}`;
-}
-
-/**
- * @param {Date} date
- * @returns {number}
- */
-export function getDayOfYear(date) {
-  const start = new Date(date.getFullYear(), 0, 0);
-  // TS cant handle date manipulation
-  // @ts-ignore
-  const diff = (date - start) + ((start.getTimezoneOffset() - date.getTimezoneOffset()) * 60 * 1000);
-  const oneDay = 1000 * 60 * 60 * 24;
-  return Math.floor(diff / oneDay);
-}
-
-/**
- * @param {Date} date
- * @returns {boolean}
- */
-export function isLeapYear(date) {
-  const currentYear = date.getFullYear();
-  if (currentYear % 4 !== 0) {
-    return false;
-  } else if (currentYear % 100 !== 0) {
-    return true;
-  } else if (currentYear % 400 !== 0) {
-    return false;
-  }
-  return true;
-}

package/src/vcs/vcm/util/featureProvider/featureProviderHelpers.js

@@ -1,51 +0,0 @@
-import { getCenter } from 'ol/extent.js';
-import Projection from '../projection.js';
-import { createOrUpdateFromGeometry } from '../featureconverter/extent3d.js';
-
-/**
- * @param {VectorClickedObject} feature
- * @param {import("@vcmap/core").Layer} layer
- * @returns {?GenericFeature}
- */
-// eslint-disable-next-line import/prefer-default-export
-export function getGenericFeatureFromProvidedFeature(feature, layer) {
-  const attributes = feature.getProperties();
-  delete attributes[feature.getGeometryName()];
-
-  let { clickedPosition } = feature;
-  const geometry = feature.getGeometry();
-  const isModel = feature.get('olcs_modelUrl');
-  if (
-    geometry &&
-    (
-      (geometry.getType() === 'Point' && !isModel) ||
-      (clickedPosition && !clickedPosition.exactPosition) ||
-      (!clickedPosition && geometry)
-    )
-  ) {
-    const center = getCenter(geometry.getExtent());
-    if (center) {
-      Projection.mercatorToWgs84(center, true);
-      clickedPosition = { longitude: center[0], latitude: center[1] };
-    }
-  }
-
-  let heightOffset = clickedPosition.height;
-  if (!isModel) {
-    const extent = createOrUpdateFromGeometry(geometry);
-    const max = Number.isFinite(extent[5]) ? extent[5] : 0;
-    heightOffset = max;
-  }
-  const relativeToGround = !isModel && feature.get('olcs_altitudeMode') === 'relativeToGround';
-
-  delete attributes.clickedPosition;
-  return {
-    layerName: layer.name,
-    layerClass: layer.className,
-    attributes,
-    longitude: clickedPosition.longitude,
-    latitude: clickedPosition.latitude,
-    height: heightOffset,
-    relativeToGround,
-  };
-}

package/src/vcs/vcm/util/featureconverter/extent3d.js

@@ -1,154 +0,0 @@
-import GeometryType from 'ol/geom/GeometryType.js';
-
-/**
- * Create an empty extent.
- * @returns {Array<number>} Empty extent.
- */
-export function createEmpty3D() {
-  return [Infinity, Infinity, Infinity, -Infinity, -Infinity, -Infinity];
-}
-
-/**
- * Create a new extent or update the provided extent.
- * @param {number} minX Minimum X.
- * @param {number} minY Minimum Y.
- * @param {number} minZ Minimum Z.
- * @param {number} maxX Maximum X.
- * @param {number} maxY Maximum Y.
- * @param {number} maxZ Maximum Z.
- * @param {Array<number>=} optExtent Destination extent.
- * @returns {Array<number>} Extent.
- */
-export function createOrUpdate3D(minX, minY, minZ, maxX, maxY, maxZ, optExtent) {
-  if (optExtent) {
-    optExtent[0] = minX;
-    optExtent[1] = minY;
-    optExtent[2] = minZ;
-    optExtent[3] = maxX;
-    optExtent[4] = maxY;
-    optExtent[5] = maxZ;
-    return optExtent;
-  } else {
-    return [minX, minY, minZ, maxX, maxY, maxZ];
-  }
-}
-
-/**
- * @param {Array<number>} extent Extent.
- * @param {number} x X.
- * @param {number} y Y.
- * @param {number} z Z.
- */
-export function extendXYZ(extent, x, y, z) {
-  extent[0] = Math.min(extent[0], x);
-  extent[1] = Math.min(extent[1], y);
-  extent[2] = Math.min(extent[2], z);
-  extent[3] = Math.max(extent[3], x);
-  extent[4] = Math.max(extent[4], y);
-  extent[5] = Math.max(extent[5], z);
-}
-/**
- * @param {Array<number>} extent Extent.
- * @param {number} x X.
- * @param {number} y Y.
- */
-export function extendXY(extent, x, y) {
-  extent[0] = Math.min(extent[0], x);
-  extent[1] = Math.min(extent[1], y);
-  extent[3] = Math.max(extent[3], x);
-  extent[4] = Math.max(extent[4], y);
-}
-
-/**
- * @param {Array<number>} extent Extent.
- * @param {number} z Z.
- */
-export function extendZ(extent, z) {
-  extent[2] = Math.min(extent[2], z);
-  extent[5] = Math.max(extent[5], z);
-}
-
-/**
- * @param {Array<number>} extent Extent.
- * @param {Array<number>} flatCoordinates Flat coordinates.
- * @param {number} stride Stride.
- * @returns {Array<number>} Extent.
- */
-export function extendFlatCoordinates(
-  extent,
-  flatCoordinates,
-  stride,
-) {
-  const { length } = flatCoordinates;
-  for (let offset = 0; offset < length; offset += stride) {
-    if (stride > 2) {
-      extendXYZ(extent, flatCoordinates[offset], flatCoordinates[offset + 1], flatCoordinates[offset + 2]);
-    } else {
-      extendXY(extent, flatCoordinates[offset], flatCoordinates[offset + 1]);
-    }
-  }
-  return extent;
-}
-
-/**
- * @param {import("ol/geom/Geometry").default} geometry Geometry.
- * @param {Array<number>=} optExtent Extent.
- * @returns {Array<number>} Extent.
- */
-export function createOrUpdateFromGeometry(geometry, optExtent) {
-  const extent = optExtent || createEmpty3D();
-  if (geometry.getType() === GeometryType.GEOMETRY_COLLECTION) {
-    /** @type {import("ol/geom/GeometryCollection").default} */ (geometry)
-      .getGeometriesArray().forEach((geom) => { createOrUpdateFromGeometry(geom, extent); });
-  } else if (geometry.getType() === GeometryType.CIRCLE) {
-    const flatCoordinates = /** @type {import("ol/geom/Circle").default} */ (geometry).getFlatCoordinates();
-    const stride = /** @type {import("ol/geom/Circle").default} */ (geometry).getStride();
-    const radius = flatCoordinates[stride] - flatCoordinates[0];
-    extendXY(
-      extent,
-      flatCoordinates[0] - radius,
-      flatCoordinates[1] - radius,
-    );
-    extendXY(
-      extent,
-      flatCoordinates[0] + radius,
-      flatCoordinates[1] + radius,
-    );
-    if (stride > 2) {
-      extendZ(extent, flatCoordinates[2]);
-    }
-  } else {
-    const flatCoordinates = /** @type {import("ol/geom/SimpleGeometry").default} */ (geometry).getFlatCoordinates();
-    const stride = /** @type {import("ol/geom/SimpleGeometry").default} */ (geometry).getStride();
-    extendFlatCoordinates(extent, flatCoordinates, stride);
-  }
-  return extent;
-}
-
-/**
- * @param {VectorHeightInfo} heightInfo
- * @param {Array<number>} optExtent
- */
-export function createOrUpdateFromHeightInfo(heightInfo, optExtent) {
-  const extent = optExtent || createEmpty3D();
-  if (heightInfo.extruded) {
-    const calculatedFeatureMaxHeight =
-      heightInfo.groundLevel + heightInfo.storeyHeightsAboveGround.reduce((accumulator, currentValue) => {
-        return accumulator + currentValue;
-      }, 0);
-    extendZ(extent, calculatedFeatureMaxHeight);
-    const calculatedFeatureMinHeight =
-      heightInfo.groundLevel - heightInfo.storeyHeightsBelowGround.reduce((accumulator, currentValue) => {
-        return accumulator + currentValue;
-      }, 0);
-    extendZ(extent, calculatedFeatureMinHeight);
-  }
-}
-
-/**
- * @param {Array<number>} extent Extent.
- * @returns {import("ol/extent").Extent} Extent.
- */
-export function make2D(extent) {
-  return [extent[0], extent[1], extent[3], extent[4]];
-}

package/src/vcs/vcm/util/featureconverter/lineStringToCesium.js

@@ -1,171 +0,0 @@
-import { Cartesian3, WallGeometry, WallOutlineGeometry, GroundPolylineGeometry, PolylineGeometry } from '@vcmap/cesium';
-import GeometryType from 'ol/geom/GeometryType.js';
-import { parseNumber } from '@vcsuite/parsers';
-import Projection from '../projection.js';
-import { addPrimitivesToContext } from './featureconverterHelper.js';
-import { getFlatCoordinatesFromSimpleGeometry } from '../geometryHelpers.js';
-
-/**
- * @param {Object} options
- * @param {number} height
- * @param {boolean} perPositionHeight
- * @param {number=} extrudedHeight
- * @returns {Array<import("@vcmap/cesium").WallGeometry>}
- * @private
- */
-export function createSolidGeometries(options, height, perPositionHeight, extrudedHeight) {
-  return [WallGeometry.fromConstantHeights({
-    ...options,
-    maximumHeight: !perPositionHeight ? height : undefined,
-    minimumHeight: extrudedHeight,
-  })];
-}
-
-/**
- * @param {Object} options
- * @param {number} height
- * @param {boolean} perPositionHeight
- * @param {number=} extrudedHeight
- * @returns {Array<import("@vcmap/cesium").WallOutlineGeometry>}
- * @private
- */
-export function createOutlineGeometries(options, height, perPositionHeight, extrudedHeight) {
-  // maxium and minimum are flipped, to create the same perPositionHeight behaviour as in polygons
-  // WallGeometries extrudes down instead of up, so we switch the behaviour and extrude in the other direction
-  return [WallOutlineGeometry.fromConstantHeights({
-    ...options,
-    maximumHeight: !perPositionHeight ? height : undefined,
-    minimumHeight: extrudedHeight,
-  })];
-}
-
-/**
- * @param {Object} options
- * @param {number} height
- * @param {boolean} perPositionHeight
- * @returns {Array}
- * @private
- */
-// eslint-disable-next-line no-unused-vars
-export function createFillGeometries(options, height, perPositionHeight) {
-  return [];
-}
-
-
-/**
- * @param {Object} options
- * @param {import("ol/style/Style").default} style
- * @returns {Array<import("@vcmap/cesium").GroundPolylineGeometry>}
- * @private
- */
-export function createGroundLineGeometries(options, style) {
-  const width = parseNumber(style.getStroke().getWidth(), 1.0);
-  return [new GroundPolylineGeometry({
-    ...options,
-    width,
-  })];
-}
-
-/**
- * @param {Object} options
- * @param {import("ol/style/Style").default} style
- * @returns {Array<import("@vcmap/cesium").PolylineGeometry>}
- * @private
- */
-export function createLineGeometries(options, style) {
-  const width = parseNumber(style.getStroke().getWidth(), 1.0);
-  return [new PolylineGeometry({
-    ...options,
-    width,
-  })];
-}
-
-/**
- * extracts the center and radius from the CircleGeometry and converts it to Cartesian3/radius in m
- * @param {import("ol/geom/LineString").default} geometry
- * @param {number} positionHeightAdjustment
- * @returns {Object}
- * @private
- */
-export function getGeometryOptions(geometry, positionHeightAdjustment) {
-  const coords = geometry.getCoordinates();
-  const positions = coords.map((coord) => {
-    const wgs84Coords = Projection.mercatorToWgs84(coord);
-    if (wgs84Coords[2] != null) {
-      wgs84Coords[2] += positionHeightAdjustment;
-    }
-    return Cartesian3.fromDegrees(wgs84Coords[0], wgs84Coords[1], wgs84Coords[2]);
-  });
-  return { positions };
-}
-
-/**
- * @param {Array<import("ol/geom/LineString").default>} geometries
- * @returns {Array<import("ol/coordinate").Coordinate>}
- * @private
- */
-export function getCoordinates(geometries) {
-  const coordinates = [];
-  geometries.forEach((lineString) => {
-    coordinates.push(...getFlatCoordinatesFromSimpleGeometry(lineString));
-  });
-  return coordinates;
-}
-
-/**
- * @type {VectorGeometryFactoryType|null}
- */
-let geometryFactory = null;
-
-/**
- * @returns {VectorGeometryFactoryType}
- */
-function getGeometryFactory() {
-  if (!geometryFactory) {
-    geometryFactory = {
-      getCoordinates,
-      getGeometryOptions,
-      createSolidGeometries,
-      createOutlineGeometries,
-      createFillGeometries,
-      createGroundLineGeometries,
-      createLineGeometries,
-    };
-  }
-  return geometryFactory;
-}
-
-/**
- * validates if a lineString is renderable
- * @param {import("ol/geom/LineString").default} lineString
- * @returns {boolean}
- */
-export function validateLineString(lineString) {
-  if (lineString.getType() !== GeometryType.LINE_STRING) {
-    return false;
-  }
-  const flatCoordinates = lineString.getFlatCoordinates();
-  const minimumValues = lineString.getStride() * 2;
-  if (flatCoordinates && flatCoordinates.length >= minimumValues) {
-    return flatCoordinates.every(value => Number.isFinite(value));
-  }
-  return false;
-}
-
-/**
- * converts a linestring to a a cesium primitive, with optional labels
- * @param {import("ol").Feature<import("ol/geom/Geometry").default>} feature
- * @param {import("ol/style/Style").default} style
- * @param {Array<import("ol/geom/LineString").default>} geometries
- * @param {import("@vcmap/core").VectorProperties} vectorProperties
- * @param {import("@vcmap/cesium").Scene} scene
- * @param {import("@vcmap/core").VectorContext|import("@vcmap/core").ClusterContext} context
- */
-export default function lineStringToCesium(feature, style, geometries, vectorProperties, scene, context) {
-  if (!style.getFill() && !style.getStroke()) {
-    return;
-  }
-  const lineGeometryFactory = getGeometryFactory();
-  const validGeometries = geometries.filter(lineString => validateLineString(lineString));
-  addPrimitivesToContext(feature, style, validGeometries, vectorProperties, scene, lineGeometryFactory, context);
-}

package/src/vcs/vcm/util/locale.js

@@ -1,53 +0,0 @@
-import VcsEvent from '../event/vcsEvent.js';
-
-/**
- * @type {VcsEvent<string>}
- */
-let localeChangedEvent;
-
-/**
- * @returns {VcsEvent<string>}
- */
-export function getLocaleChangedEvent() {
-  if (!localeChangedEvent) {
-    localeChangedEvent = new VcsEvent();
-  }
-  return localeChangedEvent;
-}
-
-/**
- * returns the default browserLocale, if not possible 'en'
- * @returns {string}
- */
-export function detectBrowserLocale() {
-  if (navigator.language) {
-    const lang = navigator.language;
-    return lang.substring(0, 2);
-  }
-  return 'en';
-}
-
-/**
- * @type {string}
- */
-let currentLocale;
-
-/**
- * @returns {string}
- */
-export function getCurrentLocale() {
-  if (!currentLocale) {
-    currentLocale = detectBrowserLocale();
-  }
-  return currentLocale;
-}
-
-/**
- * @param {string} value
- */
-export function setCurrentLocale(value) {
-  if (typeof value === 'string') {
-    currentLocale = value;
-    getLocaleChangedEvent().raiseEvent(value);
-  }
-}