@guardian/interactive-component-library 0.2.0-rc1 → 0.2.0-rc2

package/dist/components/molecules/canvas-map/lib/styles/Stroke.js

@@ -0,0 +1,16 @@
+import { memoise } from "../util/memoise.js";
+import { toRgba } from "../util/toRgba.js";
+class Stroke {
+  constructor(options) {
+    this.color = (options == null ? void 0 : options.color) || "#121212";
+    this.width = (options == null ? void 0 : options.width) || 0.5;
+    this.opacity = (options == null ? void 0 : options.opacity) || 1;
+    this._getRgba = memoise(toRgba);
+  }
+  getRgba() {
+    return this._getRgba(this.color, this.opacity);
+  }
+}
+export {
+  Stroke
+};

package/dist/components/molecules/canvas-map/lib/styles/Style.d.ts

@@ -0,0 +1,24 @@
+/**
+ * A function that takes a {@link import("../Feature").Feature} and returns a {@link Style}
+ *
+ * @typedef {function(import("../Feature").Feature):(Style)} StyleFunction
+ */
+/**
+ * Class representing a style.
+ * @class
+ * @property {Object} properties - The properties of the style
+ * @property {Object} properties.stroke - The stroke color of the style
+ * @property {Object} properties.fill - The fill color of the style
+ * @property {Object} properties.text - The text color of the style
+ */
+export class Style {
+    constructor(properties: any);
+    stroke: any;
+    fill: any;
+    text: any;
+    clone(): Style;
+}
+/**
+ * A function that takes a {@link import ("../Feature").Feature} and returns a {@link Style}
+ */
+export type StyleFunction = (arg0: import('../Feature').Feature) => (Style);

package/dist/components/molecules/canvas-map/lib/styles/Style.js

@@ -0,0 +1,17 @@
+class Style {
+  constructor(properties) {
+    this.stroke = properties == null ? void 0 : properties.stroke;
+    this.fill = properties == null ? void 0 : properties.fill;
+    this.text = properties == null ? void 0 : properties.text;
+  }
+  clone() {
+    return new Style({
+      stroke: this.stroke,
+      fill: this.fill,
+      text: this.text
+    });
+  }
+}
+export {
+  Style
+};

package/dist/components/molecules/canvas-map/lib/styles/Text.d.ts

@@ -0,0 +1,10 @@
+export class Text {
+    constructor(options: any);
+    content: any;
+    fontFamily: any;
+    fontSize: any;
+    fontWeight: any;
+    lineHeight: any;
+    color: any;
+    textShadow: any;
+}

package/dist/components/molecules/canvas-map/lib/styles/Text.js

@@ -0,0 +1,14 @@
+class Text {
+  constructor(options) {
+    this.content = options == null ? void 0 : options.content;
+    this.fontFamily = (options == null ? void 0 : options.fontFamily) || "var(--text-sans)";
+    this.fontSize = (options == null ? void 0 : options.fontSize) || "17px";
+    this.fontWeight = (options == null ? void 0 : options.fontWeight) || "400";
+    this.lineHeight = (options == null ? void 0 : options.lineHeight) || 1.3;
+    this.color = (options == null ? void 0 : options.color) || "#121212";
+    this.textShadow = (options == null ? void 0 : options.textShadow) || "1px 1px 0px #f6f6f6, -1px -1px 0px #f6f6f6, -1px 1px 0px #f6f6f6, 1px -1px #f6f6f6";
+  }
+}
+export {
+  Text
+};

package/dist/components/molecules/canvas-map/lib/styles/index.d.ts

@@ -0,0 +1,4 @@
+export * from './Style';
+export * from './Stroke';
+export * from './Fill';
+export * from './Text';

package/dist/components/molecules/canvas-map/lib/util/array.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @param {Array<any>|Uint8ClampedArray} arr1 The first array to compare.
+ * @param {Array<any>|Uint8ClampedArray} arr2 The second array to compare.
+ * @return {boolean} Whether the two arrays are equal.
+ */
+export function arrayEquals(arr1: Array<any> | Uint8ClampedArray, arr2: Array<any> | Uint8ClampedArray): boolean;

package/dist/components/molecules/canvas-map/lib/util/array.js

@@ -0,0 +1,15 @@
+function arrayEquals(arr1, arr2) {
+  const len1 = arr1.length;
+  if (len1 !== arr2.length) {
+    return false;
+  }
+  for (let i = 0; i < len1; i++) {
+    if (arr1[i] !== arr2[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+export {
+  arrayEquals
+};

package/dist/components/molecules/canvas-map/lib/util/bboxFeature.d.ts

@@ -0,0 +1,8 @@
+export function bboxFeature(bounds: any): {
+    type: string;
+    properties: {};
+    geometry: {
+        coordinates: any[][][];
+        type: string;
+    };
+};

package/dist/components/molecules/canvas-map/lib/util/bboxFeature.js

@@ -0,0 +1,26 @@
+function bboxFeature(bounds) {
+  const minLon = bounds[0][0];
+  const minLat = bounds[0][1];
+  const maxLon = bounds[1][0];
+  const maxLat = bounds[1][1];
+  const feature = {
+    type: "Feature",
+    properties: {},
+    geometry: {
+      coordinates: [
+        [
+          [minLon, maxLat],
+          [maxLon, maxLat],
+          [maxLon, minLat],
+          [minLon, minLat],
+          [minLon, maxLat]
+        ]
+      ],
+      type: "Polygon"
+    }
+  };
+  return feature;
+}
+export {
+  bboxFeature
+};

package/dist/components/molecules/canvas-map/lib/util/debug.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @function
+ * @param {Array<import('../geometry').Geometry>} geometries
+ */
+export function validateGeometries(geometries: Array<import('../geometry').Geometry>): void;
+/**
+ *
+ * @param {import('../Feature').Feature | Object} feature - The feature you want to inspect
+ * @returns {string} URL to geojson.io, with feature embedded
+ */
+export function generateDebugUrl(feature: import('../Feature').Feature | any, convertToGeoJSON?: boolean): string;

package/dist/components/molecules/canvas-map/lib/util/debug.js

@@ -0,0 +1,27 @@
+function validateGeometries(geometries) {
+  if (!Array.isArray(geometries)) {
+    throw new Error("geometries must be an array");
+  }
+  geometries.forEach((geometry) => {
+    var _a;
+    if (!geometry.type) {
+      throw new Error("geometry must have a type");
+    }
+    if (!((_a = geometry.coordinates) == null ? void 0 : _a.length)) {
+      throw new Error("geometry must have coordinates");
+    }
+  });
+}
+function generateDebugUrl(feature, convertToGeoJSON = true) {
+  const featureGeoJSON = convertToGeoJSON ? feature.getGeoJSON() : feature;
+  const featureCollection = {
+    type: "FeatureCollection",
+    features: [featureGeoJSON]
+  };
+  const jsonString = encodeURIComponent(JSON.stringify(featureCollection));
+  return `https://geojson.io/#data=data:application/json,${jsonString}`;
+}
+export {
+  generateDebugUrl,
+  validateGeometries
+};

package/dist/components/molecules/canvas-map/lib/util/deflate.d.ts

@@ -0,0 +1,36 @@
+/**
+ * @module ol/geom/flat/deflate
+ */
+/**
+ * @param {Array<number>} flatCoordinates Flat coordinates.
+ * @param {number} offset Offset.
+ * @param {import("../../coordinate.js").Coordinate} coordinate Coordinate.
+ * @return {number} offset Offset.
+ */
+export function deflateCoordinate(flatCoordinates: Array<number>, offset: number, coordinate: any): number;
+/**
+ * @param {Array<number>} flatCoordinates Flat coordinates.
+ * @param {number} offset Offset.
+ * @param {Array<import("../../coordinate.js").Coordinate>} coordinates Coordinates.
+ * @param {number} stride Stride.
+ * @return {number} offset Offset.
+ */
+export function deflateCoordinates(flatCoordinates: Array<number>, offset: number, coordinates: Array<any>, stride: number): number;
+/**
+ * @param {Array<number>} flatCoordinates Flat coordinates.
+ * @param {number} offset Offset.
+ * @param {Array<Array<import("../../coordinate.js").Coordinate>>} coordinatess Coordinatess.
+ * @param {number} stride Stride.
+ * @param {Array<number>} [ends] Ends.
+ * @return {Array<number>} Ends.
+ */
+export function deflateCoordinatesArray(flatCoordinates: Array<number>, offset: number, coordinatess: Array<Array<any>>, stride: number, ends?: Array<number>): Array<number>;
+/**
+ * @param {Array<number>} flatCoordinates Flat coordinates.
+ * @param {number} offset Offset.
+ * @param {Array<Array<Array<import("../../coordinate.js").Coordinate>>>} coordinatesss Coordinatesss.
+ * @param {number} stride Stride.
+ * @param {Array<Array<number>>} [endss] Endss.
+ * @return {Array<Array<number>>} Endss.
+ */
+export function deflateMultiCoordinatesArray(flatCoordinates: Array<number>, offset: number, coordinatesss: Array<Array<Array<any>>>, stride: number, endss?: Array<Array<number>>): Array<Array<number>>;

package/dist/components/molecules/canvas-map/lib/util/distance.d.ts

@@ -0,0 +1 @@
+export function haversineDistance(lat1: any, lon1: any, lat2: any, lon2: any): number;

package/dist/components/molecules/canvas-map/lib/util/distance.js

@@ -0,0 +1,12 @@
+function haversineDistance(lat1, lon1, lat2, lon2) {
+  const R = 6371e3;
+  const toRadians = (degrees) => degrees * Math.PI / 180;
+  const dLat = toRadians(lat2 - lat1);
+  const dLon = toRadians(lon2 - lon1);
+  const a = Math.sin(dLat / 2) * Math.sin(dLat / 2) + Math.cos(toRadians(lat1)) * Math.cos(toRadians(lat2)) * Math.sin(dLon / 2) * Math.sin(dLon / 2);
+  const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+  return R * c;
+}
+export {
+  haversineDistance
+};

package/dist/components/molecules/canvas-map/lib/util/dom.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Transform the children of a parent node so they match the
+ * provided list of children.  This function aims to efficiently
+ * remove, add, and reorder child nodes while maintaining a simple
+ * implementation (it is not guaranteed to minimize DOM operations).
+ * @param {Node} node The parent node whose children need reworking.
+ * @param {Array<Node>} children The desired children.
+ */
+export function replaceChildren(node: Node, children: Array<Node>): void;

package/dist/components/molecules/canvas-map/lib/util/dom.js

@@ -0,0 +1,28 @@
+function replaceChildren(node, children) {
+  const oldChildren = node.childNodes;
+  let done = false;
+  for (let i = 0; !done; ++i) {
+    const oldChild = oldChildren[i];
+    const newChild = children[i];
+    if (!oldChild && !newChild) {
+      done = true;
+      break;
+    }
+    if (oldChild === newChild) {
+      continue;
+    }
+    if (!oldChild) {
+      node.appendChild(newChild);
+      continue;
+    }
+    if (!newChild) {
+      node.removeChild(oldChild);
+      --i;
+      continue;
+    }
+    node.insertBefore(newChild, oldChild);
+  }
+}
+export {
+  replaceChildren
+};

package/dist/components/molecules/canvas-map/lib/util/extent.d.ts

@@ -0,0 +1,21 @@
+export function extentForCoordinates(coordinates: any): number[];
+export function combineExtents(extent1: any, extent2: any): number[];
+/**
+ * Check if the passed coordinate is contained or on the edge of the extent.
+ *
+ * @param {Extent} extent Extent.
+ * @param {import("./coordinate.js").Coordinate} coordinate Coordinate.
+ * @return {boolean} The coordinate is contained in the extent.
+ * @api
+ */
+export function containsCoordinate(extent: Extent, coordinate: any): boolean;
+/**
+ * Check if the passed coordinate is contained or on the edge of the extent.
+ *
+ * @param {Extent} extent Extent.
+ * @param {number} x X coordinate.
+ * @param {number} y Y coordinate.
+ * @return {boolean} The x, y values are contained in the extent.
+ * @api
+ */
+export function containsXY(extent: Extent, x: number, y: number): boolean;

package/dist/components/molecules/canvas-map/lib/util/extent.js

@@ -0,0 +1,38 @@
+function extentForCoordinates(coordinates) {
+  let minX = Infinity, minY = Infinity;
+  let maxX = -Infinity, maxY = -Infinity;
+  for (const coordinate of coordinates) {
+    if (coordinate[0] < minX) {
+      minX = coordinate[0];
+    }
+    if (coordinate[0] > maxX) {
+      maxX = coordinate[0];
+    }
+    if (coordinate[1] < minY) {
+      minY = coordinate[1];
+    }
+    if (coordinate[1] > maxY) {
+      maxY = coordinate[1];
+    }
+  }
+  return [minX, minY, maxX, maxY];
+}
+function combineExtents(extent1, extent2) {
+  const minX = Math.min(extent1[0], extent2[0]);
+  const minY = Math.min(extent1[1], extent2[1]);
+  const maxX = Math.max(extent1[2], extent2[2]);
+  const maxY = Math.max(extent1[3], extent2[3]);
+  return [minX, minY, maxX, maxY];
+}
+function containsCoordinate(extent, coordinate) {
+  return containsXY(extent, coordinate[0], coordinate[1]);
+}
+function containsXY(extent, x, y) {
+  return extent[0] <= x && x <= extent[2] && extent[1] <= y && y <= extent[3];
+}
+export {
+  combineExtents,
+  containsCoordinate,
+  containsXY,
+  extentForCoordinates
+};

package/dist/components/molecules/canvas-map/lib/util/memoise.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Wraps a function in another function that remembers the last return.  If the
+ * returned function is called twice in a row with the same arguments and the same
+ * this object, it will return the value from the first call in the second call.
+ * @function
+ * @template ReturnType
+ * @param {function(...any): ReturnType} fn - The function to memoise
+ * @returns {function(...any): ReturnType} The memoised function
+ */
+export function memoise<ReturnType>(fn: (...args: any[]) => ReturnType): (...args: any[]) => ReturnType;

package/dist/components/molecules/canvas-map/lib/util/memoise.js

@@ -0,0 +1,20 @@
+import { arrayEquals } from "./array.js";
+function memoise(fn) {
+  let called = false;
+  let lastResult;
+  let lastArgs;
+  let lastThis;
+  return function(...args) {
+    const nextArgs = Array.prototype.slice.call(args);
+    if (!called || this !== lastThis || !arrayEquals(nextArgs, lastArgs)) {
+      called = true;
+      lastThis = this;
+      lastArgs = nextArgs;
+      lastResult = fn.apply(this, args);
+    }
+    return lastResult;
+  };
+}
+export {
+  memoise
+};

package/dist/components/molecules/canvas-map/lib/util/resolution.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Get map resolution
+ *
+ * @param {Extent} extent Geographical extent: [ lonMin, latMin, lonMax, latMax ]
+ * @param {size} viewportSize Viewport size: [ width, height ]
+ * @return {number} Map resolution (horizontal)
+ * @api
+ */
+export function resolutionForExtent(extent: Extent, viewportSize: size): number;

package/dist/components/molecules/canvas-map/lib/util/resolution.js

@@ -0,0 +1,11 @@
+import { haversineDistance } from "./distance.js";
+function resolutionForExtent(extent, viewportSize) {
+  const [lonMin, latMin, lonMax, latMax] = extent;
+  const latMid = (latMin + latMax) / 2;
+  const distance = haversineDistance(latMid, lonMin, latMid, lonMax);
+  const resolution = distance / viewportSize[0];
+  return resolution;
+}
+export {
+  resolutionForExtent
+};

package/dist/components/molecules/canvas-map/lib/util/simplify.d.ts

@@ -0,0 +1,114 @@
+/**
+ * @param {Array<number>} flatCoordinates Flat coordinates.
+ * @param {number} offset Offset.
+ * @param {number} end End.
+ * @param {number} stride Stride.
+ * @param {number} squaredTolerance Squared tolerance.
+ * @param {boolean} highQuality Highest quality.
+ * @param {Array<number>} [simplifiedFlatCoordinates] Simplified flat
+ *     coordinates.
+ * @return {Array<number>} Simplified line string.
+ */
+export function simplifyLineString(flatCoordinates: Array<number>, offset: number, end: number, stride: number, squaredTolerance: number, highQuality: boolean, simplifiedFlatCoordinates?: Array<number>): Array<number>;
+/**
+ * @param {Array<number>} flatCoordinates Flat coordinates.
+ * @param {number} offset Offset.
+ * @param {number} end End.
+ * @param {number} stride Stride.
+ * @param {number} squaredTolerance Squared tolerance.
+ * @param {Array<number>} simplifiedFlatCoordinates Simplified flat
+ *     coordinates.
+ * @param {number} simplifiedOffset Simplified offset.
+ * @return {number} Simplified offset.
+ */
+export function douglasPeucker(flatCoordinates: Array<number>, offset: number, end: number, stride: number, squaredTolerance: number, simplifiedFlatCoordinates: Array<number>, simplifiedOffset: number): number;
+/**
+ * @param {Array<number>} flatCoordinates Flat coordinates.
+ * @param {number} offset Offset.
+ * @param {Array<number>} ends Ends.
+ * @param {number} stride Stride.
+ * @param {number} squaredTolerance Squared tolerance.
+ * @param {Array<number>} simplifiedFlatCoordinates Simplified flat
+ *     coordinates.
+ * @param {number} simplifiedOffset Simplified offset.
+ * @param {Array<number>} simplifiedEnds Simplified ends.
+ * @return {number} Simplified offset.
+ */
+export function douglasPeuckerArray(flatCoordinates: Array<number>, offset: number, ends: Array<number>, stride: number, squaredTolerance: number, simplifiedFlatCoordinates: Array<number>, simplifiedOffset: number, simplifiedEnds: Array<number>): number;
+/**
+ * @param {Array<number>} flatCoordinates Flat coordinates.
+ * @param {number} offset Offset.
+ * @param {Array<Array<number>>} endss Endss.
+ * @param {number} stride Stride.
+ * @param {number} squaredTolerance Squared tolerance.
+ * @param {Array<number>} simplifiedFlatCoordinates Simplified flat
+ *     coordinates.
+ * @param {number} simplifiedOffset Simplified offset.
+ * @param {Array<Array<number>>} simplifiedEndss Simplified endss.
+ * @return {number} Simplified offset.
+ */
+export function douglasPeuckerMultiArray(flatCoordinates: Array<number>, offset: number, endss: Array<Array<number>>, stride: number, squaredTolerance: number, simplifiedFlatCoordinates: Array<number>, simplifiedOffset: number, simplifiedEndss: Array<Array<number>>): number;
+/**
+ * @param {Array<number>} flatCoordinates Flat coordinates.
+ * @param {number} offset Offset.
+ * @param {number} end End.
+ * @param {number} stride Stride.
+ * @param {number} squaredTolerance Squared tolerance.
+ * @param {Array<number>} simplifiedFlatCoordinates Simplified flat
+ *     coordinates.
+ * @param {number} simplifiedOffset Simplified offset.
+ * @return {number} Simplified offset.
+ */
+export function radialDistance(flatCoordinates: Array<number>, offset: number, end: number, stride: number, squaredTolerance: number, simplifiedFlatCoordinates: Array<number>, simplifiedOffset: number): number;
+/**
+ * @param {number} value Value.
+ * @param {number} tolerance Tolerance.
+ * @return {number} Rounded value.
+ */
+export function snap(value: number, tolerance: number): number;
+/**
+ * Simplifies a line string using an algorithm designed by Tim Schaub.
+ * Coordinates are snapped to the nearest value in a virtual grid and
+ * consecutive duplicate coordinates are discarded.  This effectively preserves
+ * topology as the simplification of any subsection of a line string is
+ * independent of the rest of the line string.  This means that, for example,
+ * the common edge between two polygons will be simplified to the same line
+ * string independently in both polygons.  This implementation uses a single
+ * pass over the coordinates and eliminates intermediate collinear points.
+ * @param {Array<number>} flatCoordinates Flat coordinates.
+ * @param {number} offset Offset.
+ * @param {number} end End.
+ * @param {number} stride Stride.
+ * @param {number} tolerance Tolerance.
+ * @param {Array<number>} simplifiedFlatCoordinates Simplified flat
+ *     coordinates.
+ * @param {number} simplifiedOffset Simplified offset.
+ * @return {number} Simplified offset.
+ */
+export function quantize(flatCoordinates: Array<number>, offset: number, end: number, stride: number, tolerance: number, simplifiedFlatCoordinates: Array<number>, simplifiedOffset: number): number;
+/**
+ * @param {Array<number>} flatCoordinates Flat coordinates.
+ * @param {number} offset Offset.
+ * @param {Array<number>} ends Ends.
+ * @param {number} stride Stride.
+ * @param {number} tolerance Tolerance.
+ * @param {Array<number>} simplifiedFlatCoordinates Simplified flat
+ *     coordinates.
+ * @param {number} simplifiedOffset Simplified offset.
+ * @param {Array<number>} simplifiedEnds Simplified ends.
+ * @return {number} Simplified offset.
+ */
+export function quantizeArray(flatCoordinates: Array<number>, offset: number, ends: Array<number>, stride: number, tolerance: number, simplifiedFlatCoordinates: Array<number>, simplifiedOffset: number, simplifiedEnds: Array<number>): number;
+/**
+ * @param {Array<number>} flatCoordinates Flat coordinates.
+ * @param {number} offset Offset.
+ * @param {Array<Array<number>>} endss Endss.
+ * @param {number} stride Stride.
+ * @param {number} tolerance Tolerance.
+ * @param {Array<number>} simplifiedFlatCoordinates Simplified flat
+ *     coordinates.
+ * @param {number} simplifiedOffset Simplified offset.
+ * @param {Array<Array<number>>} simplifiedEndss Simplified endss.
+ * @return {number} Simplified offset.
+ */
+export function quantizeMultiArray(flatCoordinates: Array<number>, offset: number, endss: Array<Array<number>>, stride: number, tolerance: number, simplifiedFlatCoordinates: Array<number>, simplifiedOffset: number, simplifiedEndss: Array<Array<number>>): number;

package/dist/components/molecules/canvas-map/lib/util/size.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Determines if a size has a positive area.
+ */
+export function hasArea(size: any): boolean;
+/**
+ * Calculate size minus padding
+ *
+ * @function sizeMinusPadding
+ * @param {[number, number]} size
+ * @param {{top: number, right: number, bottom: number, left: number}} padding
+ * @returns {[number, number]} size after subtracting padding
+ */
+export function sizeMinusPadding(size: [number, number], padding: {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+}): [number, number];
+/**
+ * Returns a size scaled by a ratio. The result will be an array of integers.
+ */
+export function scaleSize(size: any, ratio: any, dest: any): any;
+/**
+ * Returns padding object scaled by a ratio
+ */
+export function scalePadding(padding: any, ratio: any): {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+};
+export function sizeForElement(element: any): number[];

package/dist/components/molecules/canvas-map/lib/util/size.js

@@ -0,0 +1,53 @@
+function hasArea(size) {
+  return size[0] > 0 && size[1] > 0;
+}
+function sizeMinusPadding(size, padding) {
+  let newSize = [...size];
+  if (padding) {
+    newSize = [
+      size[0] - padding.left - padding.right,
+      size[1] - padding.top - padding.bottom
+    ];
+  }
+  return newSize;
+}
+function scaleSize(size, ratio, dest) {
+  if (dest === void 0) {
+    dest = [0, 0];
+  }
+  dest[0] = size[0] * ratio + 0.5 | 0;
+  dest[1] = size[1] * ratio + 0.5 | 0;
+  return dest;
+}
+function scalePadding(padding, ratio) {
+  const scaled = {
+    top: Math.round(padding.top * ratio),
+    right: Math.round(padding.right * ratio),
+    bottom: Math.round(padding.bottom * ratio),
+    left: Math.round(padding.left * ratio)
+  };
+  return scaled;
+}
+function sizeForElement(element) {
+  const computedStyle = getComputedStyle(element);
+  if (!computedStyle) return null;
+  let size;
+  const width = element.offsetWidth - parseFloat(computedStyle["borderLeftWidth"]) - parseFloat(computedStyle["paddingLeft"]) - parseFloat(computedStyle["paddingRight"]) - parseFloat(computedStyle["borderRightWidth"]);
+  const height = element.offsetHeight - parseFloat(computedStyle["borderTopWidth"]) - parseFloat(computedStyle["paddingTop"]) - parseFloat(computedStyle["paddingBottom"]) - parseFloat(computedStyle["borderBottomWidth"]);
+  if (!isNaN(width) && !isNaN(height)) {
+    size = [width, height];
+    if (!hasArea(size) && !!(element.offsetWidth || element.offsetHeight || element.getClientRects().length)) {
+      console.warn(
+        "No map visible because the map container's width or height are 0."
+      );
+    }
+  }
+  return size;
+}
+export {
+  hasArea,
+  scalePadding,
+  scaleSize,
+  sizeForElement,
+  sizeMinusPadding
+};

package/dist/components/molecules/canvas-map/lib/util/toRgba.d.ts

@@ -0,0 +1 @@
+export function toRgba(color: any, opacity?: number): string;

package/dist/components/molecules/canvas-map/lib/util/toRgba.js

@@ -0,0 +1,25 @@
+function toRgba(color, opacity = 1) {
+  color = color.replace(/\s+/g, "").toLowerCase();
+  if (color.startsWith("#")) {
+    color = color.replace(/^#/, "");
+    if (color.length === 3) {
+      color = color.split("").map((char) => char + char).join("");
+    }
+    let r = parseInt(color.substring(0, 2), 16);
+    let g = parseInt(color.substring(2, 4), 16);
+    let b = parseInt(color.substring(4, 6), 16);
+    return `rgba(${r}, ${g}, ${b}, ${opacity})`;
+  }
+  let rgbaMatch = color.match(/^rgba?\((\d+),(\d+),(\d+)(?:,(\d+(\.\d+)?))?\)$/);
+  if (rgbaMatch) {
+    let r = parseInt(rgbaMatch[1], 10);
+    let g = parseInt(rgbaMatch[2], 10);
+    let b = parseInt(rgbaMatch[3], 10);
+    let a = rgbaMatch[4] !== void 0 ? parseFloat(rgbaMatch[4]) : opacity;
+    return `rgba(${r}, ${g}, ${b}, ${a})`;
+  }
+  throw new Error("Unsupported color format");
+}
+export {
+  toRgba
+};

package/dist/components/molecules/canvas-map/lib/util/uid.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generates a unique ID for an object. Unique IDs are generated
+ * as a strictly increasing sequence.
+ */
+export function createUid(): string;

package/dist/components/molecules/canvas-map/lib/util/uid.js

@@ -0,0 +1,7 @@
+let _uidCounter = 0;
+function createUid() {
+  return String(++_uidCounter);
+}
+export {
+  createUid
+};

package/dist/components/molecules/canvas-map/lib/util/zoomLevel.d.ts

@@ -0,0 +1,2 @@
+export function zoomLevelToZoomScale(zoomLevel: any, initialResolution: any): number;
+export function zoomLevelForResolution(currentResolution: any): number;