@intra-mart/smartlime 2.0.0-dev.20241125 → 2.0.0-rc.20241226

package/eslint.config.mjs

@@ -0,0 +1,50 @@
+import tsParser from '@typescript-eslint/parser';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import js from '@eslint/js';
+import { FlatCompat } from '@eslint/eslintrc';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const compat = new FlatCompat({
+  baseDirectory: __dirname,
+  recommendedConfig: js.configs.recommended,
+  allConfig: js.configs.all,
+});
+
+export default [
+  ...compat.extends(
+    'plugin:react/recommended',
+    'plugin:@typescript-eslint/recommended',
+    'prettier'
+  ),
+  {
+    languageOptions: {
+      parser: tsParser,
+      ecmaVersion: 2020,
+      sourceType: 'module',
+
+      parserOptions: {
+        ecmaFeatures: {
+          jsx: true,
+        },
+      },
+    },
+
+    settings: {
+      react: {
+        version: 'detect',
+      },
+    },
+
+    rules: {
+      '@typescript-eslint/explicit-module-boundary-types': 'off',
+      '@typescript-eslint/ban-ts-comment': 'off',
+      '@typescript-eslint/no-empty-function': 'off',
+      'react/react-in-jsx-scope': 'off',
+      'react/prop-types': 'off',
+      'react/display-name': 'off',
+      'react/jsx-key': 'off',
+    },
+  },
+];

package/lib/_shared/renderTarget.d.ts

@@ -2,7 +2,7 @@ type ForceRender<T> = (args?: T) => void;
 export declare const createRenderTarget: <T = undefined>() => {
     addEventListener: (callback: ForceRender<T>) => void;
     removeEventListener: (callback: ForceRender<T>) => void;
-    dispatch: (args?: T | undefined) => void;
+    dispatch: (args?: T) => void;
 };
 export type CreateRenderTarget<T = undefined> = typeof createRenderTarget<T>;
 export type RenderTarget<T = undefined> = ReturnType<CreateRenderTarget<T>>;

package/lib/index.d.ts

@@ -13,3 +13,4 @@ export { IMSearch } from './packages/Search';
 export * from './packages/Search/hooks';
 export { IMWebView } from './packages/WebView';
 export * from './packages/WebView/hooks';
+export * from './packages/Copilot/hooks';

package/lib/index.js

@@ -16,3 +16,4 @@ export { IMSearch } from './packages/Search';
 export * from './packages/Search/hooks';
 export { IMWebView } from './packages/WebView';
 export * from './packages/WebView/hooks';
+export * from './packages/Copilot/hooks';

package/lib/packages/Copilot/IMCopilotError.d.ts

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

package/lib/packages/Copilot/IMCopilotError.js

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

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

@@ -0,0 +1 @@
+export * from './useAssistant';

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

@@ -0,0 +1 @@
+export * from './useAssistant';

package/lib/packages/Copilot/hooks/useAssistant/index.d.ts

@@ -0,0 +1,47 @@
+import { AssistantHistory, AssistantMetaData, AssistantRequest, ResponseMessage } from './types';
+export interface AssistantSuccess {
+    type: 'success';
+}
+export interface AssistantError {
+    type: 'error';
+    error: Error;
+}
+export interface DeleteThreadSuccess {
+    type: 'success';
+}
+export interface DeleteThreadError {
+    type: 'error';
+    error: Error;
+}
+export interface GetAssistantMetaDataSuccess<T = unknown> {
+    type: 'success';
+    metaData: AssistantMetaData<T>;
+}
+export interface GetAssistantMetaDataError {
+    type: 'error';
+    error: Error;
+}
+export interface GetAssistantsMetaDataSuccess<T = unknown> {
+    type: 'success';
+    metaDataList: AssistantMetaData<T>[];
+}
+export interface GetAssistantsMetaDataError {
+    type: 'error';
+    error: Error;
+}
+export interface GetAssistantHistorySuccess<T = unknown> {
+    type: 'success';
+    history: AssistantHistory<T>[];
+}
+export interface GetAssistantHistoryError {
+    type: 'error';
+    error: Error;
+}
+export type AssistantCallback = (message: ResponseMessage, finish: boolean) => void;
+export declare const useAssistantt: (assistantId: string, threadId?: string) => {
+    run: (message: AssistantRequest, callback: AssistantCallback) => Promise<AssistantSuccess | AssistantError>;
+    deleteThread: () => Promise<DeleteThreadSuccess | DeleteThreadError>;
+    getAssistantMetaData: <T = unknown>() => Promise<GetAssistantMetaDataSuccess<T> | GetAssistantMetaDataError>;
+    getAssistantsMetaData: <T = unknown>() => Promise<GetAssistantsMetaDataSuccess<T> | GetAssistantsMetaDataError>;
+    getThreadHistory: <T = unknown>() => Promise<GetAssistantHistorySuccess<T> | GetAssistantHistoryError>;
+};

package/lib/packages/Copilot/hooks/useAssistant/index.js

@@ -0,0 +1,194 @@
+import { randomUUID } from 'expo-crypto';
+import { useMemo } from 'react';
+import { join } from '../../../../utils/path';
+import { useIMFetch } from '../../../Fetch';
+import { IMCopilotError } from '../../IMCopilotError';
+import { jsonParse } from './jsonParse';
+const hasFinishMessage = (message) => {
+    if (Object.hasOwn(message, 'finishReason'))
+        return true;
+    return false;
+};
+const isFinishMessage = (message) => {
+    return message.finishReason === 'stop' ? true : false;
+};
+const ASSISTANT_PATH = 'api/copilot/assistant';
+const DELETE_PATH = 'api/copilot/message/history';
+const ASSISTANT_METADATA_PATH = 'api/copilot/assistant';
+const ASSISTANTS_METADATA_PATH = 'api/copilot/assistants';
+const ASSISTANT_HISTORY_PATH = 'api/copilot/message/history';
+export const useAssistantt = (assistantId, threadId) => {
+    const imFetch = useIMFetch();
+    const intternalThreadId = useMemo(() => (threadId ? threadId : randomUUID()), [threadId]);
+    const run = async (message, callback) => {
+        try {
+            const assistantUrl = join(ASSISTANT_PATH, assistantId);
+            const response = await imFetch(assistantUrl, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    // Accept: 'text/event-stream',
+                },
+                body: JSON.stringify({
+                    threadId: intternalThreadId,
+                    message: message.message,
+                    additional: '',
+                }),
+            });
+            if (response.status !== 200) {
+                throw new Error('Proofread API Error');
+            }
+            if (!response.body) {
+                throw new Error('ReadableStream not supported in this environment');
+            }
+            const reader = response.body.getReader();
+            const decoder = new TextDecoder();
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done) {
+                    break;
+                }
+                const jsonText = decoder.decode(value, { stream: true });
+                const jsonList = jsonParse(jsonText);
+                jsonList.forEach((json) => {
+                    if (hasFinishMessage(json)) {
+                        const message = json.message;
+                        const isFinish = isFinishMessage(json);
+                        callback(message, isFinish);
+                    }
+                    else {
+                        console.warn('Unexpected message', json);
+                    }
+                });
+            }
+            return {
+                type: 'success',
+            };
+        }
+        catch (e) {
+            if (e instanceof Error) {
+                return {
+                    type: 'error',
+                    error: new IMCopilotError('Exception thrown while running the assistant.', { cause: e }),
+                };
+            }
+            throw e;
+        }
+    };
+    const deleteThread = async () => {
+        try {
+            const deleteThreadUrl = join(DELETE_PATH, intternalThreadId);
+            const response = await imFetch(deleteThreadUrl, {
+                method: 'DELETE',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+            });
+            if (response.status !== 200) {
+                throw new Error('Proofread API Error');
+            }
+            return {
+                type: 'success',
+            };
+        }
+        catch (e) {
+            if (e instanceof Error) {
+                return {
+                    type: 'error',
+                    error: new IMCopilotError('Exception thrown while attempting to delete the thread.', { cause: e }),
+                };
+            }
+            throw e;
+        }
+    };
+    const getAssistantMetaData = async () => {
+        try {
+            const metaDataUrl = join(ASSISTANT_METADATA_PATH, assistantId);
+            const response = await imFetch(metaDataUrl, {
+                method: 'GET',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+            });
+            if (response.status !== 200) {
+                throw new Error('Proofread API Error');
+            }
+            const json = await response.json();
+            return {
+                type: 'success',
+                metaData: json.data,
+            };
+        }
+        catch (e) {
+            if (e instanceof Error) {
+                return {
+                    type: 'error',
+                    error: new IMCopilotError('Exception thrown while attempting to get metadata.', { cause: e }),
+                };
+            }
+            throw e;
+        }
+    };
+    const getAssistantsMetaData = async () => {
+        try {
+            const response = await imFetch(ASSISTANTS_METADATA_PATH, {
+                method: 'GET',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+            });
+            if (response.status !== 200) {
+                throw new Error('Proofread API Error');
+            }
+            const json = await response.json();
+            return {
+                type: 'success',
+                metaDataList: json.data,
+            };
+        }
+        catch (e) {
+            if (e instanceof Error) {
+                return {
+                    type: 'error',
+                    error: new IMCopilotError('Exception thrown while attempting to get metadata.', { cause: e }),
+                };
+            }
+            throw e;
+        }
+    };
+    const getThreadHistory = async () => {
+        try {
+            const historyUrl = join(ASSISTANT_HISTORY_PATH, intternalThreadId);
+            const response = await imFetch(historyUrl, {
+                method: 'GET',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+            });
+            if (response.status !== 200) {
+                throw new Error('Proofread API Error');
+            }
+            const json = await response.json();
+            return {
+                type: 'success',
+                history: json.data,
+            };
+        }
+        catch (e) {
+            if (e instanceof Error) {
+                return {
+                    type: 'error',
+                    error: new IMCopilotError('Exception thrown while attempting to get history.', { cause: e }),
+                };
+            }
+            throw e;
+        }
+    };
+    return {
+        run,
+        deleteThread,
+        getAssistantMetaData,
+        getAssistantsMetaData,
+        getThreadHistory,
+    };
+};

package/lib/packages/Copilot/hooks/useAssistant/jsonParse.d.ts

@@ -0,0 +1,2 @@
+import { AssistantResponse } from './types';
+export declare const jsonParse: (text: string) => AssistantResponse[];

package/lib/packages/Copilot/hooks/useAssistant/jsonParse.js

@@ -0,0 +1,18 @@
+export const jsonParse = (text) => {
+    const result = [];
+    try {
+        const json = JSON.parse(text);
+        result.push(json);
+        return result;
+    }
+    catch {
+        const jsonLines = text.split('\n');
+        for (const jsonLine of jsonLines) {
+            if (jsonLine !== '') {
+                const json = JSON.parse(jsonLine);
+                result.push(json);
+            }
+        }
+        return result;
+    }
+};

package/lib/packages/Copilot/hooks/useAssistant/types.d.ts

@@ -0,0 +1,52 @@
+export interface AssistantMetaData<T = unknown> {
+    assistantClass: string;
+    assistantType: string;
+    description: string;
+    name: string;
+    parameter: T;
+    listEnable: boolean;
+    storeMessage: boolean;
+}
+export interface AssistantHistory<T = unknown> {
+    role: string;
+    contents: string;
+    toolCalls: [
+        {
+            id: string;
+            type: string;
+            function: {
+                name: string;
+                arguments: string;
+            };
+        }
+    ];
+    additional: T[];
+}
+export interface ResponseMessage {
+    role: string;
+    contents: string | null;
+    toolCalls: unknown | null;
+    additional: unknown | null;
+}
+export interface AssistantResponse {
+    finishReason?: null | 'stop';
+    message: ResponseMessage;
+}
+export interface RequestMessage {
+    role: string;
+    contents: string | null;
+    toolCalls?: unknown;
+    additional?: unknown;
+}
+export interface AssistantRequest {
+    message: RequestMessage;
+}
+export interface AssistantMetaDataResponse<T = unknown> {
+    data: AssistantMetaData<T>;
+}
+export interface AssistantsMetaDataResponse<T = unknown> {
+    data: AssistantMetaData<T>[];
+}
+export interface AssistantHistoryResponse<T = unknown> {
+    data: AssistantHistory<T>[];
+}

package/lib/packages/Copilot/hooks/useAssistant/types.js

@@ -0,0 +1 @@
+export {};

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

@@ -1,14 +1,16 @@
 import { Context as DefaultContext } from '../OAuth/Context';
+import { FetchRequestInit } from 'expo/fetch';
+import { FetchResponse } from 'expo/build/winter/fetch/FetchResponse';
 export type IMJson = {
     error?: boolean;
     errorMessage?: string;
     data?: Record<string, unknown>;
 };
-interface IMResponse<T> extends Response {
+interface IMResponse<T> extends FetchResponse {
     json: () => Promise<T extends IMJson ? T & IMJson : undefined extends T ? IMJson : T>;
 }
 type UseIMFetch = (option?: {
     noValidate?: boolean;
-}, context?: typeof DefaultContext) => <T>(input: string, init?: RequestInit) => Promise<IMResponse<T>>;
+}, context?: typeof DefaultContext) => <T>(input: string, init?: FetchRequestInit) => Promise<IMResponse<T>>;
 export declare const useIMFetch: UseIMFetch;
 export {};

package/lib/packages/Fetch/index.js

@@ -4,6 +4,7 @@ import { join } from '../../utils/path';
 import { Context as DefaultContext } from '../OAuth/Context';
 import { IMOAuthError } from '../OAuth/IMOAuthError';
 import { IMFecthError } from './IMFecthError';
+import { fetch } from 'expo/fetch';
 const fetchWrapper = async (token, input, init = {}) => {
     const response = await fetch(input, {
         credentials: 'omit',

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

@@ -1,4 +1,3 @@
-/// <reference types="react" />
 import { ErrorResult, SuccessResult } from '.';
 import { RenderTarget } from '../../_shared/renderTarget';
 import { Me } from './type';

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

@@ -1,4 +1,3 @@
-/// <reference types="react" />
 import { RenderTarget } from '../../_shared/renderTarget';
 import { Context as DefaultContext } from './Context';
 import { Me } from './type';

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

@@ -1,4 +1,3 @@
-/// <reference types="react" />
 import { RenderTarget } from '../../_shared/renderTarget';
 import { AuthSessionResult } from 'expo-auth-session';
 import { IMOAuthError } from './IMOAuthError';

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

@@ -3,4 +3,4 @@ export * from './useIMToken';
 export * from './useStartAuth';
 export * from './useAuthState';
 export * from './useAuthStateEffect';
-export * from './useAuthError';
+export * from './useAuthInitError';

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

@@ -3,4 +3,4 @@ export * from './useIMToken';
 export * from './useStartAuth';
 export * from './useAuthState';
 export * from './useAuthStateEffect';
-export * from './useAuthError';
+export * from './useAuthInitError';

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

@@ -0,0 +1,3 @@
+import { DependencyList } from 'react';
+import { IMOAuthError } from '../IMOAuthError';
+export declare const useAuthInitError: (callBack: (error?: IMOAuthError) => void, deps?: DependencyList) => void;

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

@@ -0,0 +1,24 @@
+import { useContext, useEffect, useRef } from 'react';
+import { Context as DefaultContext } from '../Context';
+import { IMOAuthError } from '../IMOAuthError';
+export const useAuthInitError = (callBack, deps) => {
+    const initRef = useRef(true);
+    const firstEffectRef = useRef(true);
+    const oauthContext = useContext(DefaultContext);
+    if (oauthContext == null) {
+        throw new IMOAuthError('useAuthInitError requires either a Context provide or an ancestor element with a IMOAuthProvider.');
+    }
+    if (initRef.current) {
+        initRef.current = false;
+        oauthContext.authErrorRenderTarget.addEventListener(callBack);
+    }
+    useEffect(() => {
+        if (firstEffectRef.current)
+            firstEffectRef.current = false;
+        else
+            oauthContext.authErrorRenderTarget.addEventListener(callBack);
+        return () => {
+            oauthContext.authErrorRenderTarget.removeEventListener(callBack);
+        };
+    }, deps);
+};

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

@@ -1,4 +1,3 @@
-/// <reference types="react" />
 import { Prompt } from 'expo-auth-session';
 import * as SecureStore from 'expo-secure-store';
 import { Context as DefaultContext } from './Context';

package/lib/packages/OAuth/index.js

@@ -10,7 +10,7 @@ import { IMOAuthError } from './IMOAuthError';
 WebBrowser.maybeCompleteAuthSession();
 const SUCCESS = 'success';
 const EXCEPTION = 'exception';
-const DEFAULT_STORAGE_KEY = '_example_IMAuthKey';
+const DEFAULT_STORE_KEY = '_example_IMAuthKey';
 const DEFAULT_REMAINING_TIME_TO_RUN_REFRESH = 360000;
 export const IMPrompt = {
     Login: Prompt.Login,
@@ -56,7 +56,7 @@ const useStoreConfig = (secureStore) => {
     const keychainAccessible = secureStore?.keychainAccessible;
     return useMemo(() => {
         return {
-            storeKey: storeKey ? storeKey : DEFAULT_STORAGE_KEY,
+            storeKey: storeKey ? storeKey : DEFAULT_STORE_KEY,
             keychainAccessible: keychainAccessible !== void 0
                 ? keychainAccessible
                 : SecureStore.WHEN_UNLOCKED,
@@ -70,7 +70,7 @@ const useRemainingTimeToRunRefresh = (remainingTimeToRunRefresh) => {
             : DEFAULT_REMAINING_TIME_TO_RUN_REFRESH;
     }, [remainingTimeToRunRefresh]);
 };
-const saveTokenStorage = async (storeConfig, baseUrl, accessToken, refreshToken, expirationDate) => {
+const saveTokenStore = async (storeConfig, baseUrl, accessToken, refreshToken, expirationDate) => {
     const item = {
         baseUrl,
         accessToken,
@@ -81,12 +81,12 @@ const saveTokenStorage = async (storeConfig, baseUrl, accessToken, refreshToken,
         keychainAccessible: storeConfig.keychainAccessible,
     });
 };
-const deleteTokenStorage = async (storeConfig) => {
+const deleteTokenStore = async (storeConfig) => {
     return await SecureStore.deleteItemAsync(storeConfig.storeKey, {
         keychainAccessible: storeConfig.keychainAccessible,
     });
 };
-const getTokenStorage = async (storeConfig) => {
+const getTokenStore = async (storeConfig) => {
     const state = await SecureStore.getItemAsync(storeConfig.storeKey, {
         keychainAccessible: storeConfig.keychainAccessible,
     });
@@ -176,7 +176,7 @@ const useRefresh = (storeConfig, refreshTokenRef, expirationDateRef, requestConf
                 }, discovery);
                 const { accessToken, refreshToken, expiresIn } = tokenResponse;
                 const expirationDate = expiresIn ? createExpirationDate(expiresIn) : 0;
-                await saveTokenStorage(storeConfig, baseUrl, accessToken, refreshToken, expirationDate);
+                await saveTokenStore(storeConfig, baseUrl, accessToken, refreshToken, expirationDate);
                 refreshTokenRef.current = refreshToken ? refreshToken : null;
                 expirationDateRef.current = expirationDate;
                 setToken(accessToken);
@@ -198,7 +198,7 @@ const useStartAuth = (storeConfig, remainingTimeToRunRefresh, refreshTokenRef, e
     useEffect(() => {
         (async () => {
             try {
-                const tokenState = await getTokenStorage(storeConfig);
+                const tokenState = await getTokenStore(storeConfig);
                 if (tokenState) {
                     const { baseUrl, accessToken, refreshToken, expirationDate } = tokenState;
                     const expired = checkExpirationDateOfToken(expirationDate ? expirationDate : 0, remainingTimeToRunRefresh);
@@ -262,7 +262,7 @@ const useStartAuth = (storeConfig, remainingTimeToRunRefresh, refreshTokenRef, e
             }, discovery);
             const { accessToken, refreshToken, expiresIn } = tokenResponse;
             const expirationDate = expiresIn ? createExpirationDate(expiresIn) : 0;
-            await saveTokenStorage(storeConfig, currentBaseUrl, accessToken, refreshToken, expirationDate);
+            await saveTokenStore(storeConfig, currentBaseUrl, accessToken, refreshToken, expirationDate);
             refreshTokenRef.current = refreshToken ? refreshToken : null;
             expirationDateRef.current = expirationDate;
             setToken(accessToken);
@@ -284,7 +284,7 @@ const useStartAuth = (storeConfig, remainingTimeToRunRefresh, refreshTokenRef, e
 };
 const useDestroy = (storeConfig, refreshTokenRef, expirationDateRef, setToken, setAuthState) => {
     return useCallback(async () => {
-        await deleteTokenStorage(storeConfig);
+        await deleteTokenStore(storeConfig);
         setToken(null);
         refreshTokenRef.current = null;
         expirationDateRef.current = null;

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

@@ -1,4 +1,3 @@
-/// <reference types="react" />
 import { StartSearchArg, StartSearchResult } from '.';
 export interface SearchContext {
     start: ({ target, type, paramString, }: StartSearchArg) => Promise<StartSearchResult<typeof type>>;

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

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

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

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

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

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

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

@@ -1,4 +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>>;
+    startSearch: ({ target, type, paramString, }: import("..").StartSearchArg) => Promise<import("..").StartSearchResult<typeof type>>;
 };

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

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

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

@@ -1,2 +1,3 @@
 import { PublicGroupRoleSearchResult, PublicGroupRoleSet } from '../types';
-export declare const usePublicGroupRoleSearch: (paramString: string) => (publicGroupSet: PublicGroupRoleSet, init?: RequestInit) => Promise<PublicGroupRoleSearchResult>;
+import { FetchRequestInit } from 'expo/fetch';
+export declare const usePublicGroupRoleSearch: (paramString: string) => (publicGroupSet: PublicGroupRoleSet, init?: FetchRequestInit) => Promise<PublicGroupRoleSearchResult>;

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

@@ -1,2 +1,3 @@
 import { PublicGroupSearcResult } from '../types';
-export declare const usePublicGroupSearch: (paramString: string) => (keyword: string, init?: RequestInit) => Promise<PublicGroupSearcResult>;
+import { FetchRequestInit } from 'expo/fetch';
+export declare const usePublicGroupSearch: (paramString: string) => (keyword: string, init?: FetchRequestInit) => Promise<PublicGroupSearcResult>;

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

@@ -1,2 +1,3 @@
 import { PublicGroupTopSearchResult } from '../types';
-export declare const usePublicGroupTopSearch: (paramString: string) => (init?: RequestInit) => Promise<PublicGroupTopSearchResult>;
+import { FetchRequestInit } from 'expo/fetch';
+export declare const usePublicGroupTopSearch: (paramString: string) => (init?: FetchRequestInit) => Promise<PublicGroupTopSearchResult>;

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

@@ -1,2 +1,3 @@
 import { PublicGroupSet, RoleSearchResult } from '../types';
-export declare const useRoleSearch: (paramString: string) => (publicGroupSet: PublicGroupSet, init?: RequestInit) => Promise<RoleSearchResult>;
+import { FetchRequestInit } from 'expo/fetch';
+export declare const useRoleSearch: (paramString: string) => (publicGroupSet: PublicGroupSet, init?: FetchRequestInit) => Promise<RoleSearchResult>;

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

@@ -1,2 +1,3 @@
 import { UserAdditionalInformationSearchResult } from '../types';
-export declare const useUserAdditionalInformationSearch: (paramString: string) => (userCd: string, init?: RequestInit) => Promise<UserAdditionalInformationSearchResult>;
+import { FetchRequestInit } from 'expo/fetch';
+export declare const useUserAdditionalInformationSearch: (paramString: string) => (userCd: string, init?: FetchRequestInit) => Promise<UserAdditionalInformationSearchResult>;

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

@@ -1,2 +1,3 @@
 import { UserSearchResult } from '../types';
-export declare const useUserSearch: (paramString: string) => (keyword: string, init?: RequestInit) => Promise<UserSearchResult>;
+import { FetchRequestInit } from 'expo/fetch';
+export declare const useUserSearch: (paramString: string) => (keyword: string, init?: FetchRequestInit) => Promise<UserSearchResult>;

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

@@ -1,4 +1,3 @@
-/// <reference types="react" />
 import { Context as DefaultContext } from './Context';
 import { DepartmentPostSearchRecord, DepartmentSearchRecord, PostSearchRecord, PublicGroupSearchRecord, RoleSearchRecord, UserSearchRecord } from './types';
 export type SearchTarget = 'jp.co.intra_mart.master.search.user' | 'jp.co.intra_mart.master.search.company' | 'jp.co.intra_mart.master.search.company_post' | 'jp.co.intra_mart.master.search.department' | 'jp.co.intra_mart.master.search.public_group' | 'jp.co.intra_mart.master.search.private_group' | 'jp.co.intra_mart.master.search.public_group_role' | 'jp.co.intra_mart.master.search.role' | 'jp.co.intra_mart.master.search.attached_department_post' | 'jp.co.intra_mart.master.search.attached_public_group_role' | undefined;

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

@@ -1,3 +1,4 @@
+import { FetchResponse } from 'expo/build/winter/fetch/FetchResponse';
 export interface SuccessResponse<T> {
     error: false;
     message: string;
@@ -10,7 +11,7 @@ export interface Success<T> {
 export interface Error {
     readonly type: 'error';
     readonly detail: unknown;
-    readonly response: Response;
+    readonly response: FetchResponse;
 }
 export interface Exception {
     readonly type: 'exception';

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

@@ -1,4 +1,3 @@
-/// <reference types="react" />
 import { ErrorResult, SuccessResult } from '.';
 import { RenderTarget } from '../../_shared/renderTarget';
 import setCookie from 'set-cookie-parser';

package/lib/packages/Session/hooks/useSession.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="set-cookie-parser" />
 import { Context as DefaultContext } from '../Context';
 export declare const useSession: (Context?: typeof DefaultContext) => {
     getSession: () => {

package/lib/packages/Session/hooks/useSessionState.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="set-cookie-parser" />
 import { Context as DefaultContext } from '../Context';
 export declare const useSessionState: (Context?: typeof DefaultContext) => {
     cookies: import("set-cookie-parser").Cookie[] | null;

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

@@ -1,4 +1,3 @@
-/// <reference types="react" />
 import { Context as DefaultContext } from './Context';
 export interface SessionResponse {
     error: boolean;

package/lib/packages/Smartlime/NotSearchPropError.d.ts

@@ -1,3 +1,2 @@
-/// <reference types="react" />
 import { SelectSearchProps } from '../Search';
 export declare const NotSearchPropError: ({ error }: SelectSearchProps) => import("react").JSX.Element;

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

@@ -1,4 +1,3 @@
-/// <reference types="react" />
 import { IMMe } from '../Me';
 import { IMOAuth } from '../OAuth';
 import { IMSession } from '../Session';

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

@@ -1,4 +1,3 @@
-/// <reference types="react" />
 import { FetchModuleState, Moudles } from '.';
 import { RenderTarget } from '../../_shared/renderTarget';
 export interface TenantContext {

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

@@ -1,4 +1,3 @@
-/// <reference types="react" />
 import { Context as DefaultContext } from './Context';
 import { ModuleIds } from './modulesType';
 interface IMTenantProps {

package/lib/packages/WebView/hooks/useHackSearchUI.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="react" />
 import WebView, { WebViewMessageEvent } from 'react-native-webview';
 type ErrorCallBack = (error: unknown) => void;
 export declare const useHackSearchUI: (errorCallBack?: ErrorCallBack) => {

package/lib/utils/mergeRef.d.ts

@@ -1,2 +1 @@
-/// <reference types="react" />
-export declare const mergeRef: <T>(...refs: (string | import("react").MutableRefObject<T> | ((instance: T | null) => void) | import("react").MutableRefObject<T | null> | ((instance: T | null) => void) | import("react").RefObject<T> | null)[]) => (instance: T | null) => void;
+export declare const mergeRef: <T>(...refs: Array<React.MutableRefObject<T> | React.ForwardedRef<T> | React.LegacyRef<T> | React.ForwardedRef<T>>) => React.RefCallback<T>;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@intra-mart/smartlime",
   "description": "expoで使用できるintra mart accelplatform SDK",
-  "version": "2.0.0-dev.20241125",
+  "version": "2.0.0-rc.20241226",
   "keywords": [
     "intra-mart",
     "AccelPlatform",
@@ -42,46 +42,42 @@
     "type": "tsc --noEmit"
   },
   "peerDependencies": {
-    "expo": "^51.0.31",
-    "react": "18.2.0"
+    "expo": "^52.0.20",
+    "react": "18.3.1"
   },
   "dependencies": {
     "@react-native-async-storage/async-storage": "1.23.1",
-    "expo-auth-session": "~5.5.2",
-    "expo-crypto": "~13.0.2",
+    "expo-auth-session": "~6.0.1",
+    "expo-crypto": "~14.0.1",
     "expo-random": "~14.0.1",
-    "expo-secure-store": "~13.0.2",
-    "react-native-webview": "13.8.6",
-    "set-cookie-parser": "^2.7.0"
+    "expo-secure-store": "~14.0.0",
+    "react-native-webview": "13.12.5",
+    "set-cookie-parser": "^2.7.1"
   },
   "devDependencies": {
-    "@babel/core": "^7.25.2",
-    "@babel/preset-env": "^7.25.4",
-    "@types/jest": "^29.5.12",
+    "@babel/core": "^7.26.0",
+    "@babel/preset-env": "^7.26.0",
+    "@types/jest": "^29.5.14",
     "@types/react": "^18.2.79",
     "@types/react-test-renderer": "18.3.0",
     "@types/set-cookie-parser": "^2.4.10",
-    "@typescript-eslint/eslint-plugin": "^8.3.0",
-    "@typescript-eslint/parser": "^8.3.0",
-    "eslint": "^8.57.0",
+    "@typescript-eslint/eslint-plugin": "^8.18.0",
+    "@typescript-eslint/parser": "^8.18.0",
+    "eslint": "^9.16.0",
     "eslint-config-prettier": "^9.1.0",
-    "eslint-plugin-react": "^7.35.0",
-    "expo": "^51.0.31",
+    "eslint-plugin-react": "^7.37.2",
+    "expo": "~52.0.20",
     "jest": "^29.7.0",
-    "jest-expo": "^51.0.4",
-    "prettier": "^3.3.3",
-    "react": "18.2.0",
-    "react-dom": "18.2.0",
-    "react-native": "0.74.5",
+    "jest-expo": "^52.0.2",
+    "prettier": "^3.4.2",
+    "react": "18.3.1",
+    "react-dom": "18.3.1",
+    "react-native": "0.76.5",
     "react-test-renderer": "18.2.0",
     "ts-jest": "^29.2.5",
-    "typescript": "^5.3.3"
+    "typescript": "^5.7.2"
   },
-  "resolutions": {
-    "@types/react": "^18.2.79"
-  },
-  "packageManager": "yarn@1.22.19",
   "engines": {
-    "node": ">= 16.9.0"
+    "node": ">= 22.0.0"
   }
 }

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

@@ -1,2 +0,0 @@
-import { IMOAuthError } from '../IMOAuthError';
-export declare const useAuthError: (callBack: (error?: IMOAuthError) => void) => void;

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

@@ -1,15 +0,0 @@
-import { useContext, useEffect } from 'react';
-import { Context as DefaultContext } from '../Context';
-import { IMOAuthError } from '../IMOAuthError';
-export const useAuthError = (callBack) => {
-    const oauthContext = useContext(DefaultContext);
-    if (oauthContext == null) {
-        throw new IMOAuthError('useAuthError requires either a Context provide or an ancestor element with a IMOAuthProvider.');
-    }
-    useEffect(() => {
-        oauthContext.authErrorRenderTarget.addEventListener(callBack);
-        return () => {
-            oauthContext.authErrorRenderTarget.removeEventListener(callBack);
-        };
-    }, [callBack]);
-};