utopia-ui 3.0.0-alpha.19 → 3.0.0-alpha.191

package/dist/types.d.ts

@@ -1,41 +1,70 @@
 /// <reference types="react" />
-import { LatLng } from "leaflet";
 import { ItemFormPopupProps } from "./Components/Map/Subcomponents/ItemFormPopup";
 export interface UtopiaMapProps {
     height?: string;
     width?: string;
-    center?: LatLng;
+    center?: [number, number];
     zoom?: number;
     tags?: Tag[];
     children?: React.ReactNode;
+    geo?: any;
+    showFilterControl?: boolean;
+    showLayerControl?: boolean;
 }
 export interface LayerProps {
+    id?: string;
     data?: Item[];
     children?: React.ReactNode;
     name: string;
-    menuIcon: string;
+    menuIcon: any;
     menuColor: string;
     menuText: string;
     markerIcon: string;
     markerShape: string;
     markerDefaultColor: string;
+    markerDefaultColor2: string;
     api?: ItemsApi<any>;
+    itemType: ItemType;
+    itemNameField?: string;
+    itemSubnameField?: string;
+    itemTextField?: string;
+    itemAvatarField?: string;
+    itemColorField?: string;
+    itemOwnerField?: string;
+    itemTagsField?: string;
+    itemLatitudeField?: any;
+    itemLongitudeField?: any;
+    itemOffersField?: string;
+    itemNeedsField?: string;
+    onlyOnePerOwner?: boolean;
+    customEditLink?: string;
+    customEditParameter?: string;
+    public_edit_items?: boolean;
+    listed?: boolean;
     setItemFormPopup?: React.Dispatch<React.SetStateAction<ItemFormPopupProps | null>>;
     itemFormPopup?: ItemFormPopupProps | null;
-    clusterRef?: React.MutableRefObject<any>;
+    clusterRef?: any;
+}
+export interface ItemType {
+    name: string;
+    [key: string]: any;
 }
 export declare class Item {
     id: string;
     name: string;
     text: string;
-    position: Geometry;
+    position?: Geometry;
     date_created?: string;
     date_updated?: string | null;
     start?: string;
     end?: string;
     api?: ItemsApi<any>;
-    tags?: Tag[];
+    tags?: string[];
     layer?: LayerProps;
+    relations?: Relation[];
+    parent?: string;
+    subname?: string;
+    public_edit?: boolean;
     [key: string]: any;
     constructor(id: string, name: string, text: string, position: Geometry, layer?: LayerProps, api?: ItemsApi<any>);
 }
@@ -47,14 +76,21 @@ export declare class Geometry {
 export interface Tag {
     color: string;
     id: string;
+    name: string;
+    offer_or_need?: boolean;
 }
 export interface ItemsApi<T> {
     getItems(): Promise<any>;
+    getItem?(id: string): Promise<any>;
     createItem?(item: T): Promise<any>;
     updateItem?(item: T): Promise<any>;
-    deleteItem?(id: number | string): Promise<any>;
+    deleteItem?(id: string): Promise<any>;
     collectionName?: string;
 }
+export interface AssetsApi {
+    upload(file: Blob, title: string): any;
+    url: string;
+}
 export interface UserApi {
     register(email: string, password: string, userName: string): Promise<void>;
     login(email: string, password: string): Promise<any>;
@@ -62,20 +98,44 @@ export interface UserApi {
     getUser(): Promise<UserItem>;
     getToken(): Promise<any>;
     updateUser(user: UserItem): Promise<void>;
+    requestPasswordReset(email: string, reset_url?: string): any;
+    passwordReset(token: string, new_password: string): any;
 }
 export declare type UserItem = {
     id?: string;
-    avatar?: string;
     role?: string;
-    first_name: string;
-    description: string;
-    email: string;
+    email?: string;
     password?: string;
+    profile?: Profile;
+    [key: string]: any;
+};
+export declare type Profile = {
+    id?: string;
+    avatar?: string;
+    color?: string;
+    name: string;
+    text: string;
+    geoposition?: Geometry;
+};
+export declare type PermissionCondition = {
+    user_created?: {
+        _eq: string;
+    };
+    public_edit?: {
+        _eq: boolean;
+    };
 };
 export declare type Permission = {
     id?: string;
     role: string;
     collection: string;
     action: PermissionAction;
+    permissions?: {
+        _and: PermissionCondition[];
+    };
 };
 export declare type PermissionAction = "create" | "read" | "update" | "delete";
+export declare type Relation = {
+    related_items_id: string;
+    [key: string]: any;
+};

package/dist/workspace/utopia-ui/src/Components/AppShell/AppShell.d.ts

@@ -0,0 +1,8 @@
+import * as React from 'react';
+import { AssetsApi } from '../../types';
+export declare function AppShell({ appName, nameWidth, children, assetsApi }: {
+    appName: string;
+    nameWidth?: number;
+    children: React.ReactNode;
+    assetsApi: AssetsApi;
+}): JSX.Element;

package/dist/workspace/utopia-ui/src/Components/AppShell/Content.d.ts

@@ -0,0 +1,6 @@
+import * as React from 'react';
+declare type ContentProps = {
+    children?: React.ReactNode;
+};
+export declare function Content({ children }: ContentProps): JSX.Element;
+export {};

package/dist/workspace/utopia-ui/src/Components/AppShell/NavBar.d.ts

@@ -0,0 +1,4 @@
+export default function NavBar({ appName, nameWidth }: {
+    appName: string;
+    nameWidth?: number;
+}): JSX.Element;

package/dist/workspace/utopia-ui/src/Components/AppShell/SetAssetsApi.d.ts

@@ -0,0 +1,4 @@
+import { AssetsApi } from '../../types';
+export declare const SetAssetsApi: ({ assetsApi }: {
+    assetsApi: AssetsApi;
+}) => JSX.Element;

package/dist/workspace/utopia-ui/src/Components/AppShell/SideBar.d.ts

@@ -0,0 +1,12 @@
+declare type route = {
+    path: string;
+    icon: JSX.Element;
+    name: string;
+    submenu?: route;
+    blank?: boolean;
+};
+export declare function SideBar({ routes, bottomRoutes }: {
+    routes: route[];
+    bottomRoutes?: route[];
+}): JSX.Element;
+export {};

package/dist/workspace/utopia-ui/src/Components/AppShell/SidebarSubmenu.d.ts

@@ -0,0 +1,7 @@
+declare function SidebarSubmenu({ submenu, name, icon }: {
+    path: string;
+    icon: JSX.Element;
+    name: string;
+    submenu?: any | undefined;
+}): JSX.Element;
+export default SidebarSubmenu;

package/dist/workspace/utopia-ui/src/Components/AppShell/hooks/useAssets.d.ts

@@ -0,0 +1,13 @@
+import * as React from "react";
+import { AssetsApi } from '../../../types';
+declare type UseAssetManagerResult = ReturnType<typeof useAssetsManager>;
+declare function useAssetsManager(): {
+    api: AssetsApi;
+    setAssetsApi: (api: AssetsApi) => void;
+};
+export declare const AssetsProvider: React.FunctionComponent<{
+    children?: React.ReactNode;
+}>;
+export declare const useAssetApi: () => AssetsApi;
+export declare const useSetAssetApi: () => UseAssetManagerResult["setAssetsApi"];
+export {};

package/dist/workspace/utopia-ui/src/Components/AppShell/index.d.ts

@@ -0,0 +1,3 @@
+export { AppShell } from "./AppShell";
+export { SideBar } from "./SideBar";
+export { Content } from "./Content";

package/dist/workspace/utopia-ui/src/Components/Auth/LoginPage.d.ts

@@ -0,0 +1 @@
+export declare function LoginPage(): JSX.Element;

package/dist/workspace/utopia-ui/src/Components/Auth/RequestPasswordPage.d.ts

@@ -0,0 +1,3 @@
+export declare function RequestPasswordPage({ reset_url }: {
+    reset_url: any;
+}): JSX.Element;

package/dist/workspace/utopia-ui/src/Components/Auth/SetNewPasswordPage.d.ts

@@ -0,0 +1 @@
+export declare function SetNewPasswordPage(): JSX.Element;

package/dist/workspace/utopia-ui/src/Components/Auth/SignupPage.d.ts

@@ -0,0 +1 @@
+export declare function SignupPage(): JSX.Element;

package/dist/workspace/utopia-ui/src/Components/Auth/index.d.ts

@@ -0,0 +1,5 @@
+export { AuthProvider, useAuth } from "./useAuth";
+export { LoginPage } from "./LoginPage";
+export { SignupPage } from './SignupPage';
+export { RequestPasswordPage } from './RequestPasswordPage';
+export { SetNewPasswordPage } from './SetNewPasswordPage';

package/dist/{Components/Auth/authDirectus.d.ts → workspace/utopia-ui/src/Components/Auth/useAuth.d.ts}

@@ -10,15 +10,17 @@ declare type AuthCredentials = {
     otp?: string | undefined;
 };
 declare type AuthContextProps = {
-    isAuthenticated: Boolean;
+    isAuthenticated: boolean;
     user: UserItem | null;
     login: (credentials: AuthCredentials) => Promise<UserItem | undefined>;
     register: (credentials: AuthCredentials, userName: string) => Promise<UserItem | undefined>;
     loading: Boolean;
-    logout: () => void;
+    logout: () => Promise<any>;
     updateUser: (user: UserItem) => any;
     token: String | null;
+    requestPasswordReset: (email: string, reset_url: string) => Promise<any>;
+    passwordReset: (token: string, new_password: string) => Promise<any>;
 };
-export declare const AuthProviderDirectus: ({ userApi, children }: AuthProviderProps) => JSX.Element;
-export declare const useAuthDirectus: () => AuthContextProps;
+export declare const AuthProvider: ({ userApi, children }: AuthProviderProps) => JSX.Element;
+export declare const useAuth: () => AuthContextProps;
 export {};

package/dist/workspace/utopia-ui/src/Components/Gaming/Modal.d.ts

@@ -0,0 +1,5 @@
+import * as React from "react";
+export declare function Modal({ children, showOnStartup }: {
+    children: React.ReactNode;
+    showOnStartup?: boolean;
+}): JSX.Element;

package/dist/workspace/utopia-ui/src/Components/Gaming/Quests.d.ts

@@ -0,0 +1 @@
+export declare function Quests(): JSX.Element;

package/dist/workspace/utopia-ui/src/Components/Gaming/hooks/useQuests.d.ts

@@ -0,0 +1,13 @@
+import * as React from "react";
+declare type UseQuestManagerResult = ReturnType<typeof useQuestsManager>;
+declare function useQuestsManager(initialOpen: boolean): {
+    open: boolean;
+    setQuestsOpen: (open: boolean) => void;
+};
+export declare const QuestsProvider: React.FunctionComponent<{
+    initialOpen: boolean;
+    children?: React.ReactNode;
+}>;
+export declare const useQuestsOpen: () => boolean;
+export declare const useSetQuestOpen: () => UseQuestManagerResult["setQuestsOpen"];
+export {};

package/dist/workspace/utopia-ui/src/Components/Gaming/index.d.ts

@@ -0,0 +1,2 @@
+export { Modal } from './Modal';
+export { Quests } from './Quests';

package/dist/workspace/utopia-ui/src/Components/Input/Autocomplete.d.ts

@@ -0,0 +1,7 @@
+export declare const Autocomplete: ({ inputProps, suggestions, onSelected, pushFilteredSuggestions, setFocus }: {
+    inputProps: any;
+    suggestions: Array<any>;
+    onSelected: (suggestion: any) => void;
+    pushFilteredSuggestions?: any[] | undefined;
+    setFocus?: boolean | undefined;
+}) => JSX.Element;

package/dist/workspace/utopia-ui/src/Components/Input/SelectBox.d.ts

@@ -0,0 +1,16 @@
+declare type SelectBoxProps = {
+    labelTitle?: string;
+    labelStyle?: string;
+    type?: string;
+    containerStyle?: string;
+    defaultValue: string;
+    placeholder?: string;
+    updateFormValue: (value: string) => void;
+    options: {
+        name: string;
+        value: string;
+    }[];
+    labelDescription?: string;
+};
+export declare function SelectBox(props: SelectBoxProps): JSX.Element;
+export {};

package/dist/{Components/Input/TributeTextAreaInput copy.d.ts → workspace/utopia-ui/src/Components/Input/TextAreaInput.d.ts}

@@ -1,4 +1,3 @@
-/// <reference types="react" />
 declare type TextAreaProps = {
     labelTitle?: string;
     labelStyle?: string;

package/dist/workspace/utopia-ui/src/Components/Input/TextInput.d.ts

@@ -0,0 +1,14 @@
+declare type InputTextProps = {
+    labelTitle?: string;
+    labelStyle?: string;
+    type?: string;
+    dataField?: string;
+    containerStyle?: string;
+    inputStyle?: string;
+    defaultValue?: string;
+    placeholder?: string;
+    autocomplete?: string;
+    updateFormValue?: (value: string) => void;
+};
+export declare function TextInput({ labelTitle, labelStyle, type, dataField, containerStyle, inputStyle, defaultValue, placeholder, autocomplete, updateFormValue }: InputTextProps): JSX.Element;
+export {};

package/dist/workspace/utopia-ui/src/Components/Input/index.d.ts

@@ -0,0 +1,3 @@
+export { TextAreaInput } from "./TextAreaInput";
+export { TextInput } from "./TextInput";
+export { SelectBox } from "./SelectBox";

package/dist/workspace/utopia-ui/src/Components/Map/ItemForm.d.ts

@@ -0,0 +1,18 @@
+import * as React from 'react';
+import { Item } from '../../types';
+import * as PropTypes from 'prop-types';
+export declare const ItemForm: {
+    ({ children, item, title, setPopupTitle }: {
+        children?: React.ReactNode;
+        item?: Item | undefined;
+        title?: string | undefined;
+        setPopupTitle?: React.Dispatch<React.SetStateAction<string>> | undefined;
+    }): JSX.Element;
+    propTypes: {
+        children: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+        __TYPE: PropTypes.Requireable<string>;
+    };
+    defaultProps: {
+        __TYPE: string;
+    };
+};

package/dist/workspace/utopia-ui/src/Components/Map/ItemView.d.ts

@@ -0,0 +1,16 @@
+import * as React from 'react';
+import { Item } from '../../types';
+import * as PropTypes from 'prop-types';
+export declare const ItemView: {
+    ({ children, item }: {
+        children?: React.ReactNode;
+        item?: Item | undefined;
+    }): JSX.Element;
+    propTypes: {
+        children: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+        __TYPE: PropTypes.Requireable<string>;
+    };
+    defaultProps: {
+        __TYPE: string;
+    };
+};

package/dist/workspace/utopia-ui/src/Components/Map/Layer.d.ts

@@ -0,0 +1,2 @@
+import { LayerProps } from '../../types';
+export declare const Layer: ({ data, children, name, menuIcon, menuText, menuColor, markerIcon, markerShape, markerDefaultColor, api, itemNameField, itemTextField, itemAvatarField, itemColorField, itemOwnerField, itemLatitudeField, itemLongitudeField, itemTagsField, itemOffersField, itemNeedsField, onlyOnePerOwner, customEditLink, setItemFormPopup, itemFormPopup, clusterRef }: LayerProps) => JSX.Element;

package/dist/workspace/utopia-ui/src/Components/Map/Permissions.d.ts

@@ -0,0 +1,6 @@
+import { ItemsApi, Permission } from '../../types';
+export declare function Permissions({ data, api, adminRole }: {
+    data?: Permission[];
+    api?: ItemsApi<Permission>;
+    adminRole?: string;
+}): JSX.Element;

package/dist/workspace/utopia-ui/src/Components/Map/Subcomponents/AddButton.d.ts

@@ -0,0 +1,4 @@
+import * as React from 'react';
+export default function AddButton({ setSelectNewItemPosition }: {
+    setSelectNewItemPosition: React.Dispatch<React.SetStateAction<any>>;
+}): JSX.Element;

package/dist/workspace/utopia-ui/src/Components/Map/Subcomponents/Controls/Control.d.ts

@@ -0,0 +1,6 @@
+import * as React from 'react';
+export declare const Control: ({ position, children, zIndex }: {
+    position: "topLeft" | "topRight" | "bottomLeft" | "bottomRight";
+    children: React.ReactNode;
+    zIndex: string;
+}) => JSX.Element;

package/dist/workspace/utopia-ui/src/Components/Map/Subcomponents/Controls/LayerControl.d.ts

@@ -0,0 +1 @@
+export declare function LayerControl(): JSX.Element;

package/dist/workspace/utopia-ui/src/Components/Map/Subcomponents/Controls/LocateControl.d.ts

@@ -0,0 +1,3 @@
+import 'leaflet.locatecontrol';
+import 'leaflet.locatecontrol/dist/L.Control.Locate.css';
+export declare const LocateControl: () => JSX.Element;

package/dist/workspace/utopia-ui/src/Components/Map/Subcomponents/Controls/QuestControl.d.ts

@@ -0,0 +1 @@
+export declare function QuestControl(): JSX.Element;

package/dist/workspace/utopia-ui/src/Components/Map/Subcomponents/Controls/SearchControl.d.ts

@@ -0,0 +1,3 @@
+export declare const SearchControl: ({ clusterRef }: {
+    clusterRef: any;
+}) => JSX.Element;

package/dist/workspace/utopia-ui/src/Components/Map/Subcomponents/Controls/TagsControl.d.ts

@@ -0,0 +1 @@
+export declare const TagsControl: () => JSX.Element;

package/dist/{Components/Map → workspace/utopia-ui/src/Components/Map/Subcomponents}/ItemFormPopup.d.ts

@@ -1,12 +1,11 @@
 import * as React from 'react';
 import { LatLng } from 'leaflet';
-import { LayerProps, Item, ItemsApi } from '../../types';
+import { LayerProps, Item } from '../../../types';
 export interface ItemFormPopupProps {
     position: LatLng;
     layer: LayerProps;
     item?: Item;
-    api?: ItemsApi<any>;
     children?: React.ReactNode;
-    setItemFormPopup: React.Dispatch<React.SetStateAction<any>>;
+    setItemFormPopup?: React.Dispatch<React.SetStateAction<ItemFormPopupProps | null>>;
 }
 export declare function ItemFormPopup(props: ItemFormPopupProps): JSX.Element;

package/dist/{Components/Map/Subcomponents → workspace/utopia-ui/src/Components/Map/Subcomponents/ItemPopupComponents}/HeaderView.d.ts

@@ -1,6 +1,6 @@
 import * as React from "react";
-import { ItemFormPopupProps } from "./ItemFormPopup";
-import { Item } from "../../../types";
+import { ItemFormPopupProps } from "../ItemFormPopup";
+import { Item } from "../../../../types";
 export declare function HeaderView({ item, setItemFormPopup }: {
     item: Item;
     setItemFormPopup?: React.Dispatch<React.SetStateAction<ItemFormPopupProps | null>>;

package/dist/workspace/utopia-ui/src/Components/Map/Subcomponents/ItemPopupComponents/PopupButton.d.ts

@@ -0,0 +1,8 @@
+import { Item } from '../../../../types';
+export declare const PopupButton: ({ url, parameterField, text, colorField, item }: {
+    url: string;
+    parameterField?: string | undefined;
+    text: string;
+    colorField?: string | undefined;
+    item?: Item | undefined;
+}) => JSX.Element;

package/dist/workspace/utopia-ui/src/Components/Map/Subcomponents/ItemPopupComponents/PopupStartEndInput.d.ts

@@ -0,0 +1,4 @@
+import { Item } from '../../../../types';
+export declare const PopupStartEndInput: ({ item }: {
+    item?: Item | undefined;
+}) => JSX.Element;

package/dist/workspace/utopia-ui/src/Components/Map/Subcomponents/ItemPopupComponents/PopupTextAreaInput.d.ts

@@ -0,0 +1,7 @@
+import { Item } from '../../../../types';
+export declare const PopupTextAreaInput: ({ dataField, placeholder, style, item }: {
+    dataField: string;
+    placeholder: string;
+    style?: string | undefined;
+    item?: Item | undefined;
+}) => JSX.Element;

package/dist/workspace/utopia-ui/src/Components/Map/Subcomponents/ItemPopupComponents/PopupTextInput.d.ts

@@ -0,0 +1,7 @@
+import { Item } from '../../../../types';
+export declare const PopupTextInput: ({ dataField, placeholder, style, item }: {
+    dataField: string;
+    placeholder: string;
+    style?: string | undefined;
+    item?: Item | undefined;
+}) => JSX.Element;

package/dist/workspace/utopia-ui/src/Components/Map/Subcomponents/ItemPopupComponents/StartEndView.d.ts

@@ -0,0 +1,4 @@
+import { Item } from '../../../../types';
+export declare const StartEndView: ({ item }: {
+    item?: Item | undefined;
+}) => JSX.Element;

package/dist/workspace/utopia-ui/src/Components/Map/Subcomponents/ItemPopupComponents/TextView.d.ts

@@ -0,0 +1,6 @@
+import { Item } from '../../../../types';
+export declare const TextView: ({ item, truncate, itemTextField }: {
+    item?: Item | undefined;
+    truncate?: boolean | undefined;
+    itemTextField?: string | undefined;
+}) => JSX.Element;

package/dist/{Components/Map → workspace/utopia-ui/src/Components/Map/Subcomponents}/ItemViewPopup.d.ts

@@ -1,8 +1,9 @@
 import * as React from 'react';
-import { Item } from '../../types';
+import { Item } from '../../../types';
 import { ItemFormPopupProps } from './ItemFormPopup';
 export interface ItemViewPopupProps {
     item: Item;
+    children?: React.ReactNode;
     setItemFormPopup?: React.Dispatch<React.SetStateAction<ItemFormPopupProps | null>>;
 }
-export declare const ItemViewPopup: (props: ItemViewPopupProps) => JSX.Element;
+export declare const ItemViewPopup: React.ForwardRefExoticComponent<ItemViewPopupProps & React.RefAttributes<unknown>>;

package/dist/workspace/utopia-ui/src/Components/Map/Tags.d.ts

@@ -0,0 +1,5 @@
+import { ItemsApi, Tag } from '../../types';
+export declare function Tags({ data, api }: {
+    data?: Tag[];
+    api?: ItemsApi<Tag>;
+}): JSX.Element;

package/dist/workspace/utopia-ui/src/Components/Map/UtopiaMap.d.ts

@@ -0,0 +1,11 @@
+import "leaflet/dist/leaflet.css";
+import * as React from "react";
+import { LayerProps, UtopiaMapProps } from "../../types";
+import "./UtopiaMap.css";
+export interface MapEventListenerProps {
+    selectNewItemPosition: LayerProps | null;
+    setSelectNewItemPosition: React.Dispatch<any>;
+    setItemFormPopup: React.Dispatch<React.SetStateAction<any>>;
+}
+declare function UtopiaMap({ height, width, center, zoom, children }: UtopiaMapProps): JSX.Element;
+export { UtopiaMap };

package/dist/workspace/utopia-ui/src/Components/Map/hooks/useDebounce.d.ts

@@ -0,0 +1 @@
+export declare const useDebounce: (callback: any, delay: any, deps: any) => void;

package/dist/workspace/utopia-ui/src/Components/Map/hooks/useFilter.d.ts

@@ -0,0 +1,32 @@
+import * as React from "react";
+import { LayerProps, Tag } from "../../../types";
+declare type UseFilterManagerResult = ReturnType<typeof useFilterManager>;
+declare function useFilterManager(initialTags: Tag[]): {
+    filterTags: Tag[];
+    searchPhrase: string;
+    visibleLayers: LayerProps[];
+    addFilterTag: (tag: Tag) => void;
+    removeFilterTag: (name: string) => void;
+    resetFilterTags: () => void;
+    setSearchPhrase: (phrase: string) => void;
+    addVisibleLayer: (layer: LayerProps) => void;
+    toggleVisibleLayer: (layer: LayerProps) => void;
+    resetVisibleLayers: () => void;
+    isLayerVisible: (layer: LayerProps) => boolean;
+};
+export declare const FilterProvider: React.FunctionComponent<{
+    initialTags: Tag[];
+    children?: React.ReactNode;
+}>;
+export declare const useFilterTags: () => Tag[];
+export declare const useAddFilterTag: () => UseFilterManagerResult["addFilterTag"];
+export declare const useRemoveFilterTag: () => UseFilterManagerResult["removeFilterTag"];
+export declare const useResetFilterTags: () => UseFilterManagerResult["resetFilterTags"];
+export declare const useSearchPhrase: () => UseFilterManagerResult["searchPhrase"];
+export declare const useSetSearchPhrase: () => UseFilterManagerResult["setSearchPhrase"];
+export declare const useVisibleLayer: () => UseFilterManagerResult["visibleLayers"];
+export declare const useAddVisibleLayer: () => UseFilterManagerResult["addVisibleLayer"];
+export declare const useToggleVisibleLayer: () => UseFilterManagerResult["toggleVisibleLayer"];
+export declare const useResetVisibleLayers: () => UseFilterManagerResult["resetVisibleLayers"];
+export declare const useIsLayerVisible: () => UseFilterManagerResult["isLayerVisible"];
+export {};

package/dist/workspace/utopia-ui/src/Components/Map/hooks/useItems.d.ts

@@ -0,0 +1,26 @@
+import * as React from "react";
+import { Item, LayerProps } from "../../../types";
+declare type UseItemManagerResult = ReturnType<typeof useItemsManager>;
+declare function useItemsManager(initialItems: Item[]): {
+    items: Item[];
+    addItem: (item: Item) => void;
+    updateItem: (item: Item) => void;
+    removeItem: (item: Item) => void;
+    resetItems: (layer: LayerProps) => void;
+    setItemsApi: (layer: LayerProps) => void;
+    setItemsData: (layer: LayerProps) => void;
+    allItemsLoaded: boolean;
+};
+export declare const ItemsProvider: React.FunctionComponent<{
+    initialItems: Item[];
+    children?: React.ReactNode;
+}>;
+export declare const useItems: () => Item[];
+export declare const useAddItem: () => UseItemManagerResult["addItem"];
+export declare const useUpdateItem: () => UseItemManagerResult["updateItem"];
+export declare const useRemoveItem: () => UseItemManagerResult["removeItem"];
+export declare const useResetItems: () => UseItemManagerResult["resetItems"];
+export declare const useSetItemsApi: () => UseItemManagerResult["setItemsApi"];
+export declare const useSetItemsData: () => UseItemManagerResult["setItemsData"];
+export declare const useAllItemsLoaded: () => UseItemManagerResult["allItemsLoaded"];
+export {};

package/dist/workspace/utopia-ui/src/Components/Map/hooks/useLayers.d.ts

@@ -0,0 +1,14 @@
+import * as React from "react";
+import { LayerProps } from "../../../types";
+declare type UseItemManagerResult = ReturnType<typeof useLayerManager>;
+declare function useLayerManager(initialLayers: LayerProps[]): {
+    layers: LayerProps[];
+    addLayer: (layer: LayerProps) => void;
+};
+export declare const LayersProvider: React.FunctionComponent<{
+    initialLayers: LayerProps[];
+    children?: React.ReactNode;
+}>;
+export declare const useLayers: () => LayerProps[];
+export declare const useAddLayer: () => UseItemManagerResult["addLayer"];
+export {};

package/dist/workspace/utopia-ui/src/Components/Map/hooks/useLeafletRefs.d.ts

@@ -0,0 +1,22 @@
+import * as React from "react";
+import { Item } from "../../../types";
+import { Marker, Popup } from "leaflet";
+declare type LeafletRef = {
+    item: Item;
+    marker: Marker;
+    popup: Popup;
+};
+declare type UseLeafletRefsManagerResult = ReturnType<typeof useLeafletRefsManager>;
+declare function useLeafletRefsManager(initialLeafletRefs: {}): {
+    leafletRefs: Record<string, LeafletRef>;
+    addMarker: (item: Item, marker: Marker) => void;
+    addPopup: (item: Item, popup: Popup) => void;
+};
+export declare const LeafletRefsProvider: React.FunctionComponent<{
+    initialLeafletRefs: {};
+    children?: React.ReactNode;
+}>;
+export declare const useLeafletRefs: () => Record<string, LeafletRef>;
+export declare const useAddMarker: () => UseLeafletRefsManagerResult["addMarker"];
+export declare const useAddPopup: () => UseLeafletRefsManagerResult["addPopup"];
+export {};