blue-chestnut-solar-expert 0.0.1

package/dist/types/types/shapes.d.ts

@@ -0,0 +1,32 @@
+import { RoofSegmentSizeAndSunshineStats } from "../utils/solar";
+export interface Point {
+    x: number;
+    y: number;
+}
+export type PolygonType = "roof" | "obstruction";
+export interface PolygonDetails {
+    area: number;
+    azimuth: number;
+    pitch: number;
+    assignedRoofStats?: RoofSegmentSizeAndSunshineStats;
+}
+export interface Polygon {
+    points: Point[];
+    type: PolygonType;
+    closed: boolean;
+    _id: string;
+    details?: PolygonDetails;
+}
+export interface SelectedPolygon {
+    _id: string;
+    type: "roof" | "obstruction";
+}
+export interface LineSegment {
+    start: Point;
+    end: Point;
+    type: "inner" | "outer" | "border";
+}
+export interface SegmentMatch {
+    segment: string;
+    matchedSegments: string[];
+}

package/dist/types/utils/api.d.ts

@@ -0,0 +1,13 @@
+import { BuildingInsightsResponse } from "./solar";
+export declare function getBuildingImages(latitude: number, longitude: number, apiKey: string): Promise<{
+    width: number;
+    height: number;
+    rasters: number[][];
+    bounds: {
+        north: any;
+        south: any;
+        east: any;
+        west: any;
+    };
+}>;
+export declare function fetchSolarData(latitude: number, longitude: number, apiKey: string): Promise<BuildingInsightsResponse>;

package/dist/types/utils/geometry/fitting.d.ts

@@ -0,0 +1,89 @@
+import { LineSegment, Polygon, SegmentMatch } from "../../types/shapes";
+import { Bounds, RoofSegmentSizeAndSunshineStats, SolarPanelType } from "../solar";
+import { Point } from "../../types/shapes";
+import { Line } from "../render/polygon";
+export interface PositionedSolarPanel {
+    panel: SolarPanelType;
+    pixelPosition: {
+        x: number;
+        y: number;
+    };
+    horizontal: boolean;
+}
+/**
+ * Get the intersections of a line parallel to the x-axis of the projected coordinate system with a polygon.
+ * @param projectedPoint the point to draw the line from
+ * @param projectedPolygon the polygon to get the intersections with
+ * @returns the intersections of the line with the polygon
+ */
+export declare function getIntersections(projectedPoint: Point, projectedPolygon: Polygon): Point[];
+export declare function projectPoint(point: Point, azimuth: number): Point;
+export declare function projectPolygon(polygon: Polygon, azimuth: number): Polygon;
+export declare function offsetPolygon(polygon: Polygon, offset?: {
+    x: number;
+    y: number;
+}): {
+    polygon: Polygon;
+    offset: {
+        x: number;
+        y: number;
+    };
+};
+/**
+ * Checks if two lines intersect.
+ * if the lines intersect in a start or end point they are not considered as intersecting
+ * @param line1 The first line.
+ * @param line2 The second line.
+ * @returns True if the lines intersect, false otherwise.
+ */
+export declare function intersects(line1: Line, line2: Line): boolean;
+export declare function undoOffsetPolygon(polygon: Polygon, offset: {
+    x: number;
+    y: number;
+}): Polygon;
+export declare function segmentPolygon(polygon: Polygon): LineSegment[];
+/**
+ * for each segment this method will find all the following segments that are connected to it
+ *
+ * first the method subdivides the segments into y levels (all segments that have the same y coordinate are in the same level)
+ * then it will check for each segment in each level if there is a following segment that is connected to it by checking it the
+ * start point of the top segment to the end point of the bottom segment does not intersect with any of the polygon borders and the center point of the connection is in the polygon
+ *
+ * @param segments
+ * @param roof
+ * @returns
+ */
+export declare function matchSegments(segments: LineSegment[], roof: Polygon): {
+    matches: SegmentMatch[];
+    map: Record<string, LineSegment>;
+};
+/**
+ * Fits panels to a roof polygon.
+ *
+ * Starts with positioning a solar panel row (a rectangle with the height of the solar panel and the width in the direction of the perpendicular of
+ * the azimuth of the roof) at each corner of the roof.
+ * For each corner there are four possible cases (the width is the width of the whole roof in the direction of the perpendicular of the azimuth):
+ * 1. The row has height of the solar panel height and sits below the point in the direction of the azimuth of the roof.
+ * 2. The row has height of the solar panel height and sits above the point in the direction of the azimuth of the roof.
+ * 3. The row has the height of the solar panel width (solar panels are rotated) and sits below the point in the direction of the azimuth of the roof.
+ * 4. The row has the height of the solar panel width (solar panels are rotated) and sits above the point in the direction of the azimuth of the roof.
+ *
+ * For each of these cases the function then places the solar panel rows directly above and below the current row.
+ *
+ * after the function has positioned all the rows it places the solar panels in the spaces between the rows.
+ * For each of the four scenarios of each corner the number of panels are counted and the optimal placement is chosen.
+ *
+ * @param roof - The roof polygon.
+ * @param panelType - The type of panel to fit.
+ * @param borderOffset - The offset of the panel from the border of the roof. If negative, the panel can be partially overhanging the roof.
+ * @param azimuth - The azimuth of the roof.
+ * @returns The positioned panels.
+ */
+export declare function fitPanelsToRoof(roof: Polygon, panelType: SolarPanelType, borderOffset?: number, azimuth?: number): PositionedSolarPanel[];
+/**
+ * Uses the bounding box of the roof and the roof segment bounding boxes to find the best fitting roof segment.
+ * @param roof the roof shape
+ * @param roofSegmentStats the stats of the roof segments
+ * @returns the best fitting roof segment
+ */
+export declare function getBestFittingRoofSegment(roof: Polygon, roofSegmentStats: RoofSegmentSizeAndSunshineStats[], bounds: Bounds, canvas: HTMLCanvasElement): RoofSegmentSizeAndSunshineStats;

package/dist/types/utils/geometry/gridMatch.d.ts

@@ -0,0 +1,26 @@
+import { Point, Polygon } from "../../types/shapes";
+import { SolarPanelType } from "../solar";
+import { PositionedSolarPanel } from "./fitting";
+export interface MinMax {
+    minX: number;
+    maxX: number;
+    minY: number;
+    maxY: number;
+}
+export declare function generateGrid(minMax: MinMax, solarPanel: SolarPanelType, horizontal: boolean, anker: Point, rowSpacing: number, columnSpacing: number): Array<Array<PositionedSolarPanel>>;
+export declare function solarPanelInObstacle(positionedSolarPanel: PositionedSolarPanel, obstacle: Polygon, horizontal: boolean): boolean;
+export declare function solarPanelInPolygon(positionedSolarPanel: PositionedSolarPanel, polygon: Polygon, horizontal: boolean): boolean;
+export interface Obstacle {
+    polygon: Polygon;
+    boundingBox: {
+        minX: number;
+        maxX: number;
+        minY: number;
+        maxY: number;
+    };
+}
+export declare function isPanelObstructed(positionedSolarPanel: PositionedSolarPanel, obstacles: Obstacle[], horizontal: boolean): boolean;
+export declare function getSolarPanelsInPolygon(grid: Array<Array<PositionedSolarPanel>>, polygon: Polygon, horizontal: boolean, obstacles: Obstacle[]): Array<Array<PositionedSolarPanel>>;
+export declare function getOptimalSolarPosition(roof: Polygon, obstacles: Obstacle[], solarPanel: SolarPanelType, angle: number): Array<Array<PositionedSolarPanel>>;
+export declare function insetPolygon(polygon: Polygon, inset: number): Polygon;
+export declare function getOptimalSolarPositionFully(roof: Polygon, obstacles: Polygon[], solarPanel: SolarPanelType, azimuth: number, inset: number, angle: number): Array<PositionedSolarPanel>;

package/dist/types/utils/render/color.d.ts

@@ -0,0 +1,3 @@
+import { Polygon, SelectedPolygon } from "../../types/shapes";
+import { SolarExpertConfig } from "../../config";
+export declare function getFillColor(selectedPolygon: SelectedPolygon | null, hoveredPolygon: SelectedPolygon | null, _id: string, polygon: Polygon, config: SolarExpertConfig): string | undefined;

package/dist/types/utils/render/polygon.d.ts

@@ -0,0 +1,35 @@
+import { Point, Polygon } from "../../types/shapes";
+export interface DrawPolygonProps {
+    polygonCtx: CanvasRenderingContext2D;
+    polygonCanvas: HTMLCanvasElement;
+    polygon: Polygon;
+    pixelInMeters: number;
+    shiftKeyPressed: boolean;
+    mousePoint: Point | null;
+    strokeColor: string;
+    fillColor?: string;
+}
+export interface Line {
+    start: Point;
+    end: Point;
+}
+export interface DrawCircleProps {
+    ctx: CanvasRenderingContext2D;
+    x: number;
+    y: number;
+    radius: number;
+    strokeStyle?: string;
+    lineWidth?: number;
+}
+export declare function drawPolygon({ polygonCtx, polygonCanvas, polygon, shiftKeyPressed, mousePoint, strokeColor, fillColor }: DrawPolygonProps): void;
+export declare function drawCircle({ ctx, x, y, radius, strokeStyle, lineWidth }: DrawCircleProps): void;
+export declare function drawPerpendicularDottedLine({ ctx, startPoint, endPoint, dashPattern, strokeStyle, lineWidth }: {
+    ctx: CanvasRenderingContext2D;
+    startPoint: Point;
+    endPoint: Point;
+    dashPattern?: number[];
+    strokeStyle?: string;
+    lineWidth?: number;
+}): void;
+export declare function isPointOnBorder(point: Point, polygon: Polygon): boolean;
+export declare function isPointInPolygon(point: Point, polygon: Polygon): boolean;

package/dist/types/utils/render/projection.d.ts

@@ -0,0 +1,13 @@
+import { Point } from "../../types/shapes";
+export declare function projectPointPerpendicularToLine({ x, y, lastPoint, secondLastPoint, }: {
+    x: number;
+    y: number;
+    lastPoint: {
+        x: number;
+        y: number;
+    };
+    secondLastPoint: {
+        x: number;
+        y: number;
+    };
+}): Point;

package/dist/types/utils/render/tools.d.ts

@@ -0,0 +1,18 @@
+export type ToolType = "move" | "roof" | "obstruction" | "delete";
+export interface KeyboardCombination {
+    key: string;
+    description: string;
+}
+export interface Tool {
+    name: ToolType;
+    ariaLabel: string;
+    icon: string;
+    cursor: string;
+    keyboardShortcut?: string;
+    keyboardCombinations?: KeyboardCombination[];
+}
+export declare const moveTool: Tool;
+export declare const roofTool: Tool;
+export declare const obstructionTool: Tool;
+export declare const deleteTool: Tool;
+export declare const tools: Tool[];

package/dist/types/utils/solar.d.ts

@@ -0,0 +1,155 @@
+export interface DataLayersResponse {
+    imageryDate: Date;
+    imageryProcessedDate: Date;
+    dsmUrl: string;
+    rgbUrl: string;
+    maskUrl: string;
+    annualFluxUrl: string;
+    monthlyFluxUrl: string;
+    hourlyShadeUrls: string[];
+    imageryQuality: 'HIGH' | 'MEDIUM' | 'LOW';
+}
+export interface Bounds {
+    north: number;
+    south: number;
+    east: number;
+    west: number;
+}
+export interface BuildingInsightsResponse {
+    name: string;
+    center: LatLng;
+    boundingBox: LatLngBox;
+    imageryDate: Date;
+    imageryProcessedDate: Date;
+    postalCode: string;
+    administrativeArea: string;
+    statisticalArea: string;
+    regionCode: string;
+    solarPotential: SolarPotential;
+    imageryQuality: 'HIGH' | 'MEDIUM' | 'LOW';
+}
+export interface SolarPotential {
+    maxArrayPanelsCount: number;
+    panelCapacityWatts: number;
+    panelHeightMeters: number;
+    panelWidthMeters: number;
+    panelLifetimeYears: number;
+    maxArrayAreaMeters2: number;
+    maxSunshineHoursPerYear: number;
+    carbonOffsetFactorKgPerMwh: number;
+    wholeRoofStats: SizeAndSunshineStats;
+    buildingStats: SizeAndSunshineStats;
+    roofSegmentStats: RoofSegmentSizeAndSunshineStats[];
+    solarPanels: SolarPanel[];
+    solarPanelConfigs: SolarPanelConfig[];
+    financialAnalyses: object;
+}
+export interface SizeAndSunshineStats {
+    areaMeters2: number;
+    sunshineQuantiles: number[];
+    groundAreaMeters2: number;
+}
+export interface RoofSegmentSizeAndSunshineStats {
+    pitchDegrees: number;
+    azimuthDegrees: number;
+    stats: SizeAndSunshineStats;
+    center: LatLng;
+    boundingBox: LatLngBox;
+    planeHeightAtCenterMeters: number;
+}
+export interface SolarPanel {
+    center: LatLng;
+    orientation: 'LANDSCAPE' | 'PORTRAIT';
+    segmentIndex: number;
+    yearlyEnergyDcKwh: number;
+}
+export interface SolarPanelType {
+    widthMeters: number;
+    heightMeters: number;
+    kWattPeak: number;
+    efficiency: number;
+    price: number;
+}
+export interface InternalSolarPanelConfig {
+    panelsCount: number;
+    yearlyEnergyDcKwh: number;
+    panels: SolarPanel[];
+}
+export interface SolarPanelConfig {
+    panelsCount: number;
+    yearlyEnergyDcKwh: number;
+    roofSegmentSummaries: RoofSegmentSummary[];
+}
+export interface RoofSegmentSummary {
+    pitchDegrees: number;
+    azimuthDegrees: number;
+    panelsCount: number;
+    yearlyEnergyDcKwh: number;
+    segmentIndex: number;
+}
+export interface LatLng {
+    latitude: number;
+    longitude: number;
+}
+export interface LatLngBox {
+    sw: LatLng;
+    ne: LatLng;
+}
+export interface Date {
+    year: number;
+    month: number;
+    day: number;
+}
+export interface RequestError {
+    error: {
+        code: number;
+        message: string;
+        status: string;
+    };
+}
+export type LayerId = 'mask' | 'dsm' | 'rgb' | 'annualFlux' | 'monthlyFlux' | 'hourlyShade';
+/**
+ * Fetches the building insights information from the Solar API.
+ *   https://developers.google.com/maps/documentation/solar/building-insights
+ *
+ * @param  {LatLng} location      Point of interest as latitude longitude.
+ * @param  {string} apiKey        Google Cloud API key.
+ * @return {Promise<DataLayersResponse>}  Building Insights response.
+ */
+export declare function findClosestBuilding(location: google.maps.LatLng, apiKey: string): Promise<BuildingInsightsResponse>;
+/**
+ * Fetches the data layers information from the Solar API.
+ *   https://developers.google.com/maps/documentation/solar/data-layers
+ *
+ * @param  {LatLng} location      Point of interest as latitude longitude.
+ * @param  {number} radiusMeters  Radius of the data layer size in meters.
+ * @param  {string} apiKey        Google Cloud API key.
+ * @return {Promise<DataLayersResponse>}  Data Layers response.
+ */
+export declare function getDataLayerUrls(location: LatLng, radiusMeters: number, apiKey: string): Promise<DataLayersResponse>;
+export interface GeoTiff {
+    width: number;
+    height: number;
+    rasters: Array<number>[];
+    bounds: Bounds;
+}
+/**
+ * Downloads the pixel values for a Data Layer URL from the Solar API.
+ *
+ * @param  {string} url        URL from the Data Layers response.
+ * @param  {string} apiKey     Google Cloud API key.
+ * @return {Promise<GeoTiff>}  Pixel values with shape and lat/lon bounds.
+ */
+export declare function downloadGeoTIFF(url: string, apiKey: string): Promise<{
+    width: number;
+    height: number;
+    rasters: number[][];
+    bounds: {
+        north: any;
+        south: any;
+        east: any;
+        west: any;
+    };
+}>;
+export declare function showLatLng(point: LatLng): string;
+export declare function showDate(date: Date): string;

package/dist/types/utils/utils.d.ts

@@ -0,0 +1,8 @@
+import { Point } from "../types/shapes";
+import { Bounds, GeoTiff, LatLng } from "./solar";
+export declare function calculatePolygonArea(points: Point[]): number;
+export declare function azimuthToCardinal(azimuth: number): string;
+export declare function calculatePolygonOrientation(points: Point[]): number;
+export declare function calculatePolygonAngle(points: Point[]): number;
+export declare function latLngToPixel(bounds: Bounds, canvas: HTMLCanvasElement, latLng: LatLng): Point;
+export declare function getPixelInMeters(rgbTiff: GeoTiff): number;

package/dist/types/utils/visualize.d.ts

@@ -0,0 +1,111 @@
+import { PositionedSolarPanel } from './geometry/fitting';
+import type { Bounds, GeoTiff, InternalSolarPanelConfig } from './solar';
+/**
+ * Renders an RGB GeoTiff image into an HTML canvas.
+ *
+ * The GeoTiff image must include 3 rasters (bands) which
+ * correspond to [Red, Green, Blue] in that order.
+ *
+ * @param  {GeoTiff} rgb   GeoTiff with RGB values of the image.
+ * @param  {GeoTiff} mask  Optional mask for transparency, defaults to opaque.
+ * @return {HTMLCanvasElement}  Canvas element with the rendered image.
+ */
+export declare function renderRGB(rgb: GeoTiff, mask?: GeoTiff, canvas?: HTMLCanvasElement | null): HTMLCanvasElement;
+/**
+ * Renders a single value GeoTiff image into an HTML canvas.
+ *
+ * The GeoTiff image must include 1 raster (band) which contains
+ * the values we want to display.
+ *
+ * @param  {GeoTiff}  data    GeoTiff with the values of interest.
+ * @param  {GeoTiff}  mask    Optional mask for transparency, defaults to opaque.
+ * @param  {string[]} colors  Hex color palette, defaults to ['000000', 'ffffff'].
+ * @param  {number}   min     Minimum value of the data range, defaults to 0.
+ * @param  {number}   max     Maximum value of the data range, defaults to 1.
+ * @param  {number}   index   Raster index for the data, defaults to 0.
+ * @return {HTMLCanvasElement}  Canvas element with the rendered image.
+ */
+export declare function renderPalette({ data, mask, colors, min, max, index, canvas, }: {
+    data: GeoTiff;
+    mask?: GeoTiff;
+    colors?: string[];
+    min?: number;
+    max?: number;
+    index?: number;
+    canvas?: HTMLCanvasElement | null;
+}): HTMLCanvasElement;
+/**
+ * Creates an {r, g, b} color palette from a hex list of colors.
+ *
+ * Each {r, g, b} value is a number between 0 and 255.
+ * The created palette is always of size 256, regardless of the number of
+ * hex colors passed in. Inbetween values are interpolated.
+ *
+ * @param  {string[]} hexColors  List of hex colors for the palette.
+ * @return {{r, g, b}[]}         RGB values for the color palette.
+ */
+export declare function createPalette(hexColors: string[]): {
+    r: number;
+    g: number;
+    b: number;
+}[];
+/**
+ * Convert a hex color into an {r, g, b} color.
+ *
+ * @param  {string} color  Hex color like 0099FF or #0099FF.
+ * @return {{r, g, b}}     RGB values for that color.
+ */
+export declare function colorToRGB(color: string): {
+    r: number;
+    g: number;
+    b: number;
+};
+/**
+ * Normalizes a number to a given data range.
+ *
+ * @param  {number} x    Value of interest.
+ * @param  {number} max  Maximum value in data range, defaults to 1.
+ * @param  {number} min  Minimum value in data range, defaults to 0.
+ * @return {number}      Normalized value.
+ */
+export declare function normalize(x: number, max?: number, min?: number): number;
+/**
+ * Calculates the linear interpolation for a value within a range.
+ *
+ * @param  {number} x  Lower value in the range, when `t` is 0.
+ * @param  {number} y  Upper value in the range, when `t` is 1.
+ * @param  {number} t  "Time" between 0 and 1.
+ * @return {number}    Inbetween value for that "time".
+ */
+export declare function lerp(x: number, y: number, t: number): number;
+/**
+ * Clamps a value to always be within a range.
+ *
+ * @param  {number} x    Value to clamp.
+ * @param  {number} min  Minimum value in the range.
+ * @param  {number} max  Maximum value in the range.
+ * @return {number}      Clamped value.
+ */
+export declare function clamp(x: number, min: number, max: number): number;
+export declare function rgbToColor({ r, g, b }: {
+    r: number;
+    g: number;
+    b: number;
+}): string;
+export declare function renderAzimuth(azimuth: number, ctx: CanvasRenderingContext2D): void;
+export declare function renderSolarPanel(solarPanel: PositionedSolarPanel, ctx: CanvasRenderingContext2D, panelWidth: number, panelHeight: number, azimuthAngle: number, pitchAngle: number): void;
+export declare function renderPanels({ canvas, panelConfig, bounds, zoom, roofSegments }: {
+    canvas: HTMLCanvasElement | null;
+    panelConfig: InternalSolarPanelConfig;
+    bounds: Bounds;
+    zoom: number;
+    roofSegments: Record<number, {
+        pitchDegrees: number;
+        azimuthDegrees: number;
+    }>;
+}): HTMLCanvasElement;
+export declare function renderCombinedWithZoom({ rgb, zoom, canvas, }: {
+    rgb: GeoTiff;
+    zoom?: number;
+    canvas?: HTMLCanvasElement | null;
+}): HTMLCanvasElement;

package/loader/cdn.js

@@ -0,0 +1 @@
+module.exports = require('../dist/cjs/loader.cjs.js');

package/loader/index.cjs.js

@@ -0,0 +1 @@
+module.exports = require('../dist/cjs/loader.cjs.js');

package/loader/index.d.ts

@@ -0,0 +1,24 @@
+export * from '../dist/types/components';
+export interface CustomElementsDefineOptions {
+  exclude?: string[];
+  resourcesUrl?: string;
+  syncQueue?: boolean;
+  jmp?: (c: Function) => any;
+  raf?: (c: FrameRequestCallback) => number;
+  ael?: (el: EventTarget, eventName: string, listener: EventListenerOrEventListenerObject, options: boolean | AddEventListenerOptions) => void;
+  rel?: (el: EventTarget, eventName: string, listener: EventListenerOrEventListenerObject, options: boolean | AddEventListenerOptions) => void;
+}
+export declare function defineCustomElements(win?: Window, opts?: CustomElementsDefineOptions): void;
+/**
+ * @deprecated
+ */
+export declare function applyPolyfills(): Promise<void>;
+
+/**
+ * Used to specify a nonce value that corresponds with an application's CSP.
+ * When set, the nonce will be added to all dynamically created script and style tags at runtime.
+ * Alternatively, the nonce value can be set on a meta tag in the DOM head
+ * (<meta name="csp-nonce" content="{ nonce value here }" />) which
+ * will result in the same behavior.
+ */
+export declare function setNonce(nonce: string): void;

package/loader/index.es2017.js

@@ -0,0 +1 @@
+export * from '../dist/esm/loader.js';

package/loader/index.js

@@ -0,0 +1,2 @@
+(function(){if("undefined"!==typeof window&&void 0!==window.Reflect&&void 0!==window.customElements){var a=HTMLElement;window.HTMLElement=function(){return Reflect.construct(a,[],this.constructor)};HTMLElement.prototype=a.prototype;HTMLElement.prototype.constructor=HTMLElement;Object.setPrototypeOf(HTMLElement,a)}})();
+export * from '../dist/esm/loader.js';

package/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "blue-chestnut-solar-expert",
+  "version": "0.0.1",
+  "description": "Blue Chestnut Solar Expert",
+  "main": "dist/index.cjs.js",
+  "module": "dist/index.js",
+  "types": "dist/types/index.d.ts",
+  "collection": "dist/collection/collection-manifest.json",
+  "collection:main": "dist/collection/index.js",
+  "unpkg": "dist/stencil-library/stencil-library.esm.js",
+  "exports": {
+    ".": {
+      "import": "./dist/stencil-library/stencil-library.esm.js",
+      "require": "./dist/stencil-library/stencil-library.cjs.js"
+    },
+    "./my-component": {
+      "import": "./dist/components/my-component.js",
+      "types": "./dist/components/my-component.d.ts"
+    },
+    "./loader": {
+      "import": "./loader/index.js",
+      "require": "./loader/index.cjs",
+      "types": "./loader/index.d.ts"
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/stenciljs/component-starter.git"
+  },
+  "files": [
+    "dist/",
+    "loader/"
+  ],
+  "scripts": {
+    "build": "stencil build",
+    "start": "stencil build --dev --watch --serve",
+    "test": "stencil test --spec --e2e",
+    "testspec": "stencil test --spec --watchAll",
+    "testspecfile": "jest src/utils/geometry/gridMatching.spec.ts --watch",
+    "test.watch": "stencil test --spec --e2e --watchAll",
+    "generate": "stencil generate"
+  },
+  "devDependencies": {
+    "@stencil/core": "^4.27.1",
+    "@types/jest": "^29.5.14",
+    "@types/node": "^22.13.5",
+    "dotenv": "^16.5.0",
+    "jest": "^29.7.0",
+    "jest-cli": "^29.7.0",
+    "puppeteer": "^24.3.0",
+    "rollup-plugin-node-polyfills": "^0.2.1"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "@googlemaps/js-api-loader": "^1.16.8",
+    "@rollup/plugin-node-resolve": "^16.0.1",
+    "@tailwindcss/cli": "^4.1.6",
+    "@types/google.maps": "^3.58.1",
+    "geotiff": "^2.1.3",
+    "geotiff-geokeys-to-proj4": "^2024.4.13",
+    "lucide": "^0.509.0",
+    "proj4": "^2.16.2",
+    "tailwindcss": "^4.1.6",
+    "ts-jest": "^29.3.4"
+  }
+}