@symfony/ux-leaflet-map 2.32.0 → 2.34.0

package/README.md

@@ -6,9 +6,10 @@ JavaScript assets of the [symfony/ux-leaflet-map](https://packagist.org/packages
 
 This npm package is **reserved for advanced users** who want to decouple their JavaScript dependencies from their PHP dependencies (e.g., when building Docker images, running JavaScript-only pipelines, etc.).
 
-We **strongly recommend not installing this package directly**, but instead  install the PHP package [symfony/ux-leaflet-map](https://packagist.org/packages/symfony/ux-leaflet-map) in your Symfony application with [Flex](https://github.com/symfony/flex) enabled.
+We **strongly recommend not installing this package directly**, but instead install the PHP package [symfony/ux-leaflet-map](https://packagist.org/packages/symfony/ux-leaflet-map) in your Symfony application with [Flex](https://github.com/symfony/flex) enabled.
 
 If you still want to install this package directly, please make sure its version exactly matches [symfony/ux-leaflet-map](https://packagist.org/packages/symfony/ux-leaflet-map) PHP package version:
+
 ```shell
 composer require symfony/ux-leaflet-map:2.23.0
 npm add @symfony/ux-leaflet-map@2.23.0
@@ -18,7 +19,7 @@ npm add @symfony/ux-leaflet-map@2.23.0
 
 ## Resources
 
--   [Documentation](https://github.com/symfony/ux/tree/2.x/src/Map/src/Bridge/Google)
--   [Report issues](https://github.com/symfony/ux/issues) and
-    [send Pull Requests](https://github.com/symfony/ux/pulls)
-    in the [main Symfony UX repository](https://github.com/symfony/ux)
+- [Documentation](https://github.com/symfony/ux/tree/2.x/src/Map/src/Bridge/Google)
+- [Report issues](https://github.com/symfony/ux/issues) and
+  [send Pull Requests](https://github.com/symfony/ux/pulls)
+  in the [main Symfony UX repository](https://github.com/symfony/ux)

package/dist/map_controller.d.ts

@@ -1,66 +1,296 @@
-import AbstractMapController, { MapDefinition, MarkerDefinition, PolygonDefinition, PolylineDefinition, CircleDefinition, RectangleDefinition, InfoWindowDefinition, Icon } from '@symfony/ux-map';
-import * as L from 'leaflet';
-import { MapOptions as MapOptions$1, ControlPosition, MarkerOptions, PopupOptions, PolylineOptions, CircleOptions } from 'leaflet';
-
-type MapOptions = Pick<MapOptions$1, 'attributionControl' | 'zoomControl'> & {
-    attributionControlOptions?: {
-        position: ControlPosition;
-        prefix: string | false;
-    };
-    zoomControlOptions?: {
-        position: ControlPosition;
-        zoomInText: string;
-        zoomInTitle: string;
-        zoomOutText: string;
-        zoomOutTitle: string;
-    };
-    tileLayer: {
-        url: string;
-        attribution: string;
-        options: Record<string, unknown>;
-    } | false;
+import { Controller } from "@hotwired/stimulus";
+import * as L from "leaflet";
+import { CircleOptions, ControlPosition, MapOptions, MarkerOptions, PolylineOptions, PopupOptions } from "leaflet";
+type Point = {
+  lat: number;
+  lng: number;
 };
-declare class export_default extends AbstractMapController<MapOptions, MapOptions$1, L.Map, MarkerOptions, L.Marker, PopupOptions, L.Popup, PolylineOptions, L.Polygon, PolylineOptions, L.Polyline, CircleOptions, L.Circle, PolylineOptions, L.Rectangle> {
-    map: L.Map;
-    connect(): void;
-    centerValueChanged(): void;
-    zoomValueChanged(): void;
-    minZoomValueChanged(): void;
-    maxZoomValueChanged(): void;
-    protected dispatchEvent(name: string, payload?: Record<string, unknown>): void;
-    protected doCreateMap({ definition }: {
-        definition: MapDefinition<MapOptions, MapOptions$1>;
-    }): L.Map;
-    protected doCreateMarker({ definition }: {
-        definition: MarkerDefinition<MarkerOptions, PopupOptions>;
-    }): L.Marker;
-    protected doRemoveMarker(marker: L.Marker): void;
-    protected doCreatePolygon({ definition }: {
-        definition: PolygonDefinition<PolylineOptions, PopupOptions>;
-    }): L.Polygon;
-    protected doRemovePolygon(polygon: L.Polygon): void;
-    protected doCreatePolyline({ definition }: {
-        definition: PolylineDefinition<PolylineOptions, PopupOptions>;
-    }): L.Polyline;
-    protected doRemovePolyline(polyline: L.Polyline): void;
-    protected doCreateCircle({ definition }: {
-        definition: CircleDefinition<CircleOptions, PopupOptions>;
-    }): L.Circle;
-    protected doRemoveCircle(circle: L.Circle): void;
-    protected doCreateRectangle({ definition }: {
-        definition: RectangleDefinition<PolylineOptions, PopupOptions>;
-    }): L.Rectangle;
-    protected doRemoveRectangle(rectangle: L.Rectangle): void;
-    protected doCreateInfoWindow({ definition, element, }: {
-        definition: Omit<InfoWindowDefinition<PopupOptions>, 'position'>;
-        element: L.Marker | L.Polygon | L.Polyline | L.Circle | L.Rectangle;
-    }): L.Popup;
-    protected doCreateIcon({ definition, element }: {
-        definition: Icon;
-        element: L.Marker;
-    }): void;
-    protected doFitBoundsToMarkers(): void;
-    private closePopups;
+type Identifier = string;
+type WithIdentifier<T extends Record<string, unknown>> = T & {
+  '@id': Identifier;
+};
+type ExtraData = Record<string, unknown>;
+declare const IconTypes: {
+  readonly Url: "url";
+  readonly Svg: "svg";
+  readonly UxIcon: "ux-icon";
+};
+type Icon = {
+  width: number;
+  height: number;
+} & ({
+  type: typeof IconTypes.UxIcon;
+  name: string;
+  _generated_html: string;
+} | {
+  type: typeof IconTypes.Url;
+  url: string;
+} | {
+  type: typeof IconTypes.Svg;
+  html: string;
+});
+type MapDefinition<MapOptions, BridgeMapOptions> = {
+  center: Point | null;
+  zoom: number | null;
+  minZoom: number | null;
+  maxZoom: number | null;
+  options: MapOptions;
+  bridgeOptions?: BridgeMapOptions;
+  extra: ExtraData;
+};
+type MarkerDefinition<BridgeMarkerOptions, BridgeInfoWindowOptions> = WithIdentifier<{
+  position: Point;
+  title: string | null;
+  infoWindow?: Omit<InfoWindowDefinition<BridgeInfoWindowOptions>, 'position'>;
+  icon?: Icon;
+  rawOptions?: BridgeMarkerOptions;
+  bridgeOptions?: BridgeMarkerOptions;
+  extra: ExtraData;
+}>;
+type PolygonDefinition<BridgePolygonOptions, BridgeInfoWindowOptions> = WithIdentifier<{
+  infoWindow?: Omit<InfoWindowDefinition<BridgeInfoWindowOptions>, 'position'>;
+  points: Array<Point> | Array<Array<Point>>;
+  title: string | null;
+  rawOptions?: BridgePolygonOptions;
+  bridgeOptions?: BridgePolygonOptions;
+  extra: ExtraData;
+}>;
+type PolylineDefinition<BridgePolylineOptions, BridgeInfoWindowOptions> = WithIdentifier<{
+  infoWindow?: Omit<InfoWindowDefinition<BridgeInfoWindowOptions>, 'position'>;
+  points: Array<Point>;
+  title: string | null;
+  rawOptions?: BridgePolylineOptions;
+  bridgeOptions?: BridgePolylineOptions;
+  extra: ExtraData;
+}>;
+type CircleDefinition<BridgeCircleOptions, BridgeInfoWindowOptions> = WithIdentifier<{
+  infoWindow?: Omit<InfoWindowDefinition<BridgeInfoWindowOptions>, 'position'>;
+  center: Point;
+  radius: number;
+  title: string | null;
+  rawOptions?: BridgeCircleOptions;
+  bridgeOptions?: BridgeCircleOptions;
+  extra: ExtraData;
+}>;
+type RectangleDefinition<BridgeRectangleOptions, BridgeInfoWindowOptions> = WithIdentifier<{
+  infoWindow?: Omit<InfoWindowDefinition<BridgeInfoWindowOptions>, 'position'>;
+  southWest: Point;
+  northEast: Point;
+  title: string | null;
+  rawOptions?: BridgeRectangleOptions;
+  bridgeOptions?: BridgeRectangleOptions;
+  extra: ExtraData;
+}>;
+type InfoWindowDefinition<BridgeInfoWindowOptions> = {
+  headerContent: string | null;
+  content: string | null;
+  position: Point;
+  opened: boolean;
+  autoClose: boolean;
+  rawOptions?: BridgeInfoWindowOptions;
+  bridgeOptions?: BridgeInfoWindowOptions;
+  extra: ExtraData;
+};
+declare abstract class export_default$1<MapOptions, BridgeMapOptions, BridgeMap, BridgeMarkerOptions, BridgeMarker, BridgeInfoWindowOptions, BridgeInfoWindow, BridgePolygonOptions, BridgePolygon, BridgePolylineOptions, BridgePolyline, BridgeCircleOptions, BridgeCircle, BridgeRectangleOptions, BridgeRectangle> extends Controller<HTMLElement> {
+  static values: {
+    providerOptions: ObjectConstructor;
+    center: ObjectConstructor;
+    zoom: NumberConstructor;
+    minZoom: NumberConstructor;
+    maxZoom: NumberConstructor;
+    fitBoundsToMarkers: BooleanConstructor;
+    markers: ArrayConstructor;
+    polygons: ArrayConstructor;
+    polylines: ArrayConstructor;
+    circles: ArrayConstructor;
+    rectangles: ArrayConstructor;
+    options: ObjectConstructor;
+    extra: ObjectConstructor;
+  };
+  centerValue: Point | null;
+  zoomValue: number | null;
+  minZoomValue: number | null;
+  maxZoomValue: number | null;
+  fitBoundsToMarkersValue: boolean;
+  markersValue: Array<MarkerDefinition<BridgeMarkerOptions, BridgeInfoWindowOptions>>;
+  polygonsValue: Array<PolygonDefinition<BridgePolygonOptions, BridgeInfoWindowOptions>>;
+  polylinesValue: Array<PolylineDefinition<BridgePolylineOptions, BridgeInfoWindowOptions>>;
+  circlesValue: Array<CircleDefinition<BridgeCircleOptions, BridgeInfoWindowOptions>>;
+  rectanglesValue: Array<RectangleDefinition<BridgeRectangleOptions, BridgeInfoWindowOptions>>;
+  optionsValue: MapOptions;
+  extraValue: Record<string, unknown>;
+  hasCenterValue: boolean;
+  hasZoomValue: boolean;
+  hasMinZoomValue: boolean;
+  hasMaxZoomValue: boolean;
+  hasFitBoundsToMarkersValue: boolean;
+  hasMarkersValue: boolean;
+  hasPolygonsValue: boolean;
+  hasPolylinesValue: boolean;
+  hasCirclesValue: boolean;
+  hasRectanglesValue: boolean;
+  hasOptionsValue: boolean;
+  hasExtraValue: boolean;
+  protected map: BridgeMap;
+  protected markers: Map<string, BridgeMarker>;
+  protected polygons: Map<string, BridgePolygon>;
+  protected polylines: Map<string, BridgePolyline>;
+  protected circles: Map<string, BridgeCircle>;
+  protected rectangles: Map<string, BridgeRectangle>;
+  protected infoWindows: Array<BridgeInfoWindow>;
+  private isConnected;
+  private createMarker;
+  private createPolygon;
+  private createPolyline;
+  private createCircle;
+  private createRectangle;
+  protected abstract dispatchEvent(name: string, payload: Record<string, unknown>): void;
+  connect(): void;
+  createInfoWindow({
+    definition,
+    element
+  }: {
+    definition: Omit<InfoWindowDefinition<BridgeInfoWindowOptions>, 'position'>;
+    element: BridgeMarker | BridgePolygon | BridgePolyline | BridgeCircle | BridgeRectangle;
+  }): BridgeInfoWindow;
+  abstract centerValueChanged(): void;
+  abstract zoomValueChanged(): void;
+  abstract minZoomValueChanged(): void;
+  abstract maxZoomValueChanged(): void;
+  markersValueChanged(): void;
+  polygonsValueChanged(): void;
+  polylinesValueChanged(): void;
+  circlesValueChanged(): void;
+  rectanglesValueChanged(): void;
+  protected abstract doCreateMap({
+    definition
+  }: {
+    definition: MapDefinition<MapOptions, BridgeMapOptions>;
+  }): BridgeMap;
+  protected abstract doFitBoundsToMarkers(): void;
+  protected abstract doCreateMarker({
+    definition
+  }: {
+    definition: MarkerDefinition<BridgeMarkerOptions, BridgeInfoWindowOptions>;
+  }): BridgeMarker;
+  protected abstract doRemoveMarker(marker: BridgeMarker): void;
+  protected abstract doCreatePolygon({
+    definition
+  }: {
+    definition: PolygonDefinition<BridgePolygonOptions, BridgeInfoWindowOptions>;
+  }): BridgePolygon;
+  protected abstract doRemovePolygon(polygon: BridgePolygon): void;
+  protected abstract doCreatePolyline({
+    definition
+  }: {
+    definition: PolylineDefinition<BridgePolylineOptions, BridgeInfoWindowOptions>;
+  }): BridgePolyline;
+  protected abstract doRemovePolyline(polyline: BridgePolyline): void;
+  protected abstract doCreateCircle({
+    definition
+  }: {
+    definition: CircleDefinition<BridgeCircleOptions, BridgeInfoWindowOptions>;
+  }): BridgeCircle;
+  protected abstract doRemoveCircle(circle: BridgeCircle): void;
+  protected abstract doCreateRectangle({
+    definition
+  }: {
+    definition: RectangleDefinition<BridgeRectangleOptions, BridgeInfoWindowOptions>;
+  }): BridgeRectangle;
+  protected abstract doRemoveRectangle(rectangle: BridgeRectangle): void;
+  protected abstract doCreateInfoWindow({
+    definition,
+    element
+  }: {
+    definition: Omit<InfoWindowDefinition<BridgeInfoWindowOptions>, 'position'>;
+    element: BridgeMarker | BridgePolygon | BridgePolyline | BridgeCircle | BridgeRectangle;
+  }): BridgeInfoWindow;
+  protected abstract doCreateIcon({
+    definition,
+    element
+  }: {
+    definition: Icon;
+    element: BridgeMarker;
+  }): void;
+  private createDrawingFactory;
+  private onDrawChanged;
+}
+type MapOptions$1 = Pick<MapOptions, 'attributionControl' | 'zoomControl'> & {
+  attributionControlOptions?: {
+    position: ControlPosition;
+    prefix: string | false;
+  };
+  zoomControlOptions?: {
+    position: ControlPosition;
+    zoomInText: string;
+    zoomInTitle: string;
+    zoomOutText: string;
+    zoomOutTitle: string;
+  };
+  tileLayer: {
+    url: string;
+    attribution: string;
+    options: Record<string, unknown>;
+  } | false;
+};
+declare class export_default extends export_default$1<MapOptions$1, MapOptions, L.Map, MarkerOptions, L.Marker, PopupOptions, L.Popup, PolylineOptions, L.Polygon, PolylineOptions, L.Polyline, CircleOptions, L.Circle, PolylineOptions, L.Rectangle> {
+  map: L.Map;
+  connect(): void;
+  centerValueChanged(): void;
+  zoomValueChanged(): void;
+  minZoomValueChanged(): void;
+  maxZoomValueChanged(): void;
+  protected dispatchEvent(name: string, payload?: Record<string, unknown>): void;
+  protected doCreateMap({
+    definition
+  }: {
+    definition: MapDefinition<MapOptions$1, MapOptions>;
+  }): L.Map;
+  protected doCreateMarker({
+    definition
+  }: {
+    definition: MarkerDefinition<MarkerOptions, PopupOptions>;
+  }): L.Marker;
+  protected doRemoveMarker(marker: L.Marker): void;
+  protected doCreatePolygon({
+    definition
+  }: {
+    definition: PolygonDefinition<PolylineOptions, PopupOptions>;
+  }): L.Polygon;
+  protected doRemovePolygon(polygon: L.Polygon): void;
+  protected doCreatePolyline({
+    definition
+  }: {
+    definition: PolylineDefinition<PolylineOptions, PopupOptions>;
+  }): L.Polyline;
+  protected doRemovePolyline(polyline: L.Polyline): void;
+  protected doCreateCircle({
+    definition
+  }: {
+    definition: CircleDefinition<CircleOptions, PopupOptions>;
+  }): L.Circle;
+  protected doRemoveCircle(circle: L.Circle): void;
+  protected doCreateRectangle({
+    definition
+  }: {
+    definition: RectangleDefinition<PolylineOptions, PopupOptions>;
+  }): L.Rectangle;
+  protected doRemoveRectangle(rectangle: L.Rectangle): void;
+  protected doCreateInfoWindow({
+    definition,
+    element
+  }: {
+    definition: Omit<InfoWindowDefinition<PopupOptions>, 'position'>;
+    element: L.Marker | L.Polygon | L.Polyline | L.Circle | L.Rectangle;
+  }): L.Popup;
+  protected doCreateIcon({
+    definition,
+    element
+  }: {
+    definition: Icon;
+    element: L.Marker;
+  }): void;
+  protected doFitBoundsToMarkers(): void;
+  private closePopups;
 }
-
-export { export_default as default };
+export { export_default as default };

package/dist/map_controller.js

@@ -1,389 +1,353 @@
-// ../../../../assets/dist/abstract_map_controller.js
 import { Controller } from "@hotwired/stimulus";
-var IconTypes = {
-  Url: "url",
-  Svg: "svg",
-  UxIcon: "ux-icon"
-};
-var abstract_map_controller_default = class extends Controller {
-  constructor() {
-    super(...arguments);
-    this.markers = /* @__PURE__ */ new Map();
-    this.polygons = /* @__PURE__ */ new Map();
-    this.polylines = /* @__PURE__ */ new Map();
-    this.circles = /* @__PURE__ */ new Map();
-    this.rectangles = /* @__PURE__ */ new Map();
-    this.infoWindows = [];
-    this.isConnected = false;
-  }
-  connect() {
-    const extra = this.hasExtraValue ? this.extraValue : {};
-    const mapDefinition = {
-      center: this.hasCenterValue ? this.centerValue : null,
-      zoom: this.hasZoomValue ? this.zoomValue : null,
-      minZoom: this.hasMinZoomValue ? this.minZoomValue : null,
-      maxZoom: this.hasMaxZoomValue ? this.maxZoomValue : null,
-      options: this.optionsValue,
-      extra
-    };
-    this.dispatchEvent("pre-connect", mapDefinition);
-    this.createMarker = this.createDrawingFactory("marker", this.markers, this.doCreateMarker.bind(this));
-    this.createPolygon = this.createDrawingFactory("polygon", this.polygons, this.doCreatePolygon.bind(this));
-    this.createPolyline = this.createDrawingFactory("polyline", this.polylines, this.doCreatePolyline.bind(this));
-    this.createCircle = this.createDrawingFactory("circle", this.circles, this.doCreateCircle.bind(this));
-    this.createRectangle = this.createDrawingFactory("rectangle", this.rectangles, this.doCreateRectangle.bind(this));
-    this.map = this.doCreateMap({ definition: mapDefinition });
-    this.markersValue.forEach((definition) => {
-      this.createMarker({ definition });
-    });
-    this.polygonsValue.forEach((definition) => {
-      this.createPolygon({ definition });
-    });
-    this.polylinesValue.forEach((definition) => {
-      this.createPolyline({ definition });
-    });
-    this.circlesValue.forEach((definition) => {
-      this.createCircle({ definition });
-    });
-    this.rectanglesValue.forEach((definition) => {
-      this.createRectangle({ definition });
-    });
-    if (this.fitBoundsToMarkersValue) {
-      this.doFitBoundsToMarkers();
-    }
-    this.dispatchEvent("connect", {
-      map: this.map,
-      markers: [...this.markers.values()],
-      polygons: [...this.polygons.values()],
-      polylines: [...this.polylines.values()],
-      circles: [...this.circles.values()],
-      rectangles: [...this.rectangles.values()],
-      infoWindows: this.infoWindows,
-      extra
-    });
-    this.isConnected = true;
-  }
-  //region Public API
-  createInfoWindow({
-    definition,
-    element
-  }) {
-    this.dispatchEvent("info-window:before-create", { definition, element });
-    const infoWindow = this.doCreateInfoWindow({ definition, element });
-    this.dispatchEvent("info-window:after-create", { infoWindow, definition, element });
-    this.infoWindows.push(infoWindow);
-    return infoWindow;
-  }
-  markersValueChanged() {
-    if (!this.isConnected) {
-      return;
-    }
-    this.onDrawChanged(this.markers, this.markersValue, this.createMarker, this.doRemoveMarker);
-    if (this.fitBoundsToMarkersValue) {
-      this.doFitBoundsToMarkers();
-    }
-  }
-  polygonsValueChanged() {
-    if (!this.isConnected) {
-      return;
-    }
-    this.onDrawChanged(this.polygons, this.polygonsValue, this.createPolygon, this.doRemovePolygon);
-  }
-  polylinesValueChanged() {
-    if (!this.isConnected) {
-      return;
-    }
-    this.onDrawChanged(this.polylines, this.polylinesValue, this.createPolyline, this.doRemovePolyline);
-  }
-  circlesValueChanged() {
-    if (!this.isConnected) {
-      return;
-    }
-    this.onDrawChanged(this.circles, this.circlesValue, this.createCircle, this.doRemoveCircle);
-  }
-  rectanglesValueChanged() {
-    if (!this.isConnected) {
-      return;
-    }
-    this.onDrawChanged(this.rectangles, this.rectanglesValue, this.createRectangle, this.doRemoveRectangle);
-  }
-  createDrawingFactory(type, draws, factory) {
-    const eventBefore = `${type}:before-create`;
-    const eventAfter = `${type}:after-create`;
-    return ({ definition }) => {
-      this.dispatchEvent(eventBefore, { definition });
-      if (typeof definition.rawOptions !== "undefined") {
-        console.warn(
-          `[Symfony UX Map] The event "${eventBefore}" added a deprecated "rawOptions" property to the definition, it will be removed in a next major version, replace it with "bridgeOptions" instead.`,
-          definition
-        );
-      }
-      const drawing = factory({ definition });
-      this.dispatchEvent(eventAfter, { [type]: drawing, definition });
-      draws.set(definition["@id"], drawing);
-      return drawing;
-    };
-  }
-  onDrawChanged(draws, newDrawDefinitions, factory, remover) {
-    const idsToRemove = new Set(draws.keys());
-    newDrawDefinitions.forEach((definition) => {
-      idsToRemove.delete(definition["@id"]);
-    });
-    idsToRemove.forEach((id) => {
-      const draw = draws.get(id);
-      remover(draw);
-      draws.delete(id);
-    });
-    newDrawDefinitions.forEach((definition) => {
-      if (!draws.has(definition["@id"])) {
-        factory({ definition });
-      }
-    });
-  }
-  //endregion
-};
-abstract_map_controller_default.values = {
-  providerOptions: Object,
-  center: Object,
-  zoom: Number,
-  minZoom: Number,
-  maxZoom: Number,
-  fitBoundsToMarkers: Boolean,
-  markers: Array,
-  polygons: Array,
-  polylines: Array,
-  circles: Array,
-  rectangles: Array,
-  options: Object,
-  extra: Object
-};
-
-// src/map_controller.ts
 import "leaflet/dist/leaflet.min.css";
 import * as L from "leaflet";
-var map_controller_default = class extends abstract_map_controller_default {
-  connect() {
-    L.Marker.prototype.options.icon = L.divIcon({
-      html: '<svg xmlns="http://www.w3.org/2000/svg" xml:space="preserve" fill-rule="evenodd" stroke-linecap="round" clip-rule="evenodd" viewBox="0 0 500 820"><defs><linearGradient id="__sf_ux_map_gradient_marker_fill" x1="0" x2="1" y1="0" y2="0" gradientTransform="matrix(0 -37.57 37.57 0 416.45 541)" gradientUnits="userSpaceOnUse"><stop offset="0" stop-color="#126FC6"/><stop offset="1" stop-color="#4C9CD1"/></linearGradient><linearGradient id="__sf_ux_map_gradient_marker_border" x1="0" x2="1" y1="0" y2="0" gradientTransform="matrix(0 -19.05 19.05 0 414.48 522.49)" gradientUnits="userSpaceOnUse"><stop offset="0" stop-color="#2E6C97"/><stop offset="1" stop-color="#3883B7"/></linearGradient></defs><circle cx="252.31" cy="266.24" r="83.99" fill="#fff"/><path fill="url(#__sf_ux_map_gradient_marker_fill)" stroke="url(#__sf_ux_map_gradient_marker_border)" stroke-width="1.1" d="M416.54 503.61c-6.57 0-12.04 5.7-12.04 11.87 0 2.78 1.56 6.3 2.7 8.74l9.3 17.88 9.26-17.88c1.13-2.43 2.74-5.79 2.74-8.74 0-6.18-5.38-11.87-11.96-11.87Zm0 7.16a4.69 4.69 0 1 1-.02 9.4 4.69 4.69 0 0 1 .02-9.4Z" transform="translate(-7889.1 -9807.44) scale(19.54)"/></svg>',
-      iconSize: [25, 41],
-      iconAnchor: [12.5, 41],
-      popupAnchor: [0, -41],
-      className: ""
-      // Adding an empty class to the icon to avoid the default Leaflet styles
-    });
-    super.connect();
-  }
-  centerValueChanged() {
-    if (this.map && this.hasCenterValue && this.centerValue && this.hasZoomValue && this.zoomValue) {
-      this.map.setView(this.centerValue, this.zoomValue);
-    }
-  }
-  zoomValueChanged() {
-    if (this.map && this.hasZoomValue && this.zoomValue) {
-      this.map.setZoom(this.zoomValue);
-    }
-  }
-  minZoomValueChanged() {
-    if (this.map && this.hasMinZoomValue && this.minZoomValue) {
-      this.map.setMinZoom(this.minZoomValue);
-    }
-  }
-  maxZoomValueChanged() {
-    if (this.map && this.hasMaxZoomValue && this.maxZoomValue) {
-      this.map.setMaxZoom(this.maxZoomValue);
-    }
-  }
-  dispatchEvent(name, payload = {}) {
-    payload.L = L;
-    this.dispatch(name, {
-      prefix: "ux:map",
-      detail: payload
-    });
-  }
-  doCreateMap({ definition }) {
-    const { center, zoom, minZoom, maxZoom, options, bridgeOptions = {} } = definition;
-    const map2 = L.map(this.element, {
-      center: center === null ? void 0 : center,
-      zoom: zoom === null ? void 0 : zoom,
-      minZoom: minZoom === null ? void 0 : minZoom,
-      maxZoom: maxZoom === null ? void 0 : maxZoom,
-      attributionControl: false,
-      zoomControl: false,
-      ...options,
-      ...bridgeOptions
-    });
-    if (options.tileLayer) {
-      L.tileLayer(options.tileLayer.url, {
-        attribution: options.tileLayer.attribution,
-        ...options.tileLayer.options
-      }).addTo(map2);
-    }
-    if (typeof options.attributionControlOptions !== "undefined") {
-      L.control.attribution({ ...options.attributionControlOptions }).addTo(map2);
-    }
-    if (typeof options.zoomControlOptions !== "undefined") {
-      L.control.zoom({ ...options.zoomControlOptions }).addTo(map2);
-    }
-    return map2;
-  }
-  doCreateMarker({ definition }) {
-    const { "@id": _id, position, title, infoWindow, icon: icon2, rawOptions = {}, bridgeOptions = {} } = definition;
-    const marker2 = L.marker(position, {
-      title: title || void 0,
-      ...rawOptions,
-      ...bridgeOptions,
-      riseOnHover: true
-    }).addTo(this.map);
-    if (infoWindow) {
-      this.createInfoWindow({ definition: infoWindow, element: marker2 });
-    }
-    if (icon2) {
-      if (Object.prototype.hasOwnProperty.call(bridgeOptions, "icon")) {
-        console.warn('[Symfony UX Map] Defining "bridgeOptions.icon" for a marker with a custom icon is not supported and will be ignored.');
-      } else if (Object.prototype.hasOwnProperty.call(rawOptions, "icon")) {
-        console.warn('[Symfony UX Map] Defining "rawOptions.icon" for a marker with a custom icon is not supported and will be ignored.');
-      }
-      this.doCreateIcon({ definition: icon2, element: marker2 });
-    }
-    return marker2;
-  }
-  doRemoveMarker(marker2) {
-    marker2.remove();
-  }
-  doCreatePolygon({ definition }) {
-    const { "@id": _id, points, title, infoWindow, rawOptions = {}, bridgeOptions = {} } = definition;
-    const polygon2 = L.polygon(points, { ...rawOptions, ...bridgeOptions }).addTo(this.map);
-    if (title) {
-      polygon2.bindPopup(title);
-    }
-    if (infoWindow) {
-      this.createInfoWindow({ definition: infoWindow, element: polygon2 });
-    }
-    return polygon2;
-  }
-  doRemovePolygon(polygon2) {
-    polygon2.remove();
-  }
-  doCreatePolyline({ definition }) {
-    const { "@id": _id, points, title, infoWindow, rawOptions = {}, bridgeOptions = {} } = definition;
-    const polyline2 = L.polyline(points, { ...rawOptions, ...bridgeOptions }).addTo(this.map);
-    if (title) {
-      polyline2.bindPopup(title);
-    }
-    if (infoWindow) {
-      this.createInfoWindow({ definition: infoWindow, element: polyline2 });
-    }
-    return polyline2;
-  }
-  doRemovePolyline(polyline2) {
-    polyline2.remove();
-  }
-  doCreateCircle({ definition }) {
-    const { "@id": _id, center, radius, title, infoWindow, rawOptions = {}, bridgeOptions = {} } = definition;
-    const circle2 = L.circle(center, { radius, ...rawOptions, ...bridgeOptions }).addTo(this.map);
-    if (title) {
-      circle2.bindPopup(title);
-    }
-    if (infoWindow) {
-      this.createInfoWindow({ definition: infoWindow, element: circle2 });
-    }
-    return circle2;
-  }
-  doRemoveCircle(circle2) {
-    circle2.remove();
-  }
-  doCreateRectangle({ definition }) {
-    const { "@id": _id, southWest, northEast, title, infoWindow, rawOptions = {}, bridgeOptions = {} } = definition;
-    const rectangle2 = L.rectangle(
-      [
-        [southWest.lat, southWest.lng],
-        [northEast.lat, northEast.lng]
-      ],
-      { ...rawOptions, ...bridgeOptions }
-    ).addTo(this.map);
-    if (title) {
-      rectangle2.bindPopup(title);
-    }
-    if (infoWindow) {
-      this.createInfoWindow({ definition: infoWindow, element: rectangle2 });
-    }
-    return rectangle2;
-  }
-  doRemoveRectangle(rectangle2) {
-    rectangle2.remove();
-  }
-  doCreateInfoWindow({
-    definition,
-    element
-  }) {
-    const { headerContent, content, opened, autoClose, rawOptions = {}, bridgeOptions = {} } = definition;
-    element.bindPopup([headerContent, content].filter((x) => x).join("<br>"), { ...rawOptions, ...bridgeOptions });
-    if (opened) {
-      if (autoClose) {
-        this.closePopups();
-      }
-      setTimeout(() => element.openPopup(), 0);
-    }
-    const popup = element.getPopup();
-    if (!popup) {
-      throw new Error("Unable to get the Popup associated with the element.");
-    }
-    popup.on("click", () => {
-      if (autoClose) {
-        this.closePopups({ except: popup });
-      }
-    });
-    return popup;
-  }
-  doCreateIcon({ definition, element }) {
-    const { type, width, height } = definition;
-    let icon2;
-    if (type === IconTypes.Svg) {
-      icon2 = L.divIcon({
-        html: definition.html,
-        iconSize: [width, height],
-        className: ""
-        // Adding an empty class to the icon to avoid the default Leaflet styles
-      });
-    } else if (type === IconTypes.UxIcon) {
-      icon2 = L.divIcon({
-        html: definition._generated_html,
-        iconSize: [width, height],
-        className: ""
-        // Adding an empty class to the icon to avoid the default Leaflet styles
-      });
-    } else if (type === IconTypes.Url) {
-      icon2 = L.icon({
-        iconUrl: definition.url,
-        iconSize: [width, height],
-        className: ""
-        // Adding an empty class to the icon to avoid the default Leaflet styles
-      });
-    } else {
-      throw new Error(`Unsupported icon type: ${type}.`);
-    }
-    element.setIcon(icon2);
-  }
-  doFitBoundsToMarkers() {
-    if (this.markers.size === 0) {
-      return;
-    }
-    const bounds = [];
-    this.markers.forEach((marker2) => {
-      const position = marker2.getLatLng();
-      bounds.push([position.lat, position.lng]);
-    });
-    this.map.fitBounds(bounds);
-  }
-  closePopups(options = {}) {
-    this.infoWindows.forEach((popup) => {
-      if (options.except && popup === options.except) {
-        return;
-      }
-      popup.close();
-    });
-  }
+const IconTypes = {
+	Url: "url",
+	Svg: "svg",
+	UxIcon: "ux-icon"
+};
+var _Class = class extends Controller {
+	constructor(..._args) {
+		super(..._args);
+		this.markers = /* @__PURE__ */ new Map();
+		this.polygons = /* @__PURE__ */ new Map();
+		this.polylines = /* @__PURE__ */ new Map();
+		this.circles = /* @__PURE__ */ new Map();
+		this.rectangles = /* @__PURE__ */ new Map();
+		this.infoWindows = [];
+		this.isConnected = false;
+	}
+	connect() {
+		const extra = this.hasExtraValue ? this.extraValue : {};
+		const mapDefinition = {
+			center: this.hasCenterValue ? this.centerValue : null,
+			zoom: this.hasZoomValue ? this.zoomValue : null,
+			minZoom: this.hasMinZoomValue ? this.minZoomValue : null,
+			maxZoom: this.hasMaxZoomValue ? this.maxZoomValue : null,
+			options: this.optionsValue,
+			extra
+		};
+		this.dispatchEvent("pre-connect", mapDefinition);
+		this.createMarker = this.createDrawingFactory("marker", this.markers, this.doCreateMarker.bind(this));
+		this.createPolygon = this.createDrawingFactory("polygon", this.polygons, this.doCreatePolygon.bind(this));
+		this.createPolyline = this.createDrawingFactory("polyline", this.polylines, this.doCreatePolyline.bind(this));
+		this.createCircle = this.createDrawingFactory("circle", this.circles, this.doCreateCircle.bind(this));
+		this.createRectangle = this.createDrawingFactory("rectangle", this.rectangles, this.doCreateRectangle.bind(this));
+		this.map = this.doCreateMap({ definition: mapDefinition });
+		this.markersValue.forEach((definition) => {
+			this.createMarker({ definition });
+		});
+		this.polygonsValue.forEach((definition) => {
+			this.createPolygon({ definition });
+		});
+		this.polylinesValue.forEach((definition) => {
+			this.createPolyline({ definition });
+		});
+		this.circlesValue.forEach((definition) => {
+			this.createCircle({ definition });
+		});
+		this.rectanglesValue.forEach((definition) => {
+			this.createRectangle({ definition });
+		});
+		if (this.fitBoundsToMarkersValue) this.doFitBoundsToMarkers();
+		this.dispatchEvent("connect", {
+			map: this.map,
+			markers: [...this.markers.values()],
+			polygons: [...this.polygons.values()],
+			polylines: [...this.polylines.values()],
+			circles: [...this.circles.values()],
+			rectangles: [...this.rectangles.values()],
+			infoWindows: this.infoWindows,
+			extra
+		});
+		this.isConnected = true;
+	}
+	createInfoWindow({ definition, element }) {
+		this.dispatchEvent("info-window:before-create", {
+			definition,
+			element
+		});
+		const infoWindow = this.doCreateInfoWindow({
+			definition,
+			element
+		});
+		this.dispatchEvent("info-window:after-create", {
+			infoWindow,
+			definition,
+			element
+		});
+		this.infoWindows.push(infoWindow);
+		return infoWindow;
+	}
+	markersValueChanged() {
+		if (!this.isConnected) return;
+		this.onDrawChanged(this.markers, this.markersValue, this.createMarker, this.doRemoveMarker);
+		if (this.fitBoundsToMarkersValue) this.doFitBoundsToMarkers();
+	}
+	polygonsValueChanged() {
+		if (!this.isConnected) return;
+		this.onDrawChanged(this.polygons, this.polygonsValue, this.createPolygon, this.doRemovePolygon);
+	}
+	polylinesValueChanged() {
+		if (!this.isConnected) return;
+		this.onDrawChanged(this.polylines, this.polylinesValue, this.createPolyline, this.doRemovePolyline);
+	}
+	circlesValueChanged() {
+		if (!this.isConnected) return;
+		this.onDrawChanged(this.circles, this.circlesValue, this.createCircle, this.doRemoveCircle);
+	}
+	rectanglesValueChanged() {
+		if (!this.isConnected) return;
+		this.onDrawChanged(this.rectangles, this.rectanglesValue, this.createRectangle, this.doRemoveRectangle);
+	}
+	createDrawingFactory(type, draws, factory) {
+		const eventBefore = `${type}:before-create`;
+		const eventAfter = `${type}:after-create`;
+		return ({ definition }) => {
+			this.dispatchEvent(eventBefore, { definition });
+			if (typeof definition.rawOptions !== "undefined") console.warn(`[Symfony UX Map] The event "${eventBefore}" added a deprecated "rawOptions" property to the definition, it will be removed in a next major version, replace it with "bridgeOptions" instead.`, definition);
+			const drawing = factory({ definition });
+			this.dispatchEvent(eventAfter, {
+				[type]: drawing,
+				definition
+			});
+			draws.set(definition["@id"], drawing);
+			return drawing;
+		};
+	}
+	onDrawChanged(draws, newDrawDefinitions, factory, remover) {
+		const idsToRemove = new Set(draws.keys());
+		newDrawDefinitions.forEach((definition) => {
+			idsToRemove.delete(definition["@id"]);
+		});
+		idsToRemove.forEach((id) => {
+			remover(draws.get(id));
+			draws.delete(id);
+		});
+		newDrawDefinitions.forEach((definition) => {
+			if (!draws.has(definition["@id"])) factory({ definition });
+		});
+	}
+};
+_Class.values = {
+	providerOptions: Object,
+	center: Object,
+	zoom: Number,
+	minZoom: Number,
+	maxZoom: Number,
+	fitBoundsToMarkers: Boolean,
+	markers: Array,
+	polygons: Array,
+	polylines: Array,
+	circles: Array,
+	rectangles: Array,
+	options: Object,
+	extra: Object
 };
-export {
-  map_controller_default as default
+var map_controller_default = class extends _Class {
+	connect() {
+		L.Marker.prototype.options.icon = L.divIcon({
+			html: "<svg xmlns=\"http://www.w3.org/2000/svg\" xml:space=\"preserve\" fill-rule=\"evenodd\" stroke-linecap=\"round\" clip-rule=\"evenodd\" viewBox=\"0 0 500 820\"><defs><linearGradient id=\"__sf_ux_map_gradient_marker_fill\" x1=\"0\" x2=\"1\" y1=\"0\" y2=\"0\" gradientTransform=\"matrix(0 -37.57 37.57 0 416.45 541)\" gradientUnits=\"userSpaceOnUse\"><stop offset=\"0\" stop-color=\"#126FC6\"/><stop offset=\"1\" stop-color=\"#4C9CD1\"/></linearGradient><linearGradient id=\"__sf_ux_map_gradient_marker_border\" x1=\"0\" x2=\"1\" y1=\"0\" y2=\"0\" gradientTransform=\"matrix(0 -19.05 19.05 0 414.48 522.49)\" gradientUnits=\"userSpaceOnUse\"><stop offset=\"0\" stop-color=\"#2E6C97\"/><stop offset=\"1\" stop-color=\"#3883B7\"/></linearGradient></defs><circle cx=\"252.31\" cy=\"266.24\" r=\"83.99\" fill=\"#fff\"/><path fill=\"url(#__sf_ux_map_gradient_marker_fill)\" stroke=\"url(#__sf_ux_map_gradient_marker_border)\" stroke-width=\"1.1\" d=\"M416.54 503.61c-6.57 0-12.04 5.7-12.04 11.87 0 2.78 1.56 6.3 2.7 8.74l9.3 17.88 9.26-17.88c1.13-2.43 2.74-5.79 2.74-8.74 0-6.18-5.38-11.87-11.96-11.87Zm0 7.16a4.69 4.69 0 1 1-.02 9.4 4.69 4.69 0 0 1 .02-9.4Z\" transform=\"translate(-7889.1 -9807.44) scale(19.54)\"/></svg>",
+			iconSize: [25, 41],
+			iconAnchor: [12.5, 41],
+			popupAnchor: [0, -41],
+			className: ""
+		});
+		super.connect();
+	}
+	centerValueChanged() {
+		if (this.map && this.hasCenterValue && this.centerValue && this.hasZoomValue && this.zoomValue) this.map.setView(this.centerValue, this.zoomValue);
+	}
+	zoomValueChanged() {
+		if (this.map && this.hasZoomValue && this.zoomValue) this.map.setZoom(this.zoomValue);
+	}
+	minZoomValueChanged() {
+		if (this.map && this.hasMinZoomValue && this.minZoomValue) this.map.setMinZoom(this.minZoomValue);
+	}
+	maxZoomValueChanged() {
+		if (this.map && this.hasMaxZoomValue && this.maxZoomValue) this.map.setMaxZoom(this.maxZoomValue);
+	}
+	dispatchEvent(name, payload = {}) {
+		payload.L = L;
+		this.dispatch(name, {
+			prefix: "ux:map",
+			detail: payload
+		});
+	}
+	doCreateMap({ definition }) {
+		const { center, zoom, minZoom, maxZoom, options, bridgeOptions = {} } = definition;
+		const map = L.map(this.element, {
+			center: center === null ? void 0 : center,
+			zoom: zoom === null ? void 0 : zoom,
+			minZoom: minZoom === null ? void 0 : minZoom,
+			maxZoom: maxZoom === null ? void 0 : maxZoom,
+			attributionControl: false,
+			zoomControl: false,
+			...options,
+			...bridgeOptions
+		});
+		if (options.tileLayer) L.tileLayer(options.tileLayer.url, {
+			attribution: options.tileLayer.attribution,
+			...options.tileLayer.options
+		}).addTo(map);
+		if (typeof options.attributionControlOptions !== "undefined") L.control.attribution({ ...options.attributionControlOptions }).addTo(map);
+		if (typeof options.zoomControlOptions !== "undefined") L.control.zoom({ ...options.zoomControlOptions }).addTo(map);
+		return map;
+	}
+	doCreateMarker({ definition }) {
+		const { "@id": _id, position, title, infoWindow, icon, rawOptions = {}, bridgeOptions = {} } = definition;
+		const marker = L.marker(position, {
+			title: title || void 0,
+			...rawOptions,
+			...bridgeOptions,
+			riseOnHover: true
+		}).addTo(this.map);
+		if (infoWindow) this.createInfoWindow({
+			definition: infoWindow,
+			element: marker
+		});
+		if (icon) {
+			if (Object.prototype.hasOwnProperty.call(bridgeOptions, "icon")) console.warn("[Symfony UX Map] Defining \"bridgeOptions.icon\" for a marker with a custom icon is not supported and will be ignored.");
+			else if (Object.prototype.hasOwnProperty.call(rawOptions, "icon")) console.warn("[Symfony UX Map] Defining \"rawOptions.icon\" for a marker with a custom icon is not supported and will be ignored.");
+			this.doCreateIcon({
+				definition: icon,
+				element: marker
+			});
+		}
+		return marker;
+	}
+	doRemoveMarker(marker) {
+		marker.remove();
+	}
+	doCreatePolygon({ definition }) {
+		const { "@id": _id, points, title, infoWindow, rawOptions = {}, bridgeOptions = {} } = definition;
+		const polygon = L.polygon(points, {
+			...rawOptions,
+			...bridgeOptions
+		}).addTo(this.map);
+		/**
+		* @deprecated since Symfony UX Map 2.29
+		*/
+		if (title) polygon.bindPopup(title);
+		if (infoWindow) this.createInfoWindow({
+			definition: infoWindow,
+			element: polygon
+		});
+		return polygon;
+	}
+	doRemovePolygon(polygon) {
+		polygon.remove();
+	}
+	doCreatePolyline({ definition }) {
+		const { "@id": _id, points, title, infoWindow, rawOptions = {}, bridgeOptions = {} } = definition;
+		const polyline = L.polyline(points, {
+			...rawOptions,
+			...bridgeOptions
+		}).addTo(this.map);
+		/**
+		* @deprecated since Symfony UX Map 2.29
+		*/
+		if (title) polyline.bindPopup(title);
+		if (infoWindow) this.createInfoWindow({
+			definition: infoWindow,
+			element: polyline
+		});
+		return polyline;
+	}
+	doRemovePolyline(polyline) {
+		polyline.remove();
+	}
+	doCreateCircle({ definition }) {
+		const { "@id": _id, center, radius, title, infoWindow, rawOptions = {}, bridgeOptions = {} } = definition;
+		const circle = L.circle(center, {
+			radius,
+			...rawOptions,
+			...bridgeOptions
+		}).addTo(this.map);
+		/**
+		* @deprecated since Symfony UX Map 2.29
+		*/
+		if (title) circle.bindPopup(title);
+		if (infoWindow) this.createInfoWindow({
+			definition: infoWindow,
+			element: circle
+		});
+		return circle;
+	}
+	doRemoveCircle(circle) {
+		circle.remove();
+	}
+	doCreateRectangle({ definition }) {
+		const { "@id": _id, southWest, northEast, title, infoWindow, rawOptions = {}, bridgeOptions = {} } = definition;
+		const rectangle = L.rectangle([[southWest.lat, southWest.lng], [northEast.lat, northEast.lng]], {
+			...rawOptions,
+			...bridgeOptions
+		}).addTo(this.map);
+		/**
+		* @deprecated since Symfony UX Map 2.29
+		*/
+		if (title) rectangle.bindPopup(title);
+		if (infoWindow) this.createInfoWindow({
+			definition: infoWindow,
+			element: rectangle
+		});
+		return rectangle;
+	}
+	doRemoveRectangle(rectangle) {
+		rectangle.remove();
+	}
+	doCreateInfoWindow({ definition, element }) {
+		const { headerContent, content, opened, autoClose, rawOptions = {}, bridgeOptions = {} } = definition;
+		element.bindPopup([headerContent, content].filter((x) => x).join("<br>"), {
+			...rawOptions,
+			...bridgeOptions
+		});
+		if (opened) {
+			if (autoClose) this.closePopups();
+			setTimeout(() => element.openPopup(), 0);
+		}
+		const popup = element.getPopup();
+		if (!popup) throw new Error("Unable to get the Popup associated with the element.");
+		popup.on("click", () => {
+			if (autoClose) this.closePopups({ except: popup });
+		});
+		return popup;
+	}
+	doCreateIcon({ definition, element }) {
+		const { type, width, height } = definition;
+		let icon;
+		if (type === IconTypes.Svg) icon = L.divIcon({
+			html: definition.html,
+			iconSize: [width, height],
+			className: ""
+		});
+		else if (type === IconTypes.UxIcon) icon = L.divIcon({
+			html: definition._generated_html,
+			iconSize: [width, height],
+			className: ""
+		});
+		else if (type === IconTypes.Url) icon = L.icon({
+			iconUrl: definition.url,
+			iconSize: [width, height],
+			className: ""
+		});
+		else throw new Error(`Unsupported icon type: ${type}.`);
+		element.setIcon(icon);
+	}
+	doFitBoundsToMarkers() {
+		if (this.markers.size === 0) return;
+		const bounds = [];
+		this.markers.forEach((marker) => {
+			const position = marker.getLatLng();
+			bounds.push([position.lat, position.lng]);
+		});
+		this.map.fitBounds(bounds);
+	}
+	closePopups(options = {}) {
+		this.infoWindows.forEach((popup) => {
+			if (options.except && popup === options.except) return;
+			popup.close();
+		});
+	}
 };
+export { map_controller_default as default };

package/package.json

@@ -2,14 +2,14 @@
   "name": "@symfony/ux-leaflet-map",
   "description": "Leaflet bridge for Symfony UX Map, integrate interactive maps in your Symfony applications",
   "license": "MIT",
-  "version": "2.32.0",
+  "version": "2.34.0",
   "keywords": [
     "symfony-ux",
     "leaflet",
     "map"
   ],
   "homepage": "https://ux.symfony.com/map",
-  "repository": "https://github.com/symfony/ux-leaflet-map",
+  "repository": "https://github.com/symfony/ux",
   "type": "module",
   "files": [
     "dist"
@@ -46,21 +46,16 @@
     "@testing-library/jest-dom": "^6.6.3",
     "@testing-library/user-event": "^14.6.1",
     "@types/leaflet": "^1.9.12",
-    "@vitest/browser": "^3.2.4",
     "jsdom": "^26.1.0",
     "leaflet": "^1.9.4",
     "tslib": "^2.8.1",
-    "tsx": "^4.20.3",
-    "typescript": "^5.8.3",
-    "vitest": "^3.2.4"
+    "typescript": "^5.8.3"
   },
   "scripts": {
-    "build": "tsx ../../../../../../bin/build_package.ts .",
-    "watch": "tsx ../../../../../../bin/build_package.ts . --watch",
+    "build": "node ../../../../../../bin/build_package.ts .",
+    "watch": "node ../../../../../../bin/build_package.ts . --watch",
     "test": "pnpm run test:browser",
     "test:browser": "playwright test",
-    "test:browser:ui": "playwright test --ui",
-    "check": "biome check",
-    "ci": "biome ci"
+    "test:browser:ui": "playwright test --ui"
   }
 }