@regardio/react 0.3.3 → 0.4.0

package/dist/components/leaflet-map.d.ts

@@ -1,4 +1,5 @@
-import 'leaflet/dist/leaflet.css';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+
 interface MapMarker {
     lat: number;
     lng: number;
@@ -28,6 +29,6 @@ interface LeafletMapProps {
     attribution?: string;
     showPopupsOnHover?: boolean;
 }
-export declare const LeafletMap: ({ markers, mapUrl, center, zoom, icon, attribution, showPopupsOnHover, }: LeafletMapProps) => import("react/jsx-runtime").JSX.Element;
-export default LeafletMap;
-//# sourceMappingURL=leaflet-map.d.ts.map
+declare const LeafletMap: ({ markers, mapUrl, center, zoom, icon, attribution, showPopupsOnHover, }: LeafletMapProps) => react_jsx_runtime.JSX.Element;
+
+export { LeafletMap, LeafletMap as default };

package/dist/components/leaflet-map.js

@@ -1,195 +1,201 @@
-import { jsx as _jsx } from "react/jsx-runtime";
 import 'leaflet/dist/leaflet.css';
 import L from 'leaflet';
-import { useEffect, useRef } from 'react';
-export const LeafletMap = ({ markers, mapUrl, center, zoom = 12, icon = {
+import { useRef, useEffect } from 'react';
+import { jsx } from 'react/jsx-runtime';
+
+// src/components/leaflet-map.tsx
+var LeafletMap = ({
+  markers,
+  mapUrl,
+  center,
+  zoom = 12,
+  icon = {
     iconAnchor: [12, 41],
     iconSize: [25, 41],
-    iconUrl: '/marker-icon-2x.png',
-}, attribution = '', showPopupsOnHover = false, }) => {
-    const mapContainerRef = useRef(null);
-    const mapRef = useRef(null);
-    const markersRef = useRef([]);
-    useEffect(() => {
-        if (!mapContainerRef.current || typeof window === 'undefined')
-            return;
-        let calculatedCenter;
-        if (center) {
-            calculatedCenter = [center.lat, center.lng];
-        }
-        else if (markers.length > 0) {
-            const firstMarker = markers[0];
-            if (firstMarker) {
-                calculatedCenter = [firstMarker.lat, firstMarker.lng];
-            }
-            else {
-                calculatedCenter = [52.520008, 13.404954];
-            }
-        }
-        else {
-            calculatedCenter = [52.520008, 13.404954];
-        }
-        if (mapRef.current) {
-            try {
-                markersRef.current.forEach((marker) => {
-                    try {
-                        mapRef.current?.removeLayer(marker);
-                    }
-                    catch (_error) {
-                    }
-                });
-                mapRef.current.remove();
-            }
-            catch (_error) {
-            }
-        }
-        const container = mapContainerRef.current;
-        if (container) {
-            container.innerHTML = '';
-            const leafletContainer = container;
-            if (leafletContainer._leaflet_id) {
-                delete leafletContainer._leaflet_id;
-            }
-            container.setAttribute('data-map-initialized', 'false');
-        }
-        const map = new L.Map(mapContainerRef.current, {
-            center: calculatedCenter,
-            scrollWheelZoom: false,
-            tapTolerance: 100,
-            zoom: zoom,
-        });
-        new L.TileLayer(mapUrl, {
-            attribution,
-        }).addTo(map);
-        const customIcon = new L.Icon({
-            iconAnchor: icon.iconAnchor,
-            iconSize: icon.iconSize,
-            iconUrl: icon.iconUrl,
-        });
-        const newMarkers = [];
-        markers.forEach((marker) => {
-            const markerLatLng = [marker.lat, marker.lng];
-            const leafletMarker = new L.Marker(markerLatLng, {
-                icon: customIcon,
-            }).addTo(map);
-            const offset = marker.offset || { x: 0, y: 0 };
-            let popupContent = '';
-            if (marker.htmlContent) {
-                popupContent = marker.htmlContent;
-            }
-            else if (marker.content) {
-                popupContent = marker.content;
-            }
-            if (marker.imageUrl) {
-                const imageHtml = `<img src="${marker.imageUrl}" alt="${marker.imageAlt || ''}" style="max-width: 100%; height: auto; display: block; margin-bottom: 8px;" />`;
-                popupContent = imageHtml + popupContent;
-            }
-            if (popupContent) {
-                const popup = new L.Popup({
-                    className: 'custom-map-popup',
-                    closeButton: false,
-                    offset: [offset.x, offset.y],
-                }).setContent(popupContent);
-                leafletMarker.bindPopup(popup);
-                if (showPopupsOnHover) {
-                    leafletMarker.on('mouseover', () => {
-                        leafletMarker.openPopup();
-                    });
-                    leafletMarker.on('mouseout', () => {
-                        leafletMarker.closePopup();
-                    });
-                }
-            }
-            newMarkers.push(leafletMarker);
+    iconUrl: "/marker-icon-2x.png"
+  },
+  attribution = "",
+  showPopupsOnHover = false
+}) => {
+  const mapContainerRef = useRef(null);
+  const mapRef = useRef(null);
+  const markersRef = useRef([]);
+  useEffect(() => {
+    if (!mapContainerRef.current || typeof window === "undefined") return;
+    let calculatedCenter;
+    if (center) {
+      calculatedCenter = [center.lat, center.lng];
+    } else if (markers.length > 0) {
+      const firstMarker = markers[0];
+      if (firstMarker) {
+        calculatedCenter = [firstMarker.lat, firstMarker.lng];
+      } else {
+        calculatedCenter = [52.520008, 13.404954];
+      }
+    } else {
+      calculatedCenter = [52.520008, 13.404954];
+    }
+    if (mapRef.current) {
+      try {
+        markersRef.current.forEach((marker) => {
+          try {
+            mapRef.current?.removeLayer(marker);
+          } catch (_error) {
+          }
         });
-        markersRef.current = newMarkers;
-        if (markers.length > 0) {
-            const bounds = new L.LatLngBounds(markers.map((m) => new L.LatLng(m.lat, m.lng)));
-            map.fitBounds(bounds, { padding: [20, 20] });
+        mapRef.current.remove();
+      } catch (_error) {
+      }
+    }
+    const container = mapContainerRef.current;
+    if (container) {
+      container.innerHTML = "";
+      const leafletContainer = container;
+      if (leafletContainer._leaflet_id) {
+        delete leafletContainer._leaflet_id;
+      }
+      container.setAttribute("data-map-initialized", "false");
+    }
+    const map = new L.Map(mapContainerRef.current, {
+      center: calculatedCenter,
+      scrollWheelZoom: false,
+      tapTolerance: 100,
+      zoom
+    });
+    new L.TileLayer(mapUrl, {
+      attribution
+    }).addTo(map);
+    const customIcon = new L.Icon({
+      iconAnchor: icon.iconAnchor,
+      iconSize: icon.iconSize,
+      iconUrl: icon.iconUrl
+    });
+    const newMarkers = [];
+    markers.forEach((marker) => {
+      const markerLatLng = [marker.lat, marker.lng];
+      const leafletMarker = new L.Marker(markerLatLng, {
+        icon: customIcon
+      }).addTo(map);
+      const offset = marker.offset || { x: 0, y: 0 };
+      let popupContent = "";
+      if (marker.htmlContent) {
+        popupContent = marker.htmlContent;
+      } else if (marker.content) {
+        popupContent = marker.content;
+      }
+      if (marker.imageUrl) {
+        const imageHtml = `<img src="${marker.imageUrl}" alt="${marker.imageAlt || ""}" style="max-width: 100%; height: auto; display: block; margin-bottom: 8px;" />`;
+        popupContent = imageHtml + popupContent;
+      }
+      if (popupContent) {
+        const popup = new L.Popup({
+          className: "custom-map-popup",
+          closeButton: false,
+          offset: [offset.x, offset.y]
+        }).setContent(popupContent);
+        leafletMarker.bindPopup(popup);
+        if (showPopupsOnHover) {
+          leafletMarker.on("mouseover", () => {
+            leafletMarker.openPopup();
+          });
+          leafletMarker.on("mouseout", () => {
+            leafletMarker.closePopup();
+          });
         }
-        mapRef.current = map;
-        return () => {
-            if (mapRef.current) {
-                try {
-                    markersRef.current.forEach((marker) => {
-                        try {
-                            mapRef.current?.removeLayer(marker);
-                        }
-                        catch (_error) {
-                        }
-                    });
-                    mapRef.current.remove();
-                    mapRef.current = null;
-                    if (mapContainerRef.current) {
-                        mapContainerRef.current.innerHTML = '';
-                        mapContainerRef.current.removeAttribute('data-map-initialized');
-                    }
-                }
-                catch (_error) {
-                }
-            }
-            markersRef.current = [];
-        };
-    }, [markers, mapUrl, zoom, icon, attribution, center, showPopupsOnHover]);
-    useEffect(() => {
-        const map = mapRef.current;
-        if (!map || typeof window === 'undefined')
-            return;
-        markersRef.current.forEach((marker) => {
+      }
+      newMarkers.push(leafletMarker);
+    });
+    markersRef.current = newMarkers;
+    if (markers.length > 0) {
+      const bounds = new L.LatLngBounds(markers.map((m) => new L.LatLng(m.lat, m.lng)));
+      map.fitBounds(bounds, { padding: [20, 20] });
+    }
+    mapRef.current = map;
+    return () => {
+      if (mapRef.current) {
+        try {
+          markersRef.current.forEach((marker) => {
             try {
-                map.removeLayer(marker);
-            }
-            catch (_error) {
-            }
-        });
-        markersRef.current = [];
-        const customIcon = new L.Icon({
-            iconAnchor: icon.iconAnchor,
-            iconSize: icon.iconSize,
-            iconUrl: icon.iconUrl,
-        });
-        const newMarkers = [];
-        markers.forEach((marker) => {
-            const markerLatLng = [marker.lat, marker.lng];
-            const leafletMarker = new L.Marker(markerLatLng, {
-                icon: customIcon,
-            }).addTo(map);
-            const offset = marker.offset || { x: 0, y: 0 };
-            let popupContent = '';
-            if (marker.htmlContent) {
-                popupContent = marker.htmlContent;
-            }
-            else if (marker.content) {
-                popupContent = marker.content;
-            }
-            if (marker.imageUrl) {
-                const imageHtml = `<img src="${marker.imageUrl}" alt="${marker.imageAlt || ''}" style="max-width: 100%; height: auto; display: block; margin-bottom: 8px;" />`;
-                popupContent = imageHtml + popupContent;
-            }
-            if (popupContent) {
-                const popup = new L.Popup({
-                    className: 'custom-map-popup',
-                    closeButton: false,
-                    offset: [offset.x, offset.y],
-                }).setContent(popupContent);
-                leafletMarker.bindPopup(popup);
-                if (showPopupsOnHover) {
-                    leafletMarker.on('mouseover', () => {
-                        leafletMarker.openPopup();
-                    });
-                    leafletMarker.on('mouseout', () => {
-                        leafletMarker.closePopup();
-                    });
-                }
-            }
-            newMarkers.push(leafletMarker);
-        });
-        markersRef.current = newMarkers;
-        if (markers.length > 0) {
-            const bounds = new L.LatLngBounds(markers.map((m) => new L.LatLng(m.lat, m.lng)));
-            map.fitBounds(bounds, { padding: [20, 20] });
+              mapRef.current?.removeLayer(marker);
+            } catch (_error) {
+            }
+          });
+          mapRef.current.remove();
+          mapRef.current = null;
+          if (mapContainerRef.current) {
+            mapContainerRef.current.innerHTML = "";
+            mapContainerRef.current.removeAttribute("data-map-initialized");
+          }
+        } catch (_error) {
+        }
+      }
+      markersRef.current = [];
+    };
+  }, [markers, mapUrl, zoom, icon, attribution, center, showPopupsOnHover]);
+  useEffect(() => {
+    const map = mapRef.current;
+    if (!map || typeof window === "undefined") return;
+    markersRef.current.forEach((marker) => {
+      try {
+        map.removeLayer(marker);
+      } catch (_error) {
+      }
+    });
+    markersRef.current = [];
+    const customIcon = new L.Icon({
+      iconAnchor: icon.iconAnchor,
+      iconSize: icon.iconSize,
+      iconUrl: icon.iconUrl
+    });
+    const newMarkers = [];
+    markers.forEach((marker) => {
+      const markerLatLng = [marker.lat, marker.lng];
+      const leafletMarker = new L.Marker(markerLatLng, {
+        icon: customIcon
+      }).addTo(map);
+      const offset = marker.offset || { x: 0, y: 0 };
+      let popupContent = "";
+      if (marker.htmlContent) {
+        popupContent = marker.htmlContent;
+      } else if (marker.content) {
+        popupContent = marker.content;
+      }
+      if (marker.imageUrl) {
+        const imageHtml = `<img src="${marker.imageUrl}" alt="${marker.imageAlt || ""}" style="max-width: 100%; height: auto; display: block; margin-bottom: 8px;" />`;
+        popupContent = imageHtml + popupContent;
+      }
+      if (popupContent) {
+        const popup = new L.Popup({
+          className: "custom-map-popup",
+          closeButton: false,
+          offset: [offset.x, offset.y]
+        }).setContent(popupContent);
+        leafletMarker.bindPopup(popup);
+        if (showPopupsOnHover) {
+          leafletMarker.on("mouseover", () => {
+            leafletMarker.openPopup();
+          });
+          leafletMarker.on("mouseout", () => {
+            leafletMarker.closePopup();
+          });
         }
-    }, [markers, icon, showPopupsOnHover]);
-    return (_jsx("div", { className: "h-full w-full", ref: mapContainerRef }));
+      }
+      newMarkers.push(leafletMarker);
+    });
+    markersRef.current = newMarkers;
+    if (markers.length > 0) {
+      const bounds = new L.LatLngBounds(markers.map((m) => new L.LatLng(m.lat, m.lng)));
+      map.fitBounds(bounds, { padding: [20, 20] });
+    }
+  }, [markers, icon, showPopupsOnHover]);
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      className: "h-full w-full",
+      ref: mapContainerRef
+    }
+  );
 };
-export default LeafletMap;
+var leaflet_map_default = LeafletMap;
+
+export { LeafletMap, leaflet_map_default as default };

package/dist/components/link.d.ts

@@ -1,9 +1,17 @@
-import type { NavLinkProps } from 'react-router';
-import { type VariantProps } from '../utils/cn';
-export type PathResolver = (routeKey: string) => string;
-export declare const PathResolverProvider: import("react").Provider<PathResolver | null>;
-export declare function usePathResolver(): PathResolver | null;
-export interface LinkBaseProps extends Omit<NavLinkProps, 'to'> {
+import * as cva from 'cva';
+import { VariantProps } from 'cva';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as react from 'react';
+import { NavLinkProps } from 'react-router';
+
+/**
+ * Context for providing a path resolver function.
+ * This allows projects to inject their own localization logic.
+ */
+type PathResolver = (routeKey: string) => string;
+declare const PathResolverProvider: react.Provider<PathResolver | null>;
+declare function usePathResolver(): PathResolver | null;
+interface LinkBaseProps extends Omit<NavLinkProps, 'to'> {
     to?: string | Partial<{
         pathname?: string;
         search?: string;
@@ -12,18 +20,18 @@ export interface LinkBaseProps extends Omit<NavLinkProps, 'to'> {
     routeKey?: string;
     viewTransition?: boolean;
 }
-export declare const LinkBase: ({ className, to, routeKey, children, onClick, viewTransition, ...props }: LinkBaseProps) => import("react/jsx-runtime").JSX.Element;
+declare const LinkBase: ({ className, to, routeKey, children, onClick, viewTransition, ...props }: LinkBaseProps) => react_jsx_runtime.JSX.Element;
 declare const link: (props?: ({
     arrow?: "darr" | "larr" | "rarr" | "uarr" | undefined;
-    variant?: "code" | "link" | "button" | "primary" | "navtitle" | "subtitle" | undefined;
+    variant?: "link" | "button" | "primary" | "code" | "navtitle" | "subtitle" | undefined;
 } & ({
-    class?: import("cva").ClassValue;
+    class?: cva.ClassValue;
     className?: never;
 } | {
     class?: never;
-    className?: import("cva").ClassValue;
+    className?: cva.ClassValue;
 })) | undefined) => string;
-export interface LinkProps extends Omit<NavLinkProps, 'to'>, VariantProps<typeof link> {
+interface LinkProps extends Omit<NavLinkProps, 'to'>, VariantProps<typeof link> {
     to?: string | Partial<{
         pathname?: string;
         search?: string;
@@ -32,10 +40,10 @@ export interface LinkProps extends Omit<NavLinkProps, 'to'>, VariantProps<typeof
     routeKey?: string;
     viewTransition?: boolean;
 }
-export declare const Link: ({ arrow, children, className, routeKey, to, variant, viewTransition, ...props }: LinkProps) => import("react/jsx-runtime").JSX.Element;
-export interface MarkdownLinkProps extends Omit<LinkProps, 'to'> {
+declare const Link: ({ arrow, children, className, routeKey, to, variant, viewTransition, ...props }: LinkProps) => react_jsx_runtime.JSX.Element;
+interface MarkdownLinkProps extends Omit<LinkProps, 'to'> {
     href?: string;
 }
-export declare const MarkdownLink: React.FC<MarkdownLinkProps>;
-export {};
-//# sourceMappingURL=link.d.ts.map
+declare const MarkdownLink: React.FC<MarkdownLinkProps>;
+
+export { Link, LinkBase, type LinkBaseProps, type LinkProps, MarkdownLink, type MarkdownLinkProps, type PathResolver, PathResolverProvider, usePathResolver };