@regardio/react 0.3.2

package/dist/components/leaflet-map.js

@@ -0,0 +1,195 @@
+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 = {
+    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);
+        });
+        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 {
+                            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();
+                    });
+                }
+            }
+            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 (_jsx("div", { className: "h-full w-full", ref: mapContainerRef }));
+};
+export default LeafletMap;

package/dist/components/link.d.ts

@@ -0,0 +1,41 @@
+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'> {
+    to?: string | Partial<{
+        pathname?: string;
+        search?: string;
+        hash?: string;
+    }> | undefined;
+    routeKey?: string;
+    viewTransition?: boolean;
+}
+export declare const LinkBase: ({ className, to, routeKey, children, onClick, viewTransition, ...props }: LinkBaseProps) => import("react/jsx-runtime").JSX.Element;
+declare const link: (props?: ({
+    arrow?: "darr" | "larr" | "rarr" | "uarr" | undefined;
+    variant?: "code" | "link" | "button" | "primary" | "navtitle" | "subtitle" | undefined;
+} & ({
+    class?: import("cva").ClassValue;
+    className?: never;
+} | {
+    class?: never;
+    className?: import("cva").ClassValue;
+})) | undefined) => string;
+export interface LinkProps extends Omit<NavLinkProps, 'to'>, VariantProps<typeof link> {
+    to?: string | Partial<{
+        pathname?: string;
+        search?: string;
+        hash?: string;
+    }>;
+    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'> {
+    href?: string;
+}
+export declare const MarkdownLink: React.FC<MarkdownLinkProps>;
+export {};
+//# sourceMappingURL=link.d.ts.map

package/dist/components/link.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"link.d.ts","sourceRoot":"","sources":["../../src/components/link.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAsB,MAAM,cAAc,CAAC;AAErE,OAAO,EAAO,KAAK,YAAY,EAAE,MAAM,aAAa,CAAC;AAOrD,MAAM,MAAM,YAAY,GAAG,CAAC,QAAQ,EAAE,MAAM,KAAK,MAAM,CAAC;AAIxD,eAAO,MAAM,oBAAoB,+CAA+B,CAAC;AAEjE,wBAAgB,eAAe,IAAI,YAAY,GAAG,IAAI,CAErD;AAED,MAAM,WAAW,aAAc,SAAQ,IAAI,CAAC,YAAY,EAAE,IAAI,CAAC;IAC7D,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,GAAG,SAAS,CAAC;IACzF,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED,eAAO,MAAM,QAAQ,GAAI,0EAQtB,aAAa,4CAsFf,CAAC;AAEF,QAAA,MAAM,IAAI;;;;;;;;;0BA+BR,CAAC;AAEH,MAAM,WAAW,SAAU,SAAQ,IAAI,CAAC,YAAY,EAAE,IAAI,CAAC,EAAE,YAAY,CAAC,OAAO,IAAI,CAAC;IACpF,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC7E,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED,eAAO,MAAM,IAAI,GAAI,iFASlB,SAAS,4CAgBX,CAAC;AAEF,MAAM,WAAW,iBAAkB,SAAQ,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC;IAC9D,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,eAAO,MAAM,YAAY,EAAE,KAAK,CAAC,EAAE,CAAC,iBAAiB,CAapD,CAAC"}

package/dist/components/link.js

@@ -0,0 +1,111 @@
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useCallback, useContext } from 'react';
+import { NavLink } from 'react-router';
+import { cva } from '../utils/cn';
+import { lowerCaseSzett } from '../utils/text';
+const PathResolverContext = createContext(null);
+export const PathResolverProvider = PathResolverContext.Provider;
+export function usePathResolver() {
+    return useContext(PathResolverContext);
+}
+export const LinkBase = ({ className, to, routeKey, children, onClick, viewTransition = true, ...props }) => {
+    const pathResolver = usePathResolver();
+    let path;
+    if (routeKey && pathResolver) {
+        path = pathResolver(routeKey);
+    }
+    else if (typeof to === 'string') {
+        path = to;
+    }
+    else {
+        path = to?.pathname ?? '';
+        if (to?.search)
+            path += to.search;
+        if (to?.hash)
+            path += to.hash;
+    }
+    const isExternal = path.startsWith('tel:') ||
+        path.startsWith('mailto:') ||
+        path.startsWith('#') ||
+        path.startsWith('http');
+    const handleClick = useCallback((event) => {
+        onClick?.(event);
+        if (event.defaultPrevented)
+            return;
+        if (path.startsWith('tel:') || path.startsWith('mailto:')) {
+            return;
+        }
+        if (path.startsWith('#')) {
+            event.preventDefault();
+            const element = document.getElementById(path.substring(1));
+            if (element) {
+                element.scrollIntoView({ behavior: 'smooth' });
+            }
+            return;
+        }
+        if (path.startsWith('http')) {
+            event.preventDefault();
+            window.open(path, '_blank', 'noopener,noreferrer');
+            return;
+        }
+    }, [onClick, path]);
+    if (!path) {
+        return _jsx(_Fragment, { children: typeof children === 'function' ? null : children });
+    }
+    if (isExternal) {
+        const externalState = {
+            isActive: false,
+            isPending: false,
+            isTransitioning: false,
+        };
+        const resolvedClassName = typeof className === 'function' ? className(externalState) : className;
+        const resolvedStyle = typeof props.style === 'function' ? props.style(externalState) : props.style;
+        return (_jsx("a", { className: resolvedClassName, href: path, onClick: handleClick, style: resolvedStyle, children: typeof children === 'function' ? children(externalState) : children }));
+    }
+    return (_jsx(NavLink, { ...props, className: className, onClick: handleClick, to: path, viewTransition: viewTransition, children: children }));
+};
+const link = cva({
+    base: [],
+    defaultVariants: {
+        variant: 'primary',
+    },
+    variants: {
+        arrow: {
+            darr: 'darr',
+            larr: 'larr',
+            rarr: 'rarr',
+            uarr: 'uarr',
+        },
+        variant: {
+            button: [
+                'block',
+                'button',
+                'mt-s',
+                'relative',
+                'rarr',
+                'text-right',
+                'text-sm',
+                'tracking-wider',
+                'uppercase',
+            ],
+            code: ['font-monospace'],
+            link: ['rarr', '!bg-transparent', 'uppercase', '!tracking-wider'],
+            navtitle: ['block', 'uppercase', 'tracking-wider'],
+            primary: [],
+            subtitle: ['text-lg'],
+        },
+    },
+});
+export const Link = ({ arrow, children, className, routeKey, to, variant, viewTransition, ...props }) => {
+    return (_jsx(LinkBase, { ...props, className: link({
+            arrow,
+            className,
+            variant,
+        }), routeKey: routeKey, to: to, viewTransition: viewTransition, children: lowerCaseSzett(children) }));
+};
+export const MarkdownLink = ({ children, href, ...props }) => {
+    if (href) {
+        return (_jsx(Link, { to: href, ...props, children: children }));
+    }
+    return null;
+};

package/dist/components/link.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=link.test.d.ts.map

package/dist/components/link.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"link.test.d.ts","sourceRoot":"","sources":["../../src/components/link.test.tsx"],"names":[],"mappings":""}

package/dist/components/link.test.js

@@ -0,0 +1,204 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { fireEvent, render, screen } from '@testing-library/react';
+import { MemoryRouter } from 'react-router';
+import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest';
+import { Link, LinkBase, MarkdownLink, PathResolverProvider, usePathResolver } from './link';
+const renderWithRouter = (ui, { route = '/' } = {}) => {
+    return render(_jsx(MemoryRouter, { initialEntries: [route], children: ui }));
+};
+describe('LinkBase', () => {
+    describe('path resolution', () => {
+        test('renders with string "to" prop', () => {
+            renderWithRouter(_jsx(LinkBase, { to: "/about", children: "About" }));
+            const link = screen.getByRole('link', { name: 'About' });
+            expect(link).toHaveAttribute('href', '/about');
+        });
+        test('renders with object "to" prop containing pathname', () => {
+            renderWithRouter(_jsx(LinkBase, { to: { pathname: '/contact' }, children: "Contact" }));
+            const link = screen.getByRole('link', { name: 'Contact' });
+            expect(link).toHaveAttribute('href', '/contact');
+        });
+        test('renders with object "to" prop containing pathname, search, and hash', () => {
+            renderWithRouter(_jsx(LinkBase, { to: { hash: '#section', pathname: '/page', search: '?foo=bar' }, children: "Full Path" }));
+            const link = screen.getByRole('link', { name: 'Full Path' });
+            expect(link).toHaveAttribute('href', '/page?foo=bar#section');
+        });
+        test('uses pathResolver when routeKey is provided', () => {
+            const mockResolver = vi.fn().mockReturnValue('/resolved-path');
+            renderWithRouter(_jsx(PathResolverProvider, { value: mockResolver, children: _jsx(LinkBase, { routeKey: "home", children: "Home" }) }));
+            expect(mockResolver).toHaveBeenCalledWith('home');
+            const link = screen.getByRole('link', { name: 'Home' });
+            expect(link).toHaveAttribute('href', '/resolved-path');
+        });
+        test('falls back to "to" prop when no pathResolver is available', () => {
+            renderWithRouter(_jsx(LinkBase, { routeKey: "home", to: "/fallback", children: "Home" }));
+            const link = screen.getByRole('link', { name: 'Home' });
+            expect(link).toHaveAttribute('href', '/fallback');
+        });
+        test('renders children only when path is empty', () => {
+            renderWithRouter(_jsx(LinkBase, { children: "No Link" }));
+            expect(screen.queryByRole('link')).toBeNull();
+            expect(screen.getByText('No Link')).toBeInTheDocument();
+        });
+        test('renders nothing for function children when path is empty', () => {
+            const { container } = renderWithRouter(_jsx(LinkBase, { children: () => _jsx("span", { children: "Function Child" }) }));
+            expect(screen.queryByRole('link')).toBeNull();
+            expect(container.textContent).toBe('');
+        });
+    });
+    describe('external links', () => {
+        let windowOpenSpy;
+        beforeEach(() => {
+            windowOpenSpy = vi.spyOn(window, 'open').mockImplementation(() => null);
+        });
+        afterEach(() => {
+            windowOpenSpy.mockRestore();
+        });
+        test('renders tel: links as anchor elements', () => {
+            renderWithRouter(_jsx(LinkBase, { to: "tel:+1234567890", children: "Call Us" }));
+            const link = screen.getByRole('link', { name: 'Call Us' });
+            expect(link.tagName).toBe('A');
+            expect(link).toHaveAttribute('href', 'tel:+1234567890');
+        });
+        test('renders mailto: links as anchor elements', () => {
+            renderWithRouter(_jsx(LinkBase, { to: "mailto:test@example.com", children: "Email Us" }));
+            const link = screen.getByRole('link', { name: 'Email Us' });
+            expect(link.tagName).toBe('A');
+            expect(link).toHaveAttribute('href', 'mailto:test@example.com');
+        });
+        test('opens http links in new tab on click', () => {
+            renderWithRouter(_jsx(LinkBase, { to: "https://example.com", children: "External" }));
+            const link = screen.getByRole('link', { name: 'External' });
+            fireEvent.click(link);
+            expect(windowOpenSpy).toHaveBeenCalledWith('https://example.com', '_blank', 'noopener,noreferrer');
+        });
+        test('handles hash links with smooth scroll', () => {
+            const mockElement = document.createElement('div');
+            mockElement.id = 'section';
+            mockElement.scrollIntoView = vi.fn();
+            document.body.appendChild(mockElement);
+            renderWithRouter(_jsx(LinkBase, { to: "#section", children: "Go to Section" }));
+            const link = screen.getByRole('link', { name: 'Go to Section' });
+            fireEvent.click(link);
+            expect(mockElement.scrollIntoView).toHaveBeenCalledWith({ behavior: 'smooth' });
+            document.body.removeChild(mockElement);
+        });
+        test('does not scroll if hash element does not exist', () => {
+            renderWithRouter(_jsx(LinkBase, { to: "#nonexistent", children: "Missing Section" }));
+            const link = screen.getByRole('link', { name: 'Missing Section' });
+            expect(() => fireEvent.click(link)).not.toThrow();
+        });
+    });
+    describe('onClick handling', () => {
+        test('calls custom onClick handler', () => {
+            const handleClick = vi.fn();
+            renderWithRouter(_jsx(LinkBase, { onClick: handleClick, to: "/page", children: "Click Me" }));
+            const link = screen.getByRole('link', { name: 'Click Me' });
+            fireEvent.click(link);
+            expect(handleClick).toHaveBeenCalled();
+        });
+        test('respects preventDefault from custom onClick', () => {
+            const windowOpenSpy = vi.spyOn(window, 'open').mockImplementation(() => null);
+            const handleClick = vi.fn((e) => e.preventDefault());
+            renderWithRouter(_jsx(LinkBase, { onClick: handleClick, to: "https://example.com", children: "External" }));
+            const link = screen.getByRole('link', { name: 'External' });
+            fireEvent.click(link);
+            expect(handleClick).toHaveBeenCalled();
+            expect(windowOpenSpy).not.toHaveBeenCalled();
+            windowOpenSpy.mockRestore();
+        });
+    });
+    describe('className and style handling', () => {
+        test('applies static className to external links', () => {
+            renderWithRouter(_jsx(LinkBase, { className: "custom-class", to: "https://example.com", children: "External" }));
+            const link = screen.getByRole('link', { name: 'External' });
+            expect(link).toHaveClass('custom-class');
+        });
+        test('resolves function className for external links', () => {
+            renderWithRouter(_jsx(LinkBase, { className: ({ isActive }) => (isActive ? 'active' : 'inactive'), to: "https://example.com", children: "External" }));
+            const link = screen.getByRole('link', { name: 'External' });
+            expect(link).toHaveClass('inactive');
+        });
+        test('resolves function style for external links', () => {
+            renderWithRouter(_jsx(LinkBase, { style: ({ isActive }) => ({ color: isActive ? 'red' : 'blue' }), to: "https://example.com", children: "External" }));
+            const link = screen.getByRole('link', { name: 'External' });
+            expect(link).toHaveStyle({ color: 'rgb(0, 0, 255)' });
+        });
+        test('resolves function children for external links', () => {
+            renderWithRouter(_jsx(LinkBase, { to: "https://example.com", children: ({ isActive }) => (isActive ? 'Active' : 'Inactive') }));
+            expect(screen.getByText('Inactive')).toBeInTheDocument();
+        });
+    });
+    describe('viewTransition prop', () => {
+        test('defaults to true for internal links', () => {
+            renderWithRouter(_jsx(LinkBase, { to: "/page", children: "Page" }));
+            const link = screen.getByRole('link', { name: 'Page' });
+            expect(link).toBeInTheDocument();
+        });
+        test('can be disabled', () => {
+            renderWithRouter(_jsx(LinkBase, { to: "/page", viewTransition: false, children: "Page" }));
+            const link = screen.getByRole('link', { name: 'Page' });
+            expect(link).toBeInTheDocument();
+        });
+    });
+});
+describe('Link', () => {
+    test('applies variant classes', () => {
+        renderWithRouter(_jsx(Link, { to: "/page", variant: "button", children: "Button Link" }));
+        const link = screen.getByRole('link', { name: 'Button Link' });
+        expect(link).toHaveClass('button');
+    });
+    test('applies arrow classes', () => {
+        renderWithRouter(_jsx(Link, { arrow: "rarr", to: "/page", children: "Arrow Link" }));
+        const link = screen.getByRole('link', { name: 'Arrow Link' });
+        expect(link).toHaveClass('rarr');
+    });
+    test('merges custom className with variant classes', () => {
+        renderWithRouter(_jsx(Link, { className: "custom", to: "/page", variant: "code", children: "Code Link" }));
+        const link = screen.getByRole('link', { name: 'Code Link' });
+        expect(link).toHaveClass('font-monospace');
+        expect(link).toHaveClass('custom');
+    });
+    test('passes through routeKey to LinkBase', () => {
+        const mockResolver = vi.fn().mockReturnValue('/resolved');
+        renderWithRouter(_jsx(PathResolverProvider, { value: mockResolver, children: _jsx(Link, { routeKey: "test", children: "Test" }) }));
+        expect(mockResolver).toHaveBeenCalledWith('test');
+    });
+});
+describe('MarkdownLink', () => {
+    test('renders Link when href is provided', () => {
+        renderWithRouter(_jsx(MarkdownLink, { href: "/page", children: "Markdown Link" }));
+        const link = screen.getByRole('link', { name: 'Markdown Link' });
+        expect(link).toHaveAttribute('href', '/page');
+    });
+    test('renders null when href is not provided', () => {
+        const { container } = renderWithRouter(_jsx(MarkdownLink, { children: "No Href" }));
+        expect(container.textContent).toBe('');
+    });
+    test('passes through Link props', () => {
+        renderWithRouter(_jsx(MarkdownLink, { href: "/page", variant: "subtitle", children: "Styled Link" }));
+        const link = screen.getByRole('link', { name: 'Styled Link' });
+        expect(link).toHaveClass('text-lg');
+    });
+});
+describe('usePathResolver', () => {
+    test('returns null when no provider is present', () => {
+        let resolverValue = vi.fn();
+        const TestComponent = () => {
+            resolverValue = usePathResolver();
+            return null;
+        };
+        render(_jsx(TestComponent, {}));
+        expect(resolverValue).toBeNull();
+    });
+    test('returns resolver function when provider is present', () => {
+        const mockResolver = vi.fn().mockReturnValue('/path');
+        let resolverValue = null;
+        const TestComponent = () => {
+            resolverValue = usePathResolver();
+            return null;
+        };
+        render(_jsx(PathResolverProvider, { value: mockResolver, children: _jsx(TestComponent, {}) }));
+        expect(resolverValue).toBe(mockResolver);
+    });
+});

package/dist/components/list-item.d.ts

@@ -0,0 +1,16 @@
+import type { ComponentProps } from 'react';
+import { type VariantProps } from '../utils/cn';
+declare const li: (props?: ({
+    variant?: "primary" | undefined;
+} & ({
+    class?: import("cva").ClassValue;
+    className?: never;
+} | {
+    class?: never;
+    className?: import("cva").ClassValue;
+})) | undefined) => string;
+export interface ListItemProps extends ComponentProps<'li'>, VariantProps<typeof li> {
+}
+export declare const ListItem: (props: ListItemProps) => import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=list-item.d.ts.map

package/dist/components/list-item.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-item.d.ts","sourceRoot":"","sources":["../../src/components/list-item.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,OAAO,CAAC;AAC5C,OAAO,EAAO,KAAK,YAAY,EAAE,MAAM,aAAa,CAAC;AAErD,QAAA,MAAM,EAAE;;;;;;;;0BASN,CAAC;AAEH,MAAM,WAAW,aAAc,SAAQ,cAAc,CAAC,IAAI,CAAC,EAAE,YAAY,CAAC,OAAO,EAAE,CAAC;CAAG;AAEvF,eAAO,MAAM,QAAQ,GAAI,OAAO,aAAa,4CAa5C,CAAC"}

package/dist/components/list-item.js

@@ -0,0 +1,19 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { cva } from '../utils/cn';
+const li = cva({
+    defaultVariants: {
+        variant: 'primary',
+    },
+    variants: {
+        variant: {
+            primary: [],
+        },
+    },
+});
+export const ListItem = (props) => {
+    const { children, className, variant } = props;
+    return (_jsx("li", { className: li({
+            className,
+            variant,
+        }), children: children }));
+};

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

@@ -0,0 +1,26 @@
+import '@maptiler/sdk/dist/maptiler-sdk.css';
+interface MapTilerMarker {
+    lat: number;
+    lng: number;
+    id: string;
+    content?: string;
+    htmlContent?: string;
+    offset?: {
+        x: number;
+        y: number;
+    };
+}
+interface MapTilerMapProps {
+    markers: MapTilerMarker[];
+    center?: {
+        lat: number;
+        lng: number;
+    };
+    zoom?: number;
+    mapStyle?: string;
+    apiKey: string;
+    showPopupsImmediately?: boolean;
+}
+export declare const MapTilerMap: ({ markers, center, zoom, mapStyle, apiKey, showPopupsImmediately, }: MapTilerMapProps) => import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=maptiler-map.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"maptiler-map.d.ts","sourceRoot":"","sources":["../../src/components/maptiler-map.tsx"],"names":[],"mappings":"AAEA,OAAO,qCAAqC,CAAC;AAE7C,UAAU,cAAc;IACtB,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;IACZ,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,MAAM,CAAC,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CACnC;AAED,UAAU,gBAAgB;IACxB,OAAO,EAAE,cAAc,EAAE,CAAC;IAC1B,MAAM,CAAC,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,CAAC;IACtC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,qBAAqB,CAAC,EAAE,OAAO,CAAC;CACjC;AAED,eAAO,MAAM,WAAW,GAAI,qEAOzB,gBAAgB,4CAuJlB,CAAC"}