@intra-mart/smartlime 0.0.1-beta

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

@@ -0,0 +1,208 @@
+export interface SuccessResponse<T> {
+    error: false;
+    message: string;
+    data: T;
+}
+export interface Success<T> {
+    readonly type: 'success';
+    readonly response: SuccessResponse<T>;
+}
+export interface Error {
+    readonly type: 'error';
+    readonly detail: unknown;
+    readonly response: Response;
+}
+export interface Exception {
+    readonly type: 'exception';
+    readonly detail: unknown;
+}
+export type SearchResult<T> = Exception | Error | Success<T>;
+export interface UserData {
+    user_cd: string;
+    user_name: string;
+    user_search_name: string;
+    email_address1?: string | null;
+    delete_flag: number;
+    sort1: number;
+    sort2: string;
+    sort3: string;
+}
+export interface UserSearchRecord {
+    type: 'imm_user';
+    keyFields: ['user_cd'];
+    displayName: string;
+    deleteFlag: false;
+    data: UserData;
+}
+export type UserSearchResult = SearchResult<UserSearchRecord[]>;
+export type UserSearchResponse = SuccessResponse<UserSearchRecord[]>;
+export interface DepartmentSet {
+    company_cd: string;
+    department_set_cd: string;
+}
+export interface DepartmentData {
+    company_cd: string;
+    department_set_cd: string;
+    department_cd: string;
+    department_name: string;
+    delete_flag: number;
+}
+export interface DepartmentInclusion {
+    full_path_name: string[];
+}
+export interface DepartmentSearchRecord {
+    identifier: string;
+    inclusion: DepartmentInclusion;
+    displayName: string;
+    deleteFlag: false;
+    keyFields: string[];
+    type: string;
+    data: DepartmentData;
+}
+export type DepartmentSearcResult = SearchResult<DepartmentSearchRecord[]>;
+export type DepartmentSearchResponse = SuccessResponse<DepartmentSearchRecord[]>;
+export interface DepartmentTopData {
+    company_cd: string;
+    department_set_cd: string;
+    department_cd: string;
+    department_name: string;
+    deleted_data: number;
+}
+export interface DepartmentTopInclusion {
+    full_path_name: string[];
+}
+export interface DepartmentTopSearchRecord {
+    type: string;
+    keyFields: string[];
+    deleteFlag: false;
+    displayName: string;
+    data: DepartmentTopData;
+    inclusion: DepartmentTopInclusion;
+    isParent: false;
+}
+export type DepartmentTopSearcResult = SearchResult<DepartmentTopSearchRecord[]>;
+export type DepartmentTopSearchResponse = SuccessResponse<DepartmentTopSearchRecord[]>;
+export interface PostData {
+    company_cd: string;
+    department_set_cd: string;
+    post_cd: string;
+    post_name: string;
+    delete_flag: number;
+}
+export interface PostSearchRecord {
+    type: string;
+    keyFields: string[];
+    deleteFlag: false;
+    displayName: string;
+    data: PostData;
+}
+export type PostSearcResult = SearchResult<PostSearchRecord[]>;
+export type PostSearchResponse = SuccessResponse<PostSearchRecord[]>;
+export interface PublicGroupData {
+    public_group_set_cd: string;
+    public_group_cd: string;
+    public_group_name: string;
+    delete_flag: number;
+}
+export interface PublicGroupInclusion {
+    full_path_name: string[];
+}
+export interface PublicGroupSearchRecord {
+    identifier: string;
+    inclusion: PublicGroupInclusion;
+    displayName: string;
+    deleteFlag: false;
+    keyFields: string[];
+    type: string;
+    data: PublicGroupData;
+}
+export type PublicGroupSearcResult = SearchResult<PublicGroupSearchRecord[]>;
+export type PublicGroupSearcResponse = SuccessResponse<PublicGroupSearchRecord[]>;
+export interface PublicGroupTopData {
+    public_group_set_cd: string;
+    public_group_cd: string;
+    public_group_name: string;
+    delete_flag: number;
+}
+export interface PublicGroupTopSearchRecord {
+    type: string;
+    keyFields: string[];
+    deleteFlag: false;
+    displayName: string;
+    data: PublicGroupTopData;
+    isParent: false;
+}
+export type PublicGroupTopSearchResult = SearchResult<PublicGroupTopSearchRecord[]>;
+export type PublicGroupTopSearchResponse = SuccessResponse<PublicGroupTopSearchRecord[]>;
+export interface PublicGroupSet {
+    public_group_set_cd: string;
+}
+export interface RoleData {
+    public_group_set_cd: string;
+    role_cd: string;
+    role_name: string;
+    delete_flag: number;
+}
+export interface RoleSearchRecord {
+    type: string;
+    keyFields: string[];
+    deleteFlag: false;
+    displayName: string;
+    data: RoleData;
+}
+export type RoleSearchResult = SearchResult<RoleSearchRecord[]>;
+export type RoleSearchResponse = SuccessResponse<RoleSearchRecord[]>;
+export interface UserAdditionalInformationSearchRecord {
+    mainDept: string[];
+    othDept: string[];
+}
+export type UserAdditionalInformationSearchResult = SearchResult<UserAdditionalInformationSearchRecord>;
+export type UserAdditionalInformationSearchResponse = SuccessResponse<UserAdditionalInformationSearchRecord>;
+export interface Department {
+    department_cd: string;
+}
+export interface DepartmentPostDepartmentSet {
+    company_cd: string;
+    department_set_cd: string;
+    department: Department;
+}
+export interface DepartmentPostData {
+    company_cd: string;
+    department_set_cd: string;
+    post_cd: string;
+    post_name: string;
+    delete_flag: number;
+    department_cd: string;
+}
+export interface DepartmentPostSearchRecord {
+    type: string;
+    keyFields: string[];
+    deleteFlag: false;
+    displayName: string;
+    data: DepartmentPostData;
+}
+export type DepartmentPostSearchResult = SearchResult<DepartmentPostSearchRecord[]>;
+export type DepartmentPostSearchResponse = SuccessResponse<DepartmentPostSearchRecord[]>;
+export interface PublicGroup {
+    public_group_cd: string;
+}
+export interface PublicGroupRoleSet {
+    public_group_set_cd: string;
+    public_group: PublicGroup;
+}
+export interface PublicGroupRoleData {
+    public_group_set_cd: string;
+    role_cd: string;
+    role_name: string;
+    delete_flag: number;
+    public_group_cd: string;
+}
+export interface PublicGroupRoleRecord {
+    type: string;
+    keyFields: string[];
+    deleteFlag: false;
+    displayName: string;
+    data: PublicGroupRoleData;
+}
+export type PublicGroupRoleSearchResult = SearchResult<PublicGroupRoleRecord[]>;
+export type PublicGroupRoleSearchResponse = SuccessResponse<PublicGroupRoleRecord[]>;

package/lib/packages/Search/types.js

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

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

@@ -0,0 +1,16 @@
+/// <reference types="react" />
+import { ErrorResult, SuccessResult } from '.';
+import { RenderTarget } from '../../_shared/renderTarget';
+import setCookie from 'set-cookie-parser';
+export interface SessionContext {
+    getSession: () => {
+        cookies: setCookie.Cookie[] | null;
+    };
+    getSessionAsync: () => Promise<{
+        cookies: setCookie.Cookie[] | null;
+    }>;
+    request: () => Promise<SuccessResult | ErrorResult>;
+    destroy: () => void;
+    sessionStateRenderTarget: RenderTarget;
+}
+export declare const Context: import("react").Context<SessionContext | null>;

package/lib/packages/Session/Context.js

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

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

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

package/lib/packages/Session/IMSessionError.js

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

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

@@ -0,0 +1,2 @@
+export * from './useSession';
+export * from './useSessionState';

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

@@ -0,0 +1,2 @@
+export * from './useSession';
+export * from './useSessionState';

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

@@ -0,0 +1,12 @@
+import { Context as DefaultContext } from '../Context';
+export declare const useSession: (Context?: typeof DefaultContext) => {
+    getSession: () => {
+        cookies: import("set-cookie-parser").Cookie[] | null;
+    };
+    getSessionAsync: () => Promise<{
+        cookies: import("set-cookie-parser").Cookie[] | null;
+    }>;
+    request: () => Promise<import("..").SuccessResult | import("..").ErrorResult>;
+    update: () => Promise<import("..").SuccessResult | import("..").ErrorResult>;
+    destroy: () => void;
+};

package/lib/packages/Session/hooks/useSession.js

@@ -0,0 +1,11 @@
+import { useContext } from 'react';
+import { Context as DefaultContext } from '../Context';
+import { IMSessionError } from '../IMSessionError';
+export const useSession = (Context) => {
+    const meContext = useContext(Context || DefaultContext);
+    if (meContext == null) {
+        throw new IMSessionError('useSession requires either a Context provide or an ancestor element with a IMSessionProvider.');
+    }
+    const { getSession, getSessionAsync, request, destroy } = meContext;
+    return { getSession, getSessionAsync, request, update: request, destroy };
+};

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

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

package/lib/packages/Session/hooks/useSessionState.js

@@ -0,0 +1,24 @@
+import { useContext, useEffect, useReducer, useRef } from 'react';
+import { Context as DefaultContext } from '../Context';
+import { IMSessionError } from '../IMSessionError';
+export const useSessionState = (Context) => {
+    const initRef = useRef(true);
+    const [, forceRender] = useReducer((s) => s + 1, 0);
+    const meContext = useContext(Context || DefaultContext);
+    if (meContext == null) {
+        throw new IMSessionError('useSessionState requires either a Context provide or an ancestor element with a IMSessionProvider.');
+    }
+    const { cookies } = meContext.getSession();
+    if (initRef.current) {
+        initRef.current = false;
+        meContext.sessionStateRenderTarget.addEventListener(forceRender);
+    }
+    useEffect(() => {
+        return () => {
+            meContext.sessionStateRenderTarget.removeEventListener(forceRender);
+        };
+    }, []);
+    return {
+        cookies: cookies,
+    };
+};

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

@@ -0,0 +1,16 @@
+/// <reference types="react" />
+import { Context as DefaultContext } from './Context';
+export interface SessionResponse {
+    error: boolean;
+}
+export interface SuccessResult {
+    status: 'success';
+}
+export interface ErrorResult {
+    status: 'error';
+}
+export interface IMSessionProps {
+    children: JSX.Element;
+    sessionContext?: typeof DefaultContext;
+}
+export declare const IMSession: ({ children, sessionContext }: IMSessionProps) => JSX.Element;

package/lib/packages/Session/index.js

@@ -0,0 +1,164 @@
+import { useCallback, useEffect, useRef } from 'react';
+import { useRenderTarget } from '../../_shared/renderTarget';
+import { useIMFetch } from '../Fetch';
+import { Context as DefaultContext } from './Context';
+import { IMSessionError } from './IMSessionError';
+import setCookie from 'set-cookie-parser';
+import { makeCookie } from './utils';
+const useSessionStateRef = (renderTarget) => {
+    const cookieRef = useRef(null);
+    const setter = useCallback((cookie, silent) => {
+        if (cookieRef.current === cookie)
+            return;
+        cookieRef.current = cookie;
+        if (!silent)
+            renderTarget.dispatch();
+    }, []);
+    const getter = useCallback(() => {
+        const cookie = cookieRef.current;
+        if (cookie) {
+            const splitCookieHeaders = setCookie.splitCookiesString(cookie);
+            const cookies = setCookie.parse(splitCookieHeaders);
+            return {
+                cookies: cookies,
+            };
+        }
+        return {
+            cookies: null,
+        };
+    }, []);
+    return [
+        {
+            cookieRef,
+        },
+        setter,
+        getter,
+    ];
+};
+const useLogout = () => {
+    const imFetch = useIMFetch({ noValidate: true });
+    return useCallback((cookie) => {
+        imFetch('/logout', {
+            headers: {
+                Cookie: cookie,
+            },
+            method: 'GET',
+        });
+    }, []);
+};
+const makeEncodeParams = (clientTypeId = 'pc') => {
+    return `${`clientTypeId=${encodeURIComponent(clientTypeId)}`}`;
+};
+const useRequest = (setter, getter) => {
+    const imFetch = useIMFetch();
+    const logout = useLogout();
+    const request = useCallback(async (clientTypeId) => {
+        try {
+            const currentCookies = getter()?.cookies;
+            const params = makeEncodeParams(clientTypeId);
+            const response = await imFetch(`api/bearer/smacolow/session?${params}`, {
+                headers: {
+                    Accept: 'application/json',
+                    'X-Intramart-Session': 'keep', // https://document.intra-mart.jp/library/iap/public/im_web_api_maker/im_web_api_maker_programming_guide/texts/how_to_use_api/index.html#session-management
+                },
+                method: 'GET',
+            });
+            if (response.status === 200) {
+                const json = await response.json();
+                if (!json.error) {
+                    const cookie = response.headers.get('Set-Cookie');
+                    if (cookie) {
+                        setter(cookie);
+                        if (currentCookies)
+                            logout(makeCookie(currentCookies));
+                        return { status: 'success' };
+                    }
+                    throw new IMSessionError('could not find sessionid from Set-Cookie in response header.');
+                }
+            }
+            throw new IMSessionError('failed to get session.');
+        }
+        catch {
+            return { status: 'error' };
+        }
+    }, [imFetch]);
+    return request;
+};
+const useDestroy = (renderTarget, setter, getter) => {
+    const logout = useLogout();
+    return useCallback(() => {
+        const { cookies } = getter();
+        if (cookies) {
+            logout(makeCookie(cookies));
+        }
+        setter(null);
+        renderTarget.dispatch();
+    }, []);
+};
+const useGetSessionAsync = (request, destroy, getter) => {
+    const imFetch = useIMFetch({ noValidate: true });
+    const logout = useLogout();
+    const reRequest = async (count) => {
+        const { status } = await request();
+        if (status === 'success') {
+            return status;
+        }
+        else {
+            // retry up to 3 runs
+            if (count < 3)
+                return await reRequest(count + 1);
+            return status;
+        }
+    };
+    return useCallback(async () => {
+        const { cookies } = getter();
+        if (cookies) {
+            const response = await imFetch('api/smacolow/session', {
+                headers: {
+                    Cookie: makeCookie(cookies),
+                },
+                method: 'GET',
+            });
+            if (response.status === 200) {
+                return getter();
+            }
+            else {
+                logout(makeCookie(cookies));
+            }
+        }
+        const status = await reRequest(0);
+        if (status === 'success')
+            return getter();
+        destroy();
+        throw new IMSessionError('failed to get session.');
+    }, [request]);
+};
+const unmountEffect = (getter) => {
+    const logout = useLogout();
+    const { cookies } = getter();
+    useEffect(() => {
+        return () => {
+            // you can't catch APP CLOSE, so you need to deal with it individually.
+            if (cookies)
+                logout(makeCookie(cookies));
+        };
+    }, []);
+};
+export const IMSession = ({ children, sessionContext }) => {
+    const Context = sessionContext || DefaultContext;
+    const contextRef = useRef();
+    const sessionStateRenderTarget = useRenderTarget();
+    const [, setSession, getSession] = useSessionStateRef(sessionStateRenderTarget);
+    const request = useRequest(setSession, getSession);
+    const destroy = useDestroy(sessionStateRenderTarget, setSession, getSession);
+    const getSessionAsync = useGetSessionAsync(request, destroy, getSession);
+    unmountEffect(getSession);
+    contextRef.current = {
+        getSession,
+        getSessionAsync,
+        request,
+        destroy,
+        sessionStateRenderTarget,
+    };
+    return (<Context.Provider value={contextRef.current}>{children}</Context.Provider>);
+};

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

@@ -0,0 +1,5 @@
+/**
+ * value is optional.
+ * use of sp mode is not recommended.
+ */
+export type ClientTypeId = 'pc' | 'sp';

package/lib/packages/Session/type.js

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

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

@@ -0,0 +1,2 @@
+import setCookie from 'set-cookie-parser';
+export declare const makeCookie: (cookies: setCookie.Cookie[]) => string;

package/lib/packages/Session/utils.js

@@ -0,0 +1,6 @@
+export const makeCookie = (cookies) => {
+    return cookies.reduce((acc, cookie, index) => {
+        const isLast = index === cookies.length - 1;
+        return `${acc}${cookie.name}=${cookie.value}${isLast ? '' : '; '}`;
+    }, '');
+};

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

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

package/lib/packages/Smartlime/NotSearchPropError.js

@@ -0,0 +1,13 @@
+import { useEffect, useRef } from 'react';
+import { View } from 'react-native';
+import { IMSearchError } from '../Search/IMSearchError';
+export const NotSearchPropError = ({ error }) => {
+    const initRef = useRef(false);
+    useEffect(() => {
+        if (!initRef.current) {
+            initRef.current = true;
+            error(new IMSearchError('SearchComponent is not passed to Smartlime prop.'));
+        }
+    }, []);
+    return <View />;
+};

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

@@ -0,0 +1,19 @@
+/// <reference types="react" />
+import { IMMe } from '../Me';
+import { IMOAuth } from '../OAuth';
+import { IMSession } from '../Session';
+import { IMSearch } from '../Search';
+interface SmartlimeProps {
+    children: JSX.Element;
+    baseUrl: string;
+    /**
+     * prop is currently not working.
+     */
+    tenantId?: string;
+    imoauth: Omit<React.ComponentProps<typeof IMOAuth>, 'children'>;
+    imme?: Omit<React.ComponentProps<typeof IMMe>, 'children'>;
+    imsession?: Omit<React.ComponentProps<typeof IMSession>, 'children'>;
+    imseach?: Omit<React.ComponentProps<typeof IMSearch>, 'children'>;
+}
+export declare const Smartlime: ({ children, baseUrl, tenantId, imoauth, imme, imsession, imseach, }: SmartlimeProps) => JSX.Element;
+export {};

package/lib/packages/Smartlime/index.js

@@ -0,0 +1,23 @@
+import { IMMe } from '../Me';
+import { IMOAuth } from '../OAuth';
+import { IMSession } from '../Session';
+import { IMSearch } from '../Search';
+import { IMTenant } from '../Tenant';
+import { NotSearchPropError } from './NotSearchPropError';
+export const Smartlime = ({ children, baseUrl, tenantId, imoauth, imme, imsession, imseach, }) => {
+    const imtenantProps = { baseUrl, tenantId };
+    const imseachProps = imseach != null
+        ? imseach
+        : {
+            SearchComponent: NotSearchPropError,
+        };
+    return (<IMTenant {...imtenantProps}>
+      <IMOAuth {...imoauth}>
+        <IMSession {...imsession}>
+          <IMMe {...imme}>
+            <IMSearch {...imseachProps}>{children}</IMSearch>
+          </IMMe>
+        </IMSession>
+      </IMOAuth>
+    </IMTenant>);
+};

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

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+export interface TenantContext {
+    getBaseUrl: () => string;
+    getTenantId: () => string | undefined;
+}
+export declare const Context: import("react").Context<TenantContext | null>;

package/lib/packages/Tenant/Context.js

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

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

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

package/lib/packages/Tenant/IMTenantError.js

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

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

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

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

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

package/lib/packages/Tenant/hooks/useIMBaseUrl.d.ts

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

package/lib/packages/Tenant/hooks/useIMBaseUrl.js

@@ -0,0 +1,10 @@
+import { useContext } from 'react';
+import { Context as DefaultContext } from '../Context';
+import { IMTenantError } from '../IMTenantError';
+export const useIMBaseUrl = (Context) => {
+    const tenantContext = useContext(Context || DefaultContext);
+    if (tenantContext == null) {
+        throw new IMTenantError('useIMBaseUrl requires either a Context provide or an ancestor element with a IMTenantProvider.');
+    }
+    return tenantContext.getBaseUrl();
+};

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

@@ -0,0 +1,10 @@
+/// <reference types="react" />
+import { Context as DefaultContext } from './Context';
+interface IMTenantProps {
+    children: JSX.Element;
+    baseUrl: string;
+    tenantId?: string;
+    tenantContext?: typeof DefaultContext;
+}
+export declare const IMTenant: ({ children, baseUrl, tenantId, tenantContext, }: IMTenantProps) => JSX.Element;
+export {};

package/lib/packages/Tenant/index.js

@@ -0,0 +1,19 @@
+import { useCallback, useRef } from 'react';
+import { Context as DefaultContext } from './Context';
+const useGetBaseUrl = (baseUrl) => {
+    return useCallback(() => baseUrl, [baseUrl]);
+};
+const useGetTenantId = (tenantId) => {
+    return useCallback(() => tenantId, [tenantId]);
+};
+export const IMTenant = ({ children, baseUrl, tenantId, tenantContext, }) => {
+    const Context = tenantContext || DefaultContext;
+    const contextRef = useRef();
+    const getBaseUrl = useGetBaseUrl(baseUrl);
+    const getTenantId = useGetTenantId(tenantId);
+    contextRef.current = {
+        getBaseUrl,
+        getTenantId,
+    };
+    return (<Context.Provider value={contextRef.current}>{children}</Context.Provider>);
+};

package/lib/packages/WebView/IMWebViewError.d.ts

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