@intra-mart/smartlime 2.0.0-dev.20241210 → 2.0.0-dev.20251017

package/lib/_shared/renderTarget.d.ts

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

package/lib/_shared/renderTarget.js

@@ -12,11 +12,11 @@ export const createRenderTarget = () => {
             }
         }
     };
-    const dispatch = () => {
+    const dispatch = (args) => {
         for (let i = 0, l = listenerList.length; i < l; i++) {
             const listener = listenerList[i];
             if (listener)
-                listener();
+                listener(args);
         }
     };
     return {

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/index.d.ts

@@ -1,3 +1,4 @@
+import { JSX } from 'react';
 import { RenderTarget } from '../../_shared/renderTarget';
 import { Context as DefaultContext } from './Context';
 import { Me } from './type';
@@ -13,10 +14,10 @@ export interface ErrorResult {
     couse?: unknown;
 }
 export declare const useRequestIMMe: (setter: ReturnType<typeof useMeStateRef>[1]) => () => Promise<SuccessResult | ErrorResult>;
-declare const useMeStateRef: (renderTarget: RenderTarget) => readonly [import("react").MutableRefObject<Me | null>, (state: Me, silent?: boolean) => void, () => Me | null];
+declare const useMeStateRef: (renderTarget: RenderTarget) => readonly [import("react").RefObject<Me | null>, (state: Me, silent?: boolean) => void, () => Me | null];
 export interface IMMeProps {
     children: JSX.Element;
     meContext?: typeof DefaultContext;
 }
-export declare const IMMe: ({ children, meContext }: IMMeProps) => import("react").JSX.Element;
+export declare const IMMe: ({ children, meContext }: IMMeProps) => JSX.Element;
 export {};

package/lib/packages/Me/index.js

@@ -42,7 +42,7 @@ const useMeStateRef = (renderTarget) => {
 };
 export const IMMe = ({ children, meContext }) => {
     const Context = meContext || DefaultContext;
-    const contextRef = useRef();
+    const contextRef = useRef(null);
     const meStateRenderTarget = useRenderTarget();
     const [, setMe, getMe] = useMeStateRef(meStateRenderTarget);
     const request = useRequestIMMe(setMe);

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

@@ -54,6 +54,7 @@ export interface Me {
     calendarId: string;
     firstDayOfWeek: 1 | 2 | 3 | 4 | 5 | 6 | 7;
     locale: string;
+    roleIds: string[];
     tenantId: string;
     timeZone: string;
     userCd: string;

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

@@ -1,5 +1,16 @@
-import { AuthState, StartAuthResult } from '.';
 import { RenderTarget } from '../../_shared/renderTarget';
+import { AuthSessionResult } from 'expo-auth-session';
+import { IMOAuthError } from './IMOAuthError';
+export type AuthState = 'initializing' | 'unauthorized' | 'authorized';
+export type StartAuthResult = {
+    readonly type: 'cancel' | 'dismiss' | 'opened' | 'locked' | 'error';
+    readonly detail: AuthSessionResult;
+} | {
+    readonly type: 'success';
+} | {
+    readonly type: 'exception';
+    readonly exceptionDetail: unknown;
+};
 export interface OAuthContext {
     getAuthState: () => AuthState;
     getToken: () => string | null;
@@ -9,5 +20,6 @@ export interface OAuthContext {
     startAuth: () => Promise<StartAuthResult>;
     tokenRenderTarget: RenderTarget;
     authStateRenderTarget: RenderTarget;
+    authErrorRenderTarget: RenderTarget<IMOAuthError>;
 }
 export declare const Context: import("react").Context<OAuthContext | null>;

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

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

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

@@ -3,3 +3,4 @@ export * from './useIMToken';
 export * from './useStartAuth';
 export * from './useAuthState';
 export * from './useAuthStateEffect';
+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/hooks/useAuthState.d.ts

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

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

@@ -1,4 +1,4 @@
-import { AuthState } from '..';
+import { AuthState } from '../Context';
 /**
  * sugar syntax that sets the return value of "useAuthState" to the deps of "useEffect"
  * this may be deprecated in the future

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

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

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

@@ -1,21 +1,13 @@
-import { AuthSessionResult, Prompt } from 'expo-auth-session';
+import { Prompt } from 'expo-auth-session';
+import * as SecureStore from 'expo-secure-store';
+import { JSX } from 'react';
 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;
     readonly None: Prompt.None;
@@ -28,12 +20,16 @@ interface RequestConfig {
     state?: string;
     prompt?: Prompt.Login | Prompt.None;
 }
+interface SecureStoreConfig {
+    storeKey?: string;
+    keychainAccessible?: SecureStore.KeychainAccessibilityConstant;
+}
 interface IMOAuthProps {
     children: JSX.Element;
     requestConfig: RequestConfig;
     remainingTimeToRunRefresh?: number;
-    storageKey?: string;
+    secureStore?: SecureStoreConfig;
     oauthContext?: typeof DefaultContext;
 }
-export declare const IMOAuth: ({ children, requestConfig, remainingTimeToRunRefresh, storageKey, oauthContext, }: IMOAuthProps) => import("react").JSX.Element;
+export declare const IMOAuth: ({ children, requestConfig, remainingTimeToRunRefresh, secureStore, oauthContext, }: IMOAuthProps) => JSX.Element;
 export {};