awing-library 2.1.2-dev.99 → 2.1.2-preview.1

package/dist/AWING/GeoFencing/container.test.js

@@ -0,0 +1,219 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import "@testing-library/jest-dom";
+import { fireEvent, render, waitFor } from "@testing-library/react";
+import { DEFAULT_RADIUS, MIN_RADIUS } from "../../Commons/Constant.js";
+import container from "./container.js";
+jest.mock('lodash', ()=>({
+        debounce: (fn)=>{
+            fn.cancel = jest.fn();
+            return fn;
+        }
+    }));
+jest.mock('./component', ()=>function(props) {
+        return /*#__PURE__*/ jsxs("div", {
+            "data-testid": "mocked-component",
+            children: [
+                /*#__PURE__*/ jsx("input", {
+                    "data-testid": "location-input",
+                    value: props.locationString,
+                    onChange: (e)=>props.onChange('locationString', e.target.value)
+                }),
+                /*#__PURE__*/ jsx("input", {
+                    "data-testid": "radius-input",
+                    value: props.radius,
+                    onChange: (e)=>props.onChange('radius', e.target.value)
+                }),
+                /*#__PURE__*/ jsx("button", {
+                    "data-testid": "search-button",
+                    onClick: props.onSearch,
+                    children: "Search"
+                }),
+                /*#__PURE__*/ jsx("button", {
+                    "data-testid": "map-select-button",
+                    onClick: ()=>props.onGoongMapSelect({
+                            latitude: 10,
+                            longitude: 20
+                        }),
+                    children: "Select on Map"
+                })
+            ]
+        });
+    });
+describe('Container Component', ()=>{
+    const mockOnChangeValue = jest.fn();
+    const defaultProps = {
+        configs: {
+            GOOGLE_MAP_KEY: 'test-key'
+        },
+        onChangeValue: mockOnChangeValue,
+        label: 'Test Label',
+        initValue: void 0,
+        value: void 0,
+        limit: {
+            min: MIN_RADIUS
+        },
+        isOnlyMap: false
+    };
+    beforeEach(()=>{
+        jest.clearAllMocks();
+    });
+    it('renders with default values when no initial value provided', ()=>{
+        const { getByTestId } = render(/*#__PURE__*/ jsx(container, {
+            ...defaultProps
+        }));
+        expect(getByTestId('location-input')).toHaveValue('');
+        expect(getByTestId('radius-input')).toHaveValue(DEFAULT_RADIUS);
+    });
+    it('renders with initial values when value is undefined', ()=>{
+        const initValue = {
+            latitude: 1,
+            longitude: 2,
+            radius: 300
+        };
+        const { getByTestId } = render(/*#__PURE__*/ jsx(container, {
+            ...defaultProps,
+            limit: void 0,
+            value: {
+                latitude: 1,
+                longitude: 2,
+                radius: void 0
+            },
+            initValue: initValue
+        }));
+        expect(getByTestId('location-input')).toHaveValue('1, 2');
+        expect(getByTestId('radius-input')).toHaveValue('500');
+    });
+    it('renders with initial values when limit is undefined', ()=>{
+        const initValue = {
+            latitude: 1,
+            longitude: 2,
+            radius: 500
+        };
+        const { getByTestId } = render(/*#__PURE__*/ jsx(container, {
+            ...defaultProps,
+            limit: void 0,
+            initValue: initValue
+        }));
+        expect(getByTestId('location-input')).toHaveValue('1, 2');
+        expect(getByTestId('radius-input')).toHaveValue('500');
+    });
+    it('renders with initial values when provided', ()=>{
+        const initValue = {
+            latitude: 1,
+            longitude: 2,
+            radius: 500
+        };
+        const { getByTestId } = render(/*#__PURE__*/ jsx(container, {
+            ...defaultProps,
+            initValue: initValue
+        }));
+        expect(getByTestId('location-input')).toHaveValue('1, 2');
+        expect(getByTestId('radius-input')).toHaveValue('500');
+    });
+    it('updates location string when user types', async ()=>{
+        const { getByTestId } = render(/*#__PURE__*/ jsx(container, {
+            ...defaultProps
+        }));
+        const input = getByTestId('location-input');
+        fireEvent.change(input, {
+            target: {
+                value: '10, 20'
+            }
+        });
+        expect(input).toHaveValue('10, 20');
+        await waitFor(()=>{
+            expect(mockOnChangeValue).toHaveBeenCalledWith({
+                latitude: 10,
+                longitude: 20,
+                radius: Number(DEFAULT_RADIUS)
+            });
+        });
+    });
+    it('updates radius when user types', async ()=>{
+        const { getByTestId } = render(/*#__PURE__*/ jsx(container, {
+            ...defaultProps
+        }));
+        const radiusInput = getByTestId('radius-input');
+        fireEvent.change(radiusInput, {
+            target: {
+                value: '1000'
+            }
+        });
+        expect(radiusInput).toHaveValue('1000');
+    });
+    it('handles map selection', async ()=>{
+        const { getByTestId } = render(/*#__PURE__*/ jsx(container, {
+            ...defaultProps
+        }));
+        fireEvent.click(getByTestId('map-select-button'));
+        expect(getByTestId('location-input')).toHaveValue('10, 20');
+        await waitFor(()=>{
+            expect(mockOnChangeValue).toHaveBeenCalledWith({
+                latitude: 10,
+                longitude: 20,
+                radius: Number(DEFAULT_RADIUS)
+            });
+        });
+    });
+    it('handles search button click', async ()=>{
+        const { getByTestId } = render(/*#__PURE__*/ jsx(container, {
+            ...defaultProps
+        }));
+        fireEvent.change(getByTestId('location-input'), {
+            target: {
+                value: '10, 20'
+            }
+        });
+        fireEvent.click(getByTestId('search-button'));
+        await waitFor(()=>{
+            expect(mockOnChangeValue).toHaveBeenCalledWith({
+                latitude: 10,
+                longitude: 20,
+                radius: Number(DEFAULT_RADIUS)
+            });
+        });
+    });
+    it('updates when value prop changes', async ()=>{
+        const { rerender, getByTestId } = render(/*#__PURE__*/ jsx(container, {
+            ...defaultProps
+        }));
+        rerender(/*#__PURE__*/ jsx(container, {
+            ...defaultProps,
+            value: {
+                latitude: 30,
+                longitude: 40,
+                radius: 800
+            }
+        }));
+        expect(getByTestId('location-input')).toHaveValue('30, 40');
+        expect(getByTestId('radius-input')).toHaveValue('800');
+    });
+    it.skip('validates minimum radius', async ()=>{
+        const { getByTestId } = render(/*#__PURE__*/ jsx(container, {
+            ...defaultProps
+        }));
+        fireEvent.change(getByTestId('radius-input'), {
+            target: {
+                value: (MIN_RADIUS - 1).toString()
+            }
+        });
+        fireEvent.click(getByTestId('search-button'));
+        await waitFor(()=>{
+            expect(mockOnChangeValue).not.toHaveBeenCalled();
+        });
+    });
+    it('calls onChangeValue with undefined when location or radius is empty', async ()=>{
+        const { getByTestId } = render(/*#__PURE__*/ jsx(container, {
+            ...defaultProps
+        }));
+        fireEvent.change(getByTestId('location-input'), {
+            target: {
+                value: ''
+            }
+        });
+        fireEvent.click(getByTestId('search-button'));
+        await waitFor(()=>{
+            expect(mockOnChangeValue).toHaveBeenCalledWith(void 0);
+        });
+    });
+});

package/dist/AWING/GeoFencing/index.d.ts

@@ -0,0 +1,5 @@
+import { GeoFencingProps } from './interface';
+export declare function GeoFencing(props: GeoFencingProps): import("react/jsx-runtime").JSX.Element;
+export default GeoFencing;
+export * from './interface';
+//# sourceMappingURL=index.d.ts.map

package/dist/AWING/GeoFencing/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/AWING/GeoFencing/index.tsx"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAE9C,wBAAgB,UAAU,CAAC,KAAK,EAAE,eAAe,2CAEhD;AAED,eAAe,UAAU,CAAC;AAC1B,cAAc,aAAa,CAAC"}

package/dist/AWING/GeoFencing/index.js

@@ -0,0 +1,10 @@
+import { jsx } from "react/jsx-runtime";
+import container from "./container.js";
+export * from "./interface.js";
+function GeoFencing_GeoFencing(props) {
+    return /*#__PURE__*/ jsx(container, {
+        ...props
+    });
+}
+const GeoFencing = GeoFencing_GeoFencing;
+export { GeoFencing_GeoFencing as GeoFencing, GeoFencing as default };

package/dist/AWING/GeoFencing/interface.d.ts

@@ -0,0 +1,35 @@
+export interface IConfig {
+    GOOGLE_MAP_KEY: string;
+}
+export interface GeoFencingValue {
+    latitude?: number;
+    longitude?: number;
+    radius?: number;
+}
+export interface GeoFencingProps {
+    initValue?: GeoFencingValue;
+    onChangeValue: (value: GeoFencingValue | undefined) => void;
+    label: string;
+    configs: IConfig;
+    value?: GeoFencingValue;
+    limit?: {
+        min?: number;
+        max?: number;
+    };
+    isOnlyMap?: boolean;
+}
+export interface GeoFencingComponentProps extends Omit<GeoFencingProps, 'onChangeValue'> {
+    marker: {
+        latitude: number;
+        longitude: number;
+    } | null;
+    radius: string;
+    locationString: string;
+    onGoongMapSelect: (newValue: {
+        latitude: number;
+        longitude: number;
+    }) => void;
+    onChange: (type: string, newValue: number | string) => void;
+    onSearch: () => void;
+}
+//# sourceMappingURL=interface.d.ts.map

package/dist/AWING/GeoFencing/interface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interface.d.ts","sourceRoot":"","sources":["../../../src/AWING/GeoFencing/interface.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,OAAO;IACpB,cAAc,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,eAAe;IAC5B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,eAAe;IAC5B,SAAS,CAAC,EAAE,eAAe,CAAC;IAC5B,aAAa,EAAE,CAAC,KAAK,EAAE,eAAe,GAAG,SAAS,KAAK,IAAI,CAAC;IAC5D,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,eAAe,CAAC;IACxB,KAAK,CAAC,EAAE;QAAE,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IACvC,SAAS,CAAC,EAAE,OAAO,CAAC;CACvB;AAED,MAAM,WAAW,wBAAyB,SAAQ,IAAI,CAAC,eAAe,EAAE,eAAe,CAAC;IACpF,MAAM,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;IACvD,MAAM,EAAE,MAAM,CAAC;IACf,cAAc,EAAE,MAAM,CAAC;IACvB,gBAAgB,EAAE,CAAC,QAAQ,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,KAAK,IAAI,CAAC;IAC9E,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,KAAK,IAAI,CAAC;IAC5D,QAAQ,EAAE,MAAM,IAAI,CAAC;CACxB"}

package/dist/AWING/GoogleMap/GGMap.d.ts

@@ -0,0 +1,4 @@
+import { IGoogleMapProps } from './interface';
+declare const GGMap: ({ defaultLocation, onUpdateLocation, apiKey, geofenceRadius, sxMap, isDisplayAutoComplete, isTypeTracking, markerPositions, zoomCustomed, }: IGoogleMapProps) => import("react/jsx-runtime").JSX.Element;
+export default GGMap;
+//# sourceMappingURL=GGMap.d.ts.map

package/dist/AWING/GoogleMap/GGMap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GGMap.d.ts","sourceRoot":"","sources":["../../../src/AWING/GoogleMap/GGMap.tsx"],"names":[],"mappings":"AAKA,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAkB9C,QAAA,MAAM,KAAK,gJAUR,eAAe,4CAgMjB,CAAC;AAEF,eAAe,KAAK,CAAC"}

package/dist/AWING/GoogleMap/GGMap.js

@@ -0,0 +1,265 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import react, { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { useTranslation } from "react-i18next";
+import lodash from "lodash";
+import { Autocomplete, Circle, GoogleMap, LoadScript, Marker } from "@react-google-maps/api";
+import { Box } from "@mui/material";
+import { mapStyles } from "./utils.js";
+const mapContainerStyle = {
+    height: '320px',
+    width: '100%'
+};
+const libraries = [
+    'places'
+];
+const stylesDefault = {
+    position: 'relative',
+    '& .pac-container.pac-logo': {
+        top: '55px!important',
+        left: '0!important'
+    }
+};
+const GGMap_GGMap = ({ defaultLocation, onUpdateLocation, apiKey, geofenceRadius, sxMap, isDisplayAutoComplete = false, isTypeTracking = false, markerPositions, zoomCustomed })=>{
+    const { t } = useTranslation();
+    const [map, setMap] = useState();
+    const [_error, setError] = useState('');
+    const autocompleteRef = useRef(null);
+    const boxRef = useRef(null);
+    const makerRefs = useRef([]);
+    const [zoom, setZoom] = useState(zoomCustomed || 5);
+    const onLoad = (autocomplete)=>{
+        autocompleteRef.current = autocomplete;
+    };
+    const markerConvert = useMemo(()=>{
+        const coordMap = markerPositions?.reduce((acc, { longitude, latitude })=>{
+            const key = `${longitude},${latitude}`;
+            if (acc[key]) acc[key].count += 1;
+            else acc[key] = {
+                longitude,
+                latitude,
+                count: 1
+            };
+            return acc;
+        }, {}) ?? {};
+        return Object.values(coordMap).map((item, _index, arr)=>{
+            item.radius = (item.count ?? 0) / arr.reduce((acc, item)=>acc + (item?.count ?? 0), 0) * Math.pow(2, 10 - Math.max(zoom, 4)) * 8000;
+            return item;
+        });
+    }, [
+        markerPositions,
+        zoom
+    ]);
+    const onPlaceChanged = ()=>{
+        if (null !== autocompleteRef.current) {
+            const place = autocompleteRef.current.getPlace();
+            if (place.geometry) {
+                const newLat = place?.geometry?.location?.lat();
+                const newLng = place?.geometry?.location?.lng();
+                onUpdateLocation && onUpdateLocation({
+                    latitude: newLat ?? 0,
+                    longitude: newLng ?? 0
+                });
+                map?.panTo({
+                    lat: newLat ?? 0,
+                    lng: newLng ?? 0
+                });
+                setZoom(18);
+            }
+        } else console.log('Autocomplete is not loaded yet!');
+    };
+    const onLoadMap = react.useCallback((mapInstance)=>{
+        setMap(mapInstance);
+    }, []);
+    const getCurrentLocation = ()=>{
+        const showPosition = (position)=>{
+            onUpdateLocation && onUpdateLocation({
+                latitude: position.coords.latitude,
+                longitude: position.coords.longitude
+            });
+        };
+        const showError = (error)=>{
+            switch(error.code){
+                case error.PERMISSION_DENIED:
+                    setError('User denied the request for Geolocation.');
+                    break;
+                case error.POSITION_UNAVAILABLE:
+                    setError('Location information is unavailable.');
+                    break;
+                case error.TIMEOUT:
+                    setError('The request to get user location timed out.');
+                    break;
+                default:
+                    setError('An unknown error occurred.');
+                    break;
+            }
+        };
+        if (navigator.geolocation) navigator.geolocation.getCurrentPosition(showPosition, showError);
+        else setError('Geolocation is not supported by this browser.');
+    };
+    const onMapClick = react.useCallback((e)=>{
+        onUpdateLocation && onUpdateLocation({
+            latitude: e?.latLng?.lat() ?? 0,
+            longitude: e?.latLng?.lng() ?? 0
+        });
+    }, []);
+    useEffect(()=>{
+        if (lodash.isNil(defaultLocation) || 0 === defaultLocation.lat || 0 === defaultLocation.lng) getCurrentLocation();
+    }, [
+        defaultLocation
+    ]);
+    useEffect(()=>{
+        if (map) {
+            makerRefs.current.forEach((marker)=>{
+                marker.setMap(null);
+            });
+            makerRefs.current = markerConvert.map((item)=>{
+                const maker = new google.maps.Circle({
+                    center: {
+                        lat: item.latitude ?? 0,
+                        lng: item.longitude ?? 0
+                    },
+                    radius: item.radius,
+                    strokeColor: '#4285F4',
+                    strokeOpacity: 0.8,
+                    strokeWeight: 2,
+                    fillColor: '#4285F4',
+                    fillOpacity: 0.35
+                });
+                maker.setMap(map);
+                return maker;
+            });
+        }
+    }, [
+        markerConvert
+    ]);
+    const handleZoom = useCallback((zoom)=>{
+        setZoom(zoom);
+    }, []);
+    return /*#__PURE__*/ jsx(Box, {
+        sx: sxMap ? sxMap : stylesDefault,
+        ref: boxRef,
+        children: /*#__PURE__*/ jsxs(LoadScript, {
+            googleMapsApiKey: apiKey || '',
+            libraries: libraries,
+            children: [
+                !isDisplayAutoComplete && /*#__PURE__*/ jsx(Autocomplete, {
+                    onPlaceChanged: onPlaceChanged,
+                    onLoad: onLoad,
+                    children: /*#__PURE__*/ jsx("input", {
+                        type: "text",
+                        placeholder: t('Common.PlaceHolderLocation'),
+                        onFocus: ()=>{
+                            const ggSuggest = document.querySelector('.pac-container.pac-logo');
+                            if (ggSuggest) boxRef.current?.append(ggSuggest);
+                        },
+                        style: {
+                            boxSizing: "border-box",
+                            border: "1px solid transparent",
+                            width: "378px",
+                            height: "40px",
+                            padding: "0 12px",
+                            borderRadius: "3px",
+                            boxShadow: "0 2px 6px rgba(0, 0, 0, 0.3)",
+                            fontSize: "14px",
+                            outline: "none",
+                            textOverflow: "ellipses",
+                            position: 'inherit',
+                            right: '3%',
+                            margin: '10px 0',
+                            zIndex: 99,
+                            top: '50px'
+                        }
+                    })
+                }),
+                isTypeTracking ? /*#__PURE__*/ jsx(Maprender, {
+                    onLoadMap: onLoadMap,
+                    onMapClick: onMapClick,
+                    onZoomChanged: handleZoom
+                }) : /*#__PURE__*/ jsx(MaprenderWithoutTracking, {
+                    onLoadMap: onLoadMap,
+                    onMapClick: onMapClick,
+                    onZoomChanged: handleZoom,
+                    defaultLocation: defaultLocation ?? {
+                        lat: 21.0063107,
+                        lng: 105.8279467
+                    },
+                    geofenceRadius: geofenceRadius ?? 0,
+                    zoomCustomed: zoomCustomed ?? 10
+                })
+            ]
+        })
+    });
+};
+const GGMap = GGMap_GGMap;
+const Maprender = /*#__PURE__*/ react.memo(({ onLoadMap, onMapClick, onZoomChanged })=>{
+    const mapInstance = useRef(null);
+    return /*#__PURE__*/ jsx(GoogleMap, {
+        id: "map",
+        mapContainerStyle: {
+            width: '100%',
+            height: "521px"
+        },
+        zoom: 3,
+        center: {
+            lat: 21.0063107,
+            lng: 105.8279467
+        },
+        onZoomChanged: ()=>{
+            onZoomChanged(mapInstance.current?.getZoom() ?? 0);
+        },
+        onLoad: (instance)=>{
+            mapInstance.current = instance;
+            onLoadMap(instance);
+        },
+        onClick: onMapClick,
+        options: {
+            disableDefaultUI: true,
+            styles: mapStyles,
+            zoomControl: true,
+            streetViewControl: false,
+            mapTypeControl: false,
+            fullscreenControl: false,
+            minZoom: 2,
+            maxZoom: 13
+        }
+    });
+});
+const MaprenderWithoutTracking = /*#__PURE__*/ react.memo(({ onLoadMap, onMapClick, onZoomChanged, defaultLocation, geofenceRadius, zoomCustomed })=>{
+    const mapInstance = useRef(null);
+    return /*#__PURE__*/ jsx(GoogleMap, {
+        id: "map",
+        mapContainerStyle: mapContainerStyle,
+        zoom: zoomCustomed ?? 10,
+        center: defaultLocation,
+        onZoomChanged: ()=>{
+            onZoomChanged(mapInstance.current?.getZoom() ?? 0);
+        },
+        onLoad: (instance)=>{
+            mapInstance.current = instance;
+            onLoadMap(instance);
+        },
+        onClick: onMapClick,
+        children: /*#__PURE__*/ jsxs(Box, {
+            children: [
+                /*#__PURE__*/ jsx(Marker, {
+                    position: defaultLocation ?? {
+                        lat: 21.0063107,
+                        lng: 105.8279467
+                    }
+                }),
+                /*#__PURE__*/ jsx(Circle, {
+                    center: defaultLocation,
+                    radius: geofenceRadius,
+                    options: {
+                        fillColor: 'red',
+                        fillOpacity: 0.2,
+                        strokeColor: 'red',
+                        strokeOpacity: 1,
+                        strokeWeight: 2
+                    }
+                })
+            ]
+        })
+    });
+});
+export { GGMap as default };

package/dist/AWING/GoogleMap/index.d.ts

@@ -0,0 +1,5 @@
+import { IGoogleMapProps } from './interface';
+export declare function GoogleMap(props: IGoogleMapProps): import("react/jsx-runtime").JSX.Element;
+export default GoogleMap;
+export * from './interface';
+//# sourceMappingURL=index.d.ts.map

package/dist/AWING/GoogleMap/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/AWING/GoogleMap/index.tsx"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAE9C,wBAAgB,SAAS,CAAC,KAAK,EAAE,eAAe,2CAE/C;AAED,eAAe,SAAS,CAAC;AACzB,cAAc,aAAa,CAAC"}

package/dist/AWING/GoogleMap/index.js

@@ -0,0 +1,10 @@
+import { jsx } from "react/jsx-runtime";
+import GGMap from "./GGMap.js";
+export * from "./interface.js";
+function GoogleMap_GoogleMap(props) {
+    return /*#__PURE__*/ jsx(GGMap, {
+        ...props
+    });
+}
+const GoogleMap = GoogleMap_GoogleMap;
+export { GoogleMap_GoogleMap as GoogleMap, GoogleMap as default };

package/dist/AWING/GoogleMap/interface.d.ts

@@ -0,0 +1,21 @@
+export interface IGoogleMapProps {
+    defaultLocation?: {
+        lat: number;
+        lng: number;
+    };
+    onUpdateLocation?: (newValue: {
+        latitude: number;
+        longitude: number;
+    }) => void;
+    apiKey: string;
+    geofenceRadius?: number;
+    sxMap?: any;
+    isDisplayAutoComplete?: boolean;
+    isTypeTracking?: boolean;
+    markerPositions?: {
+        longitude: number | null;
+        latitude: number | null;
+    }[];
+    zoomCustomed?: number;
+}
+//# sourceMappingURL=interface.d.ts.map

package/dist/AWING/GoogleMap/interface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interface.d.ts","sourceRoot":"","sources":["../../../src/AWING/GoogleMap/interface.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,eAAe;IAC5B,eAAe,CAAC,EAAE;QACd,GAAG,EAAE,MAAM,CAAC;QACZ,GAAG,EAAE,MAAM,CAAC;KACf,CAAC;IACF,gBAAgB,CAAC,EAAE,CAAC,QAAQ,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,KAAK,IAAI,CAAC;IAC/E,MAAM,EAAE,MAAM,CAAC;IACf,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,KAAK,CAAC,EAAE,GAAG,CAAC;IACZ,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,eAAe,CAAC,EAAE;QACd,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;QACzB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;KAC3B,EAAE,CAAC;IACJ,YAAY,CAAC,EAAE,MAAM,CAAC;CACzB"}

package/dist/AWING/GoogleMap/utils.d.ts

@@ -0,0 +1,26 @@
+export declare const mapStyles: ({
+    elementType: string;
+    stylers: {
+        color: string;
+    }[];
+    featureType?: undefined;
+} | {
+    elementType: string;
+    stylers: {
+        visibility: string;
+    }[];
+    featureType?: undefined;
+} | {
+    featureType: string;
+    elementType: string;
+    stylers: {
+        color: string;
+    }[];
+} | {
+    featureType: string;
+    stylers: {
+        visibility: string;
+    }[];
+    elementType?: undefined;
+})[];
+//# sourceMappingURL=utils.d.ts.map

package/dist/AWING/GoogleMap/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/AWING/GoogleMap/utils.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;IAmIrB,CAAC"}