\r\n \r\n );\r\n};\r\n","import { useState } from \"react\";\r\n\r\nconst useToggle = (showDefault = false) => {\r\n const [show, setShow] = useState(showDefault);\r\n\r\n const toggle = () => setShow(!show);\r\n\r\n return {\r\n show,\r\n toggle,\r\n setShow,\r\n };\r\n};\r\n\r\nexport default useToggle;\r\n","const storagePrefix = \"real_estate_\";\r\n\r\nconst storage = {\r\n getToken: () => {\r\n return JSON.parse(\r\n window.localStorage.getItem(`${storagePrefix}token`) as string\r\n );\r\n },\r\n setToken: (token: string) => {\r\n window.localStorage.setItem(`${storagePrefix}token`, JSON.stringify(token));\r\n },\r\n clearToken: () => {\r\n window.localStorage.removeItem(`${storagePrefix}token`);\r\n },\r\n};\r\n\r\nexport default storage;\r\n","import { useSelector, useDispatch } from \"react-redux\";\r\n\r\nimport { LoginResponse, onSignOut } from \"@/features/auth\";\r\nimport { RootState } from \"@/store/reducers\";\r\nimport storage from \"@/utils/storage\";\r\n\r\nasync function handleUserResponse(data: LoginResponse) {\r\n const { authToken } = data;\r\n storage.setToken(authToken);\r\n}\r\n\r\nexport async function logoutFn() {\r\n storage.clearToken();\r\n window.location.assign(window.location.origin as unknown as string);\r\n}\r\n\r\nexport const useAuth = () => {\r\n const { isLoggedIn, userDetail } = useSelector(\r\n (state: RootState) => state.login\r\n );\r\n const dispatch = useDispatch();\r\n\r\n const login = (data: LoginResponse) => {\r\n handleUserResponse(data);\r\n };\r\n\r\n const logout = () => {\r\n logoutFn();\r\n dispatch(onSignOut());\r\n };\r\n\r\n return {\r\n isLoggedIn,\r\n role: userDetail?.roles?.[0],\r\n login,\r\n logout,\r\n };\r\n};\r\n","import * as React from \"react\";\r\n\r\nimport { useAuth } from \"./auth\";\r\n\r\nexport enum ROLES {\r\n ADMIN = \"Admin\",\r\n}\r\n\r\nexport const useAuthorization = () => {\r\n const { isLoggedIn, role } = useAuth();\r\n\r\n if (!isLoggedIn) {\r\n throw Error(\"User does not exist!\");\r\n }\r\n\r\n const checkAccess = React.useCallback(\r\n ({ allowedRoles }: { allowedRoles: ROLES[] }) => {\r\n if (allowedRoles && allowedRoles.length > 0) {\r\n return allowedRoles?.includes(role as ROLES);\r\n }\r\n\r\n return true;\r\n },\r\n [role]\r\n );\r\n\r\n return { checkAccess, role };\r\n};\r\n\r\ntype AuthorizationProps = {\r\n forbiddenFallback?: React.ReactNode;\r\n children: React.ReactNode;\r\n} & (\r\n | {\r\n allowedRoles: ROLES[];\r\n policyCheck?: never;\r\n }\r\n | {\r\n allowedRoles?: never;\r\n policyCheck: boolean;\r\n }\r\n);\r\n\r\nexport const Authorization = ({\r\n policyCheck,\r\n allowedRoles,\r\n forbiddenFallback = null,\r\n children,\r\n}: AuthorizationProps) => {\r\n const { checkAccess } = useAuthorization();\r\n\r\n let canAccess = false;\r\n\r\n if (allowedRoles) {\r\n canAccess = checkAccess({ allowedRoles });\r\n }\r\n\r\n if (typeof policyCheck !== \"undefined\") {\r\n canAccess = policyCheck;\r\n }\r\n\r\n return <>{canAccess ? children : forbiddenFallback};\r\n};\r\n","export const RouteConstant = {\r\n Auth: \"/auth/*\",\r\n Login: \"/auth/login\",\r\n Landing: \"/\",\r\n Account: \"/app/account\",\r\n DeleteUser: \"/app/deleteAccount\",\r\n};\r\n","export type Id = { [K in keyof T]: T[K] } & {};\nexport type WithRequiredProp = Omit & Required>;\nexport type Override = T2 extends any ? Omit & T2 : never;\nexport function assertCast(v: any): asserts v is T {}\nexport function safeAssign(target: T, ...args: Array>>): T {\n return Object.assign(target, ...args);\n}\n\n/**\r\n * Convert a Union type `(A|B)` to an intersection type `(A&B)`\r\n */\nexport type UnionToIntersection = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;\nexport type NonOptionalKeys = { [K in keyof T]-?: undefined extends T[K] ? never : K }[keyof T];\nexport type HasRequiredProps = NonOptionalKeys extends never ? False : True;\nexport type OptionalIfAllPropsOptional = HasRequiredProps;\nexport type NoInfer = [T][T extends any ? 0 : never];\nexport type NonUndefined = T extends undefined ? never : T;\nexport type UnwrapPromise = T extends PromiseLike ? V : T;\nexport type MaybePromise = T | PromiseLike;\nexport type OmitFromUnion = T extends any ? Omit : never;\nexport type IsAny = true | false extends (T extends never ? true : false) ? True : False;\nexport type CastAny = IsAny;","export function capitalize(str: string) {\n return str.replace(str[0], str[0].toUpperCase());\n}","import type { QueryCacheKey } from './core/apiState';\nimport type { EndpointDefinition } from './endpointDefinitions';\nimport { isPlainObject } from './core/rtkImports';\nconst cache: WeakMap | undefined = WeakMap ? new WeakMap() : undefined;\nexport const defaultSerializeQueryArgs: SerializeQueryArgs = ({\n endpointName,\n queryArgs\n}) => {\n let serialized = '';\n const cached = cache?.get(queryArgs);\n if (typeof cached === 'string') {\n serialized = cached;\n } else {\n const stringified = JSON.stringify(queryArgs, (key, value) => {\n // Handle bigints\n value = typeof value === 'bigint' ? {\n $bigint: value.toString()\n } : value;\n // Sort the object keys before stringifying, to prevent useQuery({ a: 1, b: 2 }) having a different cache key than useQuery({ b: 2, a: 1 })\n value = isPlainObject(value) ? Object.keys(value).sort().reduce((acc, key) => {\n acc[key] = (value as any)[key];\n return acc;\n }, {}) : value;\n return value;\n });\n if (isPlainObject(queryArgs)) {\n cache?.set(queryArgs, stringified);\n }\n serialized = stringified;\n }\n return `${endpointName}(${serialized})`;\n};\nexport type SerializeQueryArgs = (_: {\n queryArgs: QueryArgs;\n endpointDefinition: EndpointDefinition;\n endpointName: string;\n}) => ReturnType;\nexport type InternalSerializeQueryArgs = (_: {\n queryArgs: any;\n endpointDefinition: EndpointDefinition;\n endpointName: string;\n}) => QueryCacheKey;","export const UNINITIALIZED_VALUE = Symbol();\nexport type UninitializedValue = typeof UNINITIALIZED_VALUE;","import { useEffect, useRef, useMemo } from 'react';\nimport type { SerializeQueryArgs } from '@reduxjs/toolkit/query';\nimport type { EndpointDefinition } from '@reduxjs/toolkit/query';\nexport function useStableQueryArgs(queryArgs: T, serialize: SerializeQueryArgs, endpointDefinition: EndpointDefinition, endpointName: string) {\n const incoming = useMemo(() => ({\n queryArgs,\n serialized: typeof queryArgs == 'object' ? serialize({\n queryArgs,\n endpointDefinition,\n endpointName\n }) : queryArgs\n }), [queryArgs, serialize, endpointDefinition, endpointName]);\n const cache = useRef(incoming);\n useEffect(() => {\n if (cache.current.serialized !== incoming.serialized) {\n cache.current = incoming;\n }\n }, [incoming]);\n return cache.current.serialized === incoming.serialized ? cache.current.queryArgs : queryArgs;\n}","import { useEffect, useRef } from 'react';\nimport { shallowEqual } from 'react-redux';\nexport function useShallowStableValue(value: T) {\n const cache = useRef(value);\n useEffect(() => {\n if (!shallowEqual(cache.current, value)) {\n cache.current = value;\n }\n }, [value]);\n return shallowEqual(cache.current, value) ? cache.current : value;\n}","import { formatProdErrorMessage as _formatProdErrorMessage2 } from \"@reduxjs/toolkit\";\nimport { formatProdErrorMessage as _formatProdErrorMessage } from \"@reduxjs/toolkit\";\nimport type { Selector, ThunkAction, ThunkDispatch, UnknownAction } from '@reduxjs/toolkit';\nimport type { Api, ApiContext, ApiEndpointMutation, ApiEndpointQuery, CoreModule, EndpointDefinitions, MutationActionCreatorResult, MutationDefinition, MutationResultSelectorResult, PrefetchOptions, QueryActionCreatorResult, QueryArgFrom, QueryDefinition, QueryKeys, QueryResultSelectorResult, QuerySubState, ResultTypeFrom, RootState, SerializeQueryArgs, SkipToken, SubscriptionOptions, TSHelpersId, TSHelpersNoInfer, TSHelpersOverride } from '@reduxjs/toolkit/query';\nimport { QueryStatus, skipToken } from '@reduxjs/toolkit/query';\nimport type { DependencyList } from 'react';\nimport { useCallback, useDebugValue, useEffect, useLayoutEffect, useMemo, useRef, useState } from 'react';\nimport { shallowEqual } from 'react-redux';\nimport type { BaseQueryFn } from '../baseQueryTypes';\nimport type { SubscriptionSelectors } from '../core/buildMiddleware/types';\nimport { defaultSerializeQueryArgs } from '../defaultSerializeQueryArgs';\nimport type { UninitializedValue } from './constants';\nimport { UNINITIALIZED_VALUE } from './constants';\nimport type { ReactHooksModuleOptions } from './module';\nimport { useStableQueryArgs } from './useSerializedStableValue';\nimport { useShallowStableValue } from './useShallowStableValue';\n\n// Copy-pasted from React-Redux\nexport const useIsomorphicLayoutEffect = typeof window !== 'undefined' && !!window.document && !!window.document.createElement ? useLayoutEffect : useEffect;\nexport interface QueryHooks> {\n useQuery: UseQuery;\n useLazyQuery: UseLazyQuery;\n useQuerySubscription: UseQuerySubscription;\n useLazyQuerySubscription: UseLazyQuerySubscription;\n useQueryState: UseQueryState;\n}\nexport interface MutationHooks> {\n useMutation: UseMutation;\n}\n\n/**\n * A React hook that automatically triggers fetches of data from an endpoint, 'subscribes' the component to the cached data, and reads the request status and cached data from the Redux store. The component will re-render as the loading status changes and the data becomes available.\n *\n * The query arg is used as a cache key. Changing the query arg will tell the hook to re-fetch the data if it does not exist in the cache already, and the hook will return the data for that query arg once it's available.\n *\n * This hook combines the functionality of both [`useQueryState`](#usequerystate) and [`useQuerySubscription`](#usequerysubscription) together, and is intended to be used in the majority of situations.\n *\n * #### Features\n *\n * - Automatically triggers requests to retrieve data based on the hook argument and whether cached data exists by default\n * - 'Subscribes' the component to keep cached data in the store, and 'unsubscribes' when the component unmounts\n * - Accepts polling/re-fetching options to trigger automatic re-fetches when the corresponding criteria is met\n * - Returns the latest request status and cached data from the Redux store\n * - Re-renders as the request status changes and data becomes available\n */\nexport type UseQuery> = = UseQueryStateDefaultResult>(arg: QueryArgFrom | SkipToken, options?: UseQuerySubscriptionOptions & UseQueryStateOptions) => UseQueryHookResult;\nexport type TypedUseQuery = UseQuery>;\nexport type UseQueryHookResult, R = UseQueryStateDefaultResult> = UseQueryStateResult & UseQuerySubscriptionResult;\n\n/**\n * Helper type to manually type the result\n * of the `useQuery` hook in userland code.\n */\nexport type TypedUseQueryHookResult>> = TypedUseQueryStateResult & TypedUseQuerySubscriptionResult;\ninterface UseQuerySubscriptionOptions extends SubscriptionOptions {\n /**\n * Prevents a query from automatically running.\n *\n * @remarks\n * When `skip` is true (or `skipToken` is passed in as `arg`):\n *\n * - **If the query has cached data:**\n * * The cached data **will not be used** on the initial load, and will ignore updates from any identical query until the `skip` condition is removed\n * * The query will have a status of `uninitialized`\n * * If `skip: false` is set after the initial load, the cached result will be used\n * - **If the query does not have cached data:**\n * * The query will have a status of `uninitialized`\n * * The query will not exist in the state when viewed with the dev tools\n * * The query will not automatically fetch on mount\n * * The query will not automatically run when additional components with the same query are added that do run\n *\n * @example\n * ```tsx\n * // codeblock-meta no-transpile title=\"Skip example\"\n * const Pokemon = ({ name, skip }: { name: string; skip: boolean }) => {\n * const { data, error, status } = useGetPokemonByNameQuery(name, {\n * skip,\n * });\n *\n * return (\n *
\n * {name} - {status}\n *
\n * );\n * };\n * ```\n */\n skip?: boolean;\n /**\n * Defaults to `false`. This setting allows you to control whether if a cached result is already available, RTK Query will only serve a cached result, or if it should `refetch` when set to `true` or if an adequate amount of time has passed since the last successful query result.\n * - `false` - Will not cause a query to be performed _unless_ it does not exist yet.\n * - `true` - Will always refetch when a new subscriber to a query is added. Behaves the same as calling the `refetch` callback or passing `forceRefetch: true` in the action creator.\n * - `number` - **Value is in seconds**. If a number is provided and there is an existing query in the cache, it will compare the current time vs the last fulfilled timestamp, and only refetch if enough time has elapsed.\n *\n * If you specify this option alongside `skip: true`, this **will not be evaluated** until `skip` is false.\n */\n refetchOnMountOrArgChange?: boolean | number;\n}\n\n/**\n * A React hook that automatically triggers fetches of data from an endpoint, and 'subscribes' the component to the cached data.\n *\n * The query arg is used as a cache key. Changing the query arg will tell the hook to re-fetch the data if it does not exist in the cache already.\n *\n * Note that this hook does not return a request status or cached data. For that use-case, see [`useQuery`](#usequery) or [`useQueryState`](#usequerystate).\n *\n * #### Features\n *\n * - Automatically triggers requests to retrieve data based on the hook argument and whether cached data exists by default\n * - 'Subscribes' the component to keep cached data in the store, and 'unsubscribes' when the component unmounts\n * - Accepts polling/re-fetching options to trigger automatic re-fetches when the corresponding criteria is met\n */\nexport type UseQuerySubscription> = (arg: QueryArgFrom | SkipToken, options?: UseQuerySubscriptionOptions) => UseQuerySubscriptionResult;\nexport type TypedUseQuerySubscription = UseQuerySubscription>;\nexport type UseQuerySubscriptionResult> = Pick, 'refetch'>;\n\n/**\n * Helper type to manually type the result\n * of the `useQuerySubscription` hook in userland code.\n */\nexport type TypedUseQuerySubscriptionResult = UseQuerySubscriptionResult>;\nexport type UseLazyQueryLastPromiseInfo> = {\n lastArg: QueryArgFrom;\n};\n\n/**\n * A React hook similar to [`useQuery`](#usequery), but with manual control over when the data fetching occurs.\n *\n * This hook includes the functionality of [`useLazyQuerySubscription`](#uselazyquerysubscription).\n *\n * #### Features\n *\n * - Manual control over firing a request to retrieve data\n * - 'Subscribes' the component to keep cached data in the store, and 'unsubscribes' when the component unmounts\n * - Returns the latest request status and cached data from the Redux store\n * - Re-renders as the request status changes and data becomes available\n * - Accepts polling/re-fetching options to trigger automatic re-fetches when the corresponding criteria is met and the fetch has been manually called at least once\n *\n * #### Note\n *\n * When the trigger function returned from a LazyQuery is called, it always initiates a new request to the server even if there is cached data. Set `preferCacheValue`(the second argument to the function) as `true` if you want it to immediately return a cached value if one exists.\n */\nexport type UseLazyQuery> = = UseQueryStateDefaultResult>(options?: SubscriptionOptions & Omit, 'skip'>) => [LazyQueryTrigger, UseQueryStateResult, UseLazyQueryLastPromiseInfo];\nexport type TypedUseLazyQuery = UseLazyQuery>;\nexport type LazyQueryTrigger> = {\n /**\n * Triggers a lazy query.\n *\n * By default, this will start a new request even if there is already a value in the cache.\n * If you want to use the cache value and only start a request if there is no cache value, set the second argument to `true`.\n *\n * @remarks\n * If you need to access the error or success payload immediately after a lazy query, you can chain .unwrap().\n *\n * @example\n * ```ts\n * // codeblock-meta title=\"Using .unwrap with async await\"\n * try {\n * const payload = await getUserById(1).unwrap();\n * console.log('fulfilled', payload)\n * } catch (error) {\n * console.error('rejected', error);\n * }\n * ```\n */\n (arg: QueryArgFrom, preferCacheValue?: boolean): QueryActionCreatorResult;\n};\nexport type TypedLazyQueryTrigger = LazyQueryTrigger>;\n\n/**\n * A React hook similar to [`useQuerySubscription`](#usequerysubscription), but with manual control over when the data fetching occurs.\n *\n * Note that this hook does not return a request status or cached data. For that use-case, see [`useLazyQuery`](#uselazyquery).\n *\n * #### Features\n *\n * - Manual control over firing a request to retrieve data\n * - 'Subscribes' the component to keep cached data in the store, and 'unsubscribes' when the component unmounts\n * - Accepts polling/re-fetching options to trigger automatic re-fetches when the corresponding criteria is met and the fetch has been manually called at least once\n */\nexport type UseLazyQuerySubscription> = (options?: SubscriptionOptions) => readonly [LazyQueryTrigger, QueryArgFrom | UninitializedValue];\nexport type TypedUseLazyQuerySubscription = UseLazyQuerySubscription>;\nexport type QueryStateSelector