@intra-mart/smartlime 0.0.1-beta

package/lib/packages/OAuth/hooks/useIMToken.js

@@ -0,0 +1,21 @@
+import { useContext, useEffect, useReducer, useRef } from 'react';
+import { Context as DefaultContext } from '../Context';
+import { IMOAuthError } from '../IMOAuthError';
+export const useIMToken = (Context) => {
+    const initRef = useRef(true);
+    const [, forceRender] = useReducer((s) => s + 1, 0);
+    const oauthContext = useContext(Context || DefaultContext);
+    if (oauthContext == null) {
+        throw new IMOAuthError('useIMToken requires either a Context provide or an ancestor element with a IMOAuthProvider.');
+    }
+    if (initRef.current) {
+        initRef.current = false;
+        oauthContext.authStateRenderTarget.addEventListener(forceRender);
+    }
+    useEffect(() => {
+        return () => {
+            oauthContext.tokenRenderTarget.removeEventListener(forceRender);
+        };
+    }, []);
+    return oauthContext.getToken();
+};

package/lib/packages/OAuth/hooks/useStartAuth.d.ts

@@ -0,0 +1,2 @@
+import { Context as DefaultContext } from '../Context';
+export declare const useStartAuth: (Context?: typeof DefaultContext) => () => Promise<import("..").StartAuthResult>;

package/lib/packages/OAuth/hooks/useStartAuth.js

@@ -0,0 +1,12 @@
+import { useContext, useMemo } from 'react';
+import { Context as DefaultContext } from '../Context';
+import { IMOAuthError } from '../IMOAuthError';
+export const useStartAuth = (Context) => {
+    const oauthContext = useContext(Context || DefaultContext);
+    if (oauthContext == null) {
+        throw new IMOAuthError('useStartAuth requires either a Context provide or an ancestor element with a IMOAuthProvider.');
+    }
+    return useMemo(() => {
+        return oauthContext.startAuth;
+    }, [oauthContext.startAuth]);
+};

package/lib/packages/OAuth/index.d.ts

@@ -0,0 +1,39 @@
+/// <reference types="react" />
+import { AuthSessionResult, Prompt } from 'expo-auth-session';
+import { Context as DefaultContext } from './Context';
+export type AuthState = 'initializing' | 'unauthorized' | 'authorized';
+export type TokenState = {
+    baseUrl: string;
+    accessToken: string;
+    refreshToken?: string;
+    expirationDate?: number;
+};
+export type StartAuthResult = {
+    readonly type: 'cancel' | 'dismiss' | 'opened' | 'locked' | 'error';
+    readonly detail: AuthSessionResult;
+} | {
+    readonly type: 'success';
+} | {
+    readonly type: 'exception';
+    readonly exceptionDetail: unknown;
+};
+export declare const IMPrompt: {
+    readonly Login: Prompt.Login;
+};
+interface RequestConfig {
+    redirectUri: string;
+    clientId: string;
+    clientSecret: string;
+    scopes: string[];
+    state?: string;
+    prompt?: Prompt.Login;
+}
+interface IMOAuthProps {
+    children: JSX.Element;
+    requestConfig: RequestConfig;
+    remainingTimeToRunRefresh?: number;
+    storageKey?: string;
+    oauthContext?: typeof DefaultContext;
+}
+export declare const IMOAuth: ({ children, requestConfig, remainingTimeToRunRefresh, storageKey, oauthContext, }: IMOAuthProps) => JSX.Element;
+export {};

package/lib/packages/OAuth/index.js

@@ -0,0 +1,299 @@
+import AsyncStorage from '@react-native-async-storage/async-storage';
+import { exchangeCodeAsync, loadAsync, Prompt, refreshAsync, } from 'expo-auth-session';
+import { useCallback, useLayoutEffect, useMemo, useRef, } from 'react';
+import { Context as DefaultContext } from './Context';
+import { IMOAuthError } from './IMOAuthError';
+import { useRenderTarget } from '../../_shared/renderTarget';
+import { useIMBaseUrl } from '../..';
+import { join } from '../../utils/path';
+const SUCCESS = 'success';
+const EXCEPTION = 'exception';
+const DEFAULT_STORAGE_KEY = '@example:IMAuthKey';
+const DEFAULT_REMAINING_TIME_TO_RUN_REFRESH = 360000;
+export const IMPrompt = {
+    Login: Prompt.Login,
+};
+const baseRequestConfig = {
+    responseType: 'code',
+    usePKCE: true,
+};
+const useRequestConfig = (userProps) => {
+    return useMemo(() => {
+        return {
+            ...baseRequestConfig,
+            ...userProps,
+            extraParams: {
+                redirect_uri: userProps.redirectUri,
+            },
+        };
+    }, [userProps]);
+};
+const encodeBaseURI = () => {
+    const baseUrl = useIMBaseUrl();
+    return useMemo(() => {
+        return encodeURI(baseUrl);
+    }, [baseUrl]);
+};
+const useDiscovery = () => {
+    const encodedBaseUrl = encodeBaseURI();
+    return useMemo(() => {
+        return {
+            authorizationEndpoint: join(encodedBaseUrl, '/oauth/authorize'),
+            tokenEndpoint: join(encodedBaseUrl, '/oauth/token'),
+        };
+    }, [encodedBaseUrl]);
+};
+const useStorageKey = (storageKey) => {
+    return useMemo(() => {
+        return storageKey ? storageKey : DEFAULT_STORAGE_KEY;
+    }, [storageKey]);
+};
+const useRemainingTimeToRunRefresh = (remainingTimeToRunRefresh) => {
+    return useMemo(() => {
+        return remainingTimeToRunRefresh
+            ? remainingTimeToRunRefresh
+            : DEFAULT_REMAINING_TIME_TO_RUN_REFRESH;
+    }, [remainingTimeToRunRefresh]);
+};
+const saveTokenStorage = async (storageKey, baseUrl, accessToken, refreshToken, expirationDate) => {
+    const item = {
+        baseUrl,
+        accessToken,
+        refreshToken,
+        expirationDate,
+    };
+    return await AsyncStorage.setItem(storageKey, JSON.stringify(item));
+};
+const deleteTokenStorage = async (tokenStorageKey) => {
+    return await AsyncStorage.removeItem(tokenStorageKey);
+};
+const getTokenStorage = async (storageKey) => {
+    const state = await AsyncStorage.getItem(storageKey);
+    if (state == null)
+        return;
+    const result = JSON.parse(state);
+    return result;
+};
+const useAuthStateRef = (renderTarget) => {
+    const ref = useRef('initializing');
+    const setter = useCallback((state, silent) => {
+        if (ref.current === state)
+            return;
+        ref.current = state;
+        if (!silent)
+            renderTarget.dispatch();
+    }, []);
+    const getter = useCallback(() => ref.current, []);
+    return [ref, setter, getter];
+};
+const useTokenRef = (renderTarget) => {
+    const ref = useRef(null);
+    const setter = useCallback((token, silent) => {
+        if (ref.current === token)
+            return;
+        ref.current = token;
+        if (!silent)
+            renderTarget.dispatch();
+    }, []);
+    const getter = useCallback(() => ref.current, []);
+    return [ref, setter, getter];
+};
+const createExpirationDate = (expiresIn) => {
+    const nowData = new Date().getTime();
+    return nowData + expiresIn * 1000;
+};
+const checkExpirationDateOfToken = (expirationDate, remainingTimeToRunRefresh) => {
+    const nowData = new Date().getTime();
+    if (remainingTimeToRunRefresh > expirationDate - nowData)
+        return true;
+    return false;
+};
+const useRefresh = (storageKey, refreshTokenRef, expirationDateRef, requestConfig, discovery, setToken, destroy) => {
+    const baseUrl = useIMBaseUrl();
+    const lockedRef = useRef(false);
+    const waitingLineRef = useRef([]);
+    const lock = useCallback(() => {
+        lockedRef.current = true;
+    }, []);
+    const unlock = useCallback((error) => {
+        if (error) {
+            waitingLineRef.current.forEach((v) => {
+                v.reject(error);
+            });
+        }
+        else {
+            waitingLineRef.current.forEach((v) => {
+                v.resolve();
+            });
+        }
+        waitingLineRef.current = [];
+        lockedRef.current = false;
+    }, []);
+    return useCallback(async () => {
+        if (refreshTokenRef.current == null)
+            throw new IMOAuthError('refresh token does not exist.');
+        if (lockedRef.current === true) {
+            return new Promise((resolve, reject) => {
+                waitingLineRef.current.push({ resolve, reject });
+            });
+        }
+        else {
+            lock();
+            try {
+                // HACK & WARNING
+                // currently (expo-auth-session@3.3.1), clientId and clientSecret are ignored due to a bug, so set them to extraParams and process them once.
+                // RefreshTokenRequest's getQueryBody only considers refresh_token and sends only refresh_token.
+                // set it to extraParams, it works.
+                const tokenResponse = await refreshAsync({
+                    clientId: requestConfig.clientId,
+                    // clientSecret: requestConfig.clientSecret,
+                    refreshToken: refreshTokenRef.current,
+                    extraParams: {
+                        // client_id: requestConfig.clientId,
+                        client_secret: requestConfig.clientSecret,
+                    },
+                }, discovery);
+                const { accessToken, refreshToken, expiresIn } = tokenResponse;
+                const expirationDate = expiresIn ? createExpirationDate(expiresIn) : 0;
+                await saveTokenStorage(storageKey, baseUrl, accessToken, refreshToken, expirationDate);
+                refreshTokenRef.current = refreshToken ? refreshToken : null;
+                expirationDateRef.current = expirationDate;
+                setToken(accessToken);
+                unlock();
+            }
+            catch (e) {
+                destroy();
+                const error = new IMOAuthError('an exception occurred while refreshing the token.', {
+                    cause: e instanceof Error ? e : undefined,
+                });
+                unlock(error);
+                throw error;
+            }
+        }
+    }, [storageKey, requestConfig, discovery, destroy]);
+};
+const useStartAuth = (storageKey, remainingTimeToRunRefresh, refreshTokenRef, expirationDateRef, requestConfig, discovery, setToken, refresh, setAuthState) => {
+    const currentBaseUrl = useIMBaseUrl();
+    useLayoutEffect(() => {
+        (async () => {
+            const tokenState = await getTokenStorage(storageKey);
+            if (tokenState) {
+                const { baseUrl, accessToken, refreshToken, expirationDate } = tokenState;
+                const expired = checkExpirationDateOfToken(expirationDate ? expirationDate : 0, remainingTimeToRunRefresh);
+                refreshTokenRef.current = refreshToken ? refreshToken : null;
+                expirationDateRef.current = expirationDate ? expirationDate : null;
+                if (currentBaseUrl === baseUrl) {
+                    if (expired) {
+                        await refresh(); // NOTE consideration of how users can catch errors thrown here.
+                    }
+                    else {
+                        setToken(accessToken);
+                    }
+                    setAuthState('authorized');
+                }
+                else {
+                    setAuthState('unauthorized');
+                }
+            }
+            else {
+                setAuthState('unauthorized');
+            }
+        })();
+    }, [storageKey, remainingTimeToRunRefresh, refresh]);
+    const startAuth = useCallback(async () => {
+        const authRequest = await loadAsync({
+            ...requestConfig,
+        }, discovery);
+        try {
+            const authSessionResult = await authRequest.promptAsync(discovery);
+            if (authSessionResult.type !== SUCCESS) {
+                const failedResult = {
+                    type: authSessionResult.type,
+                    detail: authSessionResult,
+                };
+                return failedResult;
+            }
+            if (authSessionResult.params.code == null ||
+                authSessionResult.params.state == null ||
+                authRequest.codeVerifier == null) {
+                throw new IMOAuthError('required parameter is missing in authSessionResult.');
+            }
+            const tokenResponse = await exchangeCodeAsync({
+                ...requestConfig,
+                code: authSessionResult.params.code,
+                extraParams: {
+                    grant_type: 'authorization_code',
+                    code_verifier: authRequest.codeVerifier,
+                },
+            }, discovery);
+            const { accessToken, refreshToken, expiresIn } = tokenResponse;
+            const expirationDate = expiresIn ? createExpirationDate(expiresIn) : 0;
+            await saveTokenStorage(storageKey, currentBaseUrl, accessToken, refreshToken, expirationDate);
+            refreshTokenRef.current = refreshToken ? refreshToken : null;
+            expirationDateRef.current = expirationDate;
+            setToken(accessToken);
+            setAuthState('authorized');
+            const successResult = {
+                type: authSessionResult.type,
+            };
+            return successResult;
+        }
+        catch (e) {
+            const exceptionResult = {
+                type: EXCEPTION,
+                exceptionDetail: e,
+            };
+            return exceptionResult;
+        }
+    }, [requestConfig, discovery]);
+    return startAuth;
+};
+const useDestroy = (storageKey, refreshTokenRef, expirationDateRef, setToken, setAuthState) => {
+    return useCallback(async () => {
+        await deleteTokenStorage(storageKey);
+        setToken(null);
+        refreshTokenRef.current = null;
+        expirationDateRef.current = null;
+        setAuthState('unauthorized');
+    }, [storageKey, setAuthState]);
+};
+const useGetTokenAsync = (tokenRef, expirationDateRef, remainingTimeToRunRefresh, refresh) => {
+    return useCallback(async () => {
+        if (expirationDateRef.current != null) {
+            const expired = checkExpirationDateOfToken(expirationDateRef.current, remainingTimeToRunRefresh);
+            if (expired) {
+                await refresh();
+            }
+        }
+        return tokenRef.current;
+    }, [refresh]);
+};
+export const IMOAuth = ({ children, requestConfig, remainingTimeToRunRefresh, storageKey, oauthContext, }) => {
+    const Context = oauthContext || DefaultContext;
+    const contextRef = useRef();
+    const authStateRenderTarget = useRenderTarget();
+    const [, setAuthState, getAuthState] = useAuthStateRef(authStateRenderTarget);
+    const tokenRenderTarget = useRenderTarget();
+    const [tokenRef, setToken, getToken] = useTokenRef(tokenRenderTarget);
+    const refreshTokenRef = useRef(null);
+    const expirationDateRef = useRef(null);
+    const _storageKey = useStorageKey(storageKey);
+    const _remainingTimeToRunRefresh = useRemainingTimeToRunRefresh(remainingTimeToRunRefresh);
+    const _requestConfig = useRequestConfig(requestConfig);
+    const _discovery = useDiscovery();
+    const destroy = useDestroy(_storageKey, refreshTokenRef, expirationDateRef, setToken, setAuthState);
+    const refresh = useRefresh(_storageKey, refreshTokenRef, expirationDateRef, _requestConfig, _discovery, setToken, destroy);
+    const startAuth = useStartAuth(_storageKey, _remainingTimeToRunRefresh, refreshTokenRef, expirationDateRef, _requestConfig, _discovery, setToken, refresh, setAuthState);
+    const getTokenAsync = useGetTokenAsync(tokenRef, expirationDateRef, _remainingTimeToRunRefresh, refresh);
+    contextRef.current = {
+        getAuthState,
+        getToken,
+        getTokenAsync,
+        refresh,
+        destroy,
+        startAuth,
+        tokenRenderTarget,
+        authStateRenderTarget,
+    };
+    return (<Context.Provider value={contextRef.current}>{children}</Context.Provider>);
+};

package/lib/packages/Search/Context.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+import { StartSearchArg, StartSearchResult } from '.';
+export interface SearchContext {
+    start: ({ target, type, paramString, }: StartSearchArg) => Promise<StartSearchResult<typeof type>>;
+}
+export declare const Context: import("react").Context<SearchContext | null>;

package/lib/packages/Search/Context.js

@@ -0,0 +1,2 @@
+import { createContext } from 'react';
+export const Context = createContext(null);

package/lib/packages/Search/IMSearchError.d.ts

@@ -0,0 +1,4 @@
+export declare const errorType = "IMSearchError";
+export declare class IMSearchError extends Error {
+    constructor(message: string, options?: ErrorOptions);
+}

package/lib/packages/Search/IMSearchError.js

@@ -0,0 +1,10 @@
+export const errorType = 'IMSearchError';
+export class IMSearchError extends Error {
+    constructor(message, options) {
+        super(message, options);
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, IMSearchError);
+        }
+        this.name = errorType;
+    }
+}

package/lib/packages/Search/hooks/index.d.ts

@@ -0,0 +1,11 @@
+export * from './useIMSearch';
+export * from './useUserSerch';
+export * from './useDepartmentSerch';
+export * from './useDepartmentTopSerch';
+export * from './usePostSerch';
+export * from './usePublicGroupSerch';
+export * from './usePublicGroupTopSerch';
+export * from './useRoleSerch';
+export * from './useUserAdditionalInformationSearch';
+export * from './useDepartmentPostSearch';
+export * from './usePublicGroupRoleSerch';

package/lib/packages/Search/hooks/index.js

@@ -0,0 +1,11 @@
+export * from './useIMSearch';
+export * from './useUserSerch';
+export * from './useDepartmentSerch';
+export * from './useDepartmentTopSerch';
+export * from './usePostSerch';
+export * from './usePublicGroupSerch';
+export * from './usePublicGroupTopSerch';
+export * from './useRoleSerch';
+export * from './useUserAdditionalInformationSearch';
+export * from './useDepartmentPostSearch';
+export * from './usePublicGroupRoleSerch';

package/lib/packages/Search/hooks/useDepartmentPostSearch.d.ts

@@ -0,0 +1,2 @@
+import { DepartmentPostDepartmentSet, DepartmentPostSearchResult } from '../types';
+export declare const useDepartmentPostSearch: (paramString: string) => (departmentSet: DepartmentPostDepartmentSet, init?: RequestInit) => Promise<DepartmentPostSearchResult>;

package/lib/packages/Search/hooks/useDepartmentPostSearch.js

@@ -0,0 +1,48 @@
+import { useCallback } from 'react';
+import { useIMFetch } from '../../Fetch';
+import { IMSearchError } from '../IMSearchError';
+import { makeParamStringIncludeCriteria, makeParamStringIncludeProp, makeParamStringIncludeTargetDate, } from './utils';
+const getEncodeParams = (parameters, userCriteria) => {
+    return `parameters=${encodeURIComponent(parameters)}&userCriteria=${encodeURIComponent(userCriteria)}`;
+};
+export const useDepartmentPostSearch = (paramString) => {
+    const imFetch = useIMFetch();
+    const search = useCallback(async (departmentSet, init) => {
+        try {
+            const parameters = makeParamStringIncludeCriteria(makeParamStringIncludeProp(makeParamStringIncludeTargetDate(paramString)));
+            const userCriteria = JSON.stringify({ department_set: departmentSet });
+            const body = getEncodeParams(parameters, userCriteria);
+            const response = await imFetch('api/smacolow/master/search/company_post/tree_with_attached_post/post', {
+                ...init,
+                headers: {
+                    ...init?.headers,
+                    'Content-Type': 'application/x-www-form-urlencoded',
+                    Accept: 'application/json',
+                },
+                method: 'POST',
+                body: body,
+            });
+            if (response.status === 200) {
+                const json = await response.json();
+                return {
+                    type: 'success',
+                    response: json,
+                };
+            }
+            else {
+                return {
+                    type: 'error',
+                    detail: new IMSearchError('response status other than 200 was returned.'),
+                    response: response,
+                };
+            }
+        }
+        catch (e) {
+            return {
+                type: 'exception',
+                detail: e,
+            };
+        }
+    }, [paramString]);
+    return search;
+};

package/lib/packages/Search/hooks/useDepartmentSerch.d.ts

@@ -0,0 +1,2 @@
+import { DepartmentSearcResult } from '../types';
+export declare const useDepartmentSerch: (paramString: string) => (keyword: string, init?: RequestInit) => Promise<DepartmentSearcResult>;

package/lib/packages/Search/hooks/useDepartmentSerch.js

@@ -0,0 +1,56 @@
+import { useCallback } from 'react';
+import { useIMFetch } from '../../Fetch';
+import { IMSearchError } from '../IMSearchError';
+import { makeParamStringIncludeCriteria, makeParamStringIncludeProp, makeParamStringIncludeTargetDate, } from './utils';
+const getEncodeParams = (parameters, userCriteria) => {
+    return `parameters=${encodeURIComponent(parameters)}&userCriteria=${encodeURIComponent(userCriteria)}`;
+};
+export const useDepartmentSerch = (paramString) => {
+    const imFetch = useIMFetch();
+    const search = useCallback(async (keyword, init) => {
+        try {
+            const parameters = makeParamStringIncludeCriteria(makeParamStringIncludeProp(makeParamStringIncludeTargetDate(paramString)));
+            const userCriteria = JSON.stringify({
+                keyword: keyword,
+                keyword_target: [
+                    'department_cd',
+                    'department_name',
+                    'department_search_name',
+                ],
+                keyword_type: 'part',
+            });
+            const body = getEncodeParams(parameters, userCriteria);
+            const response = await imFetch('api/smacolow/master/search/department/list', {
+                ...init,
+                headers: {
+                    ...init?.headers,
+                    'Content-Type': 'application/x-www-form-urlencoded',
+                    Accept: 'application/json',
+                },
+                method: 'POST',
+                body: body,
+            });
+            if (response.status === 200) {
+                const json = await response.json();
+                return {
+                    type: 'success',
+                    response: json,
+                };
+            }
+            else {
+                return {
+                    type: 'error',
+                    detail: new IMSearchError('response status other than 200 was returned.'),
+                    response: response,
+                };
+            }
+        }
+        catch (e) {
+            return {
+                type: 'exception',
+                detail: e,
+            };
+        }
+    }, [paramString]);
+    return search;
+};

package/lib/packages/Search/hooks/useDepartmentTopSerch.d.ts

@@ -0,0 +1,2 @@
+import { DepartmentTopSearcResult } from '../types';
+export declare const useDepartmentTopSerch: (paramString: string) => (init?: RequestInit) => Promise<DepartmentTopSearcResult>;

package/lib/packages/Search/hooks/useDepartmentTopSerch.js

@@ -0,0 +1,47 @@
+import { useCallback } from 'react';
+import { useIMFetch } from '../../Fetch';
+import { IMSearchError } from '../IMSearchError';
+import { makeParamStringIncludeCriteria, makeParamStringIncludeTargetDate, } from './utils';
+const getEncodeParams = (parameters) => {
+    return `parameters=${encodeURIComponent(parameters)}`;
+};
+export const useDepartmentTopSerch = (paramString) => {
+    const imFetch = useIMFetch();
+    const search = useCallback(async (init) => {
+        try {
+            const parameters = makeParamStringIncludeCriteria(makeParamStringIncludeCriteria(makeParamStringIncludeTargetDate(paramString)));
+            const body = getEncodeParams(parameters);
+            const response = await imFetch('api/smacolow/master/search/company_post/tree/department_top', {
+                ...init,
+                headers: {
+                    ...init?.headers,
+                    'Content-Type': 'application/x-www-form-urlencoded',
+                    Accept: 'application/json',
+                },
+                method: 'POST',
+                body: body,
+            });
+            if (response.status === 200) {
+                const json = await response.json();
+                return {
+                    type: 'success',
+                    response: json,
+                };
+            }
+            else {
+                return {
+                    type: 'error',
+                    detail: new IMSearchError('response status other than 200 was returned.'),
+                    response: response,
+                };
+            }
+        }
+        catch (e) {
+            return {
+                type: 'exception',
+                detail: e,
+            };
+        }
+    }, [paramString]);
+    return search;
+};

package/lib/packages/Search/hooks/useIMSearch.d.ts

@@ -0,0 +1,4 @@
+import { Context as DefaultContext } from '../Context';
+export declare const useIMSearch: (Context?: typeof DefaultContext) => {
+    startSearch: ({ target, type, paramString, }: import("..").StartSearchArg) => Promise<import("..").StartSearchResult<import("..").SearchType>>;
+};

package/lib/packages/Search/hooks/useIMSearch.js

@@ -0,0 +1,11 @@
+import { useContext } from 'react';
+import { Context as DefaultContext } from '../Context';
+import { IMSearchError } from '../IMSearchError';
+export const useIMSearch = (Context) => {
+    const searchContext = useContext(Context || DefaultContext);
+    if (searchContext == null) {
+        throw new IMSearchError('useIMSearch requires either a Context provide or an ancestor element with a IMSearchProvider');
+    }
+    const { start } = searchContext;
+    return { startSearch: start };
+};

package/lib/packages/Search/hooks/usePostSerch.d.ts

@@ -0,0 +1,2 @@
+import { DepartmentSet, PostSearcResult } from '../types';
+export declare const usePostSerch: (paramString: string) => (departmentSet: DepartmentSet, init?: RequestInit) => Promise<PostSearcResult>;

package/lib/packages/Search/hooks/usePostSerch.js

@@ -0,0 +1,48 @@
+import { useCallback } from 'react';
+import { useIMFetch } from '../../Fetch';
+import { IMSearchError } from '../IMSearchError';
+import { makeParamStringIncludeCriteria, makeParamStringIncludeProp, makeParamStringIncludeTargetDate, } from './utils';
+const getEncodeParams = (parameters, userCriteria) => {
+    return `parameters=${encodeURIComponent(parameters)}&userCriteria=${encodeURIComponent(userCriteria)}`;
+};
+export const usePostSerch = (paramString) => {
+    const imFetch = useIMFetch();
+    const search = useCallback(async (departmentSet, init) => {
+        try {
+            const parameters = makeParamStringIncludeCriteria(makeParamStringIncludeProp(makeParamStringIncludeTargetDate(paramString)));
+            const userCriteria = JSON.stringify({ department_set: departmentSet });
+            const body = getEncodeParams(parameters, userCriteria);
+            const response = await imFetch('api/smacolow/master/search/company_post/tree/post', {
+                ...init,
+                headers: {
+                    ...init?.headers,
+                    'Content-Type': 'application/x-www-form-urlencoded',
+                    Accept: 'application/json',
+                },
+                method: 'POST',
+                body: body,
+            });
+            if (response.status === 200) {
+                const json = await response.json();
+                return {
+                    type: 'success',
+                    response: json,
+                };
+            }
+            else {
+                return {
+                    type: 'error',
+                    detail: new IMSearchError('response status other than 200 was returned.'),
+                    response: response,
+                };
+            }
+        }
+        catch (e) {
+            return {
+                type: 'exception',
+                detail: e,
+            };
+        }
+    }, [paramString]);
+    return search;
+};