@ramesesinc/platform-core 0.1.0

package/dist/core/UIDependHandler.d.ts

@@ -0,0 +1,6 @@
+type useDependHandlerProps = {
+    onRefresh?: () => void;
+    name?: string;
+};
+declare const useDependHandler: (props: useDependHandlerProps) => {};
+export default useDependHandler;

package/dist/core/UIDependHandler.js

@@ -0,0 +1,31 @@
+import { useEffect } from "react";
+import { usePageContext } from "./PageContext";
+const useDependHandler = (props) => {
+    const { name, onRefresh } = props !== null && props !== void 0 ? props : {};
+    const pageContext = usePageContext();
+    const dependHandler = (val) => {
+        if (onRefresh != null) {
+            onRefresh();
+        }
+    };
+    useEffect(() => {
+        if (name == null || name.trim() === "" || onRefresh == null)
+            return;
+        const unsubscribeList = [];
+        const names = name.split(",");
+        names.forEach((key) => {
+            const unsubscribe = pageContext === null || pageContext === void 0 ? void 0 : pageContext.dependsTo(key, dependHandler);
+            unsubscribeList.push(unsubscribe);
+        });
+        return () => {
+            unsubscribeList.forEach((unsubscribe) => {
+                try {
+                    unsubscribe();
+                }
+                catch (err) { }
+            });
+        };
+    }, [name]);
+    return {};
+};
+export default useDependHandler;

package/dist/core/auth/index.d.ts

@@ -0,0 +1,18 @@
+export declare function createSessionToken(props: {
+    SESSIONID: string;
+    USERID: string;
+    USERNAME: string;
+    FULLNAME: string;
+}): Promise<string>;
+export declare function fetchSessionId(): Promise<string | null>;
+export declare function verifySessionToken(token: string): Promise<any>;
+export declare function signIn(username: string, password: string, tenant: string): Promise<{
+    SESSION: Record<string, any>;
+    OPTIONS: Record<string, any>;
+} | null>;
+export declare function signOut(tenant: string): Promise<string | null>;
+export declare function getUser(tenant: string): Promise<{
+    [x: string]: any;
+} | null>;
+export declare function changePassword(tenant: string, username: string, oldpassword: string, newpassword: string): Promise<void>;
+export declare function resetPassword(tenant: string, userid: string, password: string): Promise<void>;

package/dist/core/auth/index.js

@@ -0,0 +1,187 @@
+// Server-side authentication utilities (no "use server" needed)
+import { generateHmacMD5 } from "@ramesesinc/lib";
+import { authAPI } from "@ramesesinc/lib/auth-api";
+import { getError, localAPI } from "@ramesesinc/lib/local-api";
+export async function createSessionToken(props) {
+    try {
+        const data = await authAPI.createToken(props);
+        const { token } = data !== null && data !== void 0 ? data : {};
+        await authAPI.saveToken({ token });
+        return token;
+    }
+    catch (err) {
+        console.error(err);
+        const e = getError(err);
+        throw new Error(e.message);
+    }
+}
+export async function fetchSessionId() {
+    try {
+        const token = await authAPI.fetchToken();
+        return token;
+    }
+    catch (err) {
+        console.error(err);
+        const e = getError(err);
+        throw new Error(e.message);
+    }
+}
+export async function verifySessionToken(token) {
+    const resp = await authAPI.verifyToken({ token });
+    const { data } = resp !== null && resp !== void 0 ? resp : {};
+    return data;
+}
+async function clearSessionId() {
+    await authAPI.deleteToken();
+}
+export async function signIn(username, password, tenant) {
+    var _a, _b;
+    try {
+        const hashedPassword = generateHmacMD5(username.toLowerCase(), password);
+        const body = { username, password: hashedPassword };
+        const config = { tenant, module: "admin" };
+        const svc = localAPI.useService(config.tenant, config.module);
+        let data = (_a = (await svc.invoke("loginService", "login", body))) !== null && _a !== void 0 ? _a : {};
+        if (data.response != null)
+            data = data.response;
+        const { env } = data;
+        if (env == null)
+            return null;
+        const { USERID, SESSIONID } = env;
+        if (!USERID || !SESSIONID)
+            return null;
+        const platform = await localAPI.getPlatform();
+        const newConfig = Object.assign(Object.assign({}, config), { platform: platform === null || platform === void 0 ? void 0 : platform.name });
+        const auth_post_enabled = (String(process.env.AUTH_POST_ENABLED) === 'false' ? false : true);
+        if (auth_post_enabled) {
+            // let path = `/users/${USERID}`;
+            // const user = await server.getMongoData(path, newConfig);
+            // if (user && Object.keys(user).length > 0) {
+            //   mergeUserInfo(env, user);
+            //   path = `/users/update/${USERID}`;
+            //   await server.postMongoData(path, user, newConfig);
+            // } else {
+            //   const newUser = {};
+            //   mergeUserInfo(env, newUser);
+            //   path = `/users/create`;
+            //   await server.postMongoData(path, newUser, newConfig);
+            // }
+        }
+        const finalResult = { SESSION: {}, OPTIONS: {} };
+        if (SESSIONID) {
+            const timeIn = env.TIMEIN;
+            delete env.TIMEIN;
+            const sess = { _id: SESSIONID, env: env };
+            sess.timein = timeIn;
+            sess.timeout = null;
+            if (auth_post_enabled) {
+                const path = `/sessions/create`;
+                // await server.postMongoData(path, sess, newConfig);
+            }
+            const authOptions = (_b = env.AUTH_OPTIONS) !== null && _b !== void 0 ? _b : {};
+            delete authOptions.userid;
+            delete authOptions.username;
+            finalResult.SESSION = env;
+            finalResult.OPTIONS = authOptions;
+        }
+        return finalResult;
+    }
+    catch (err) {
+        console.error(err);
+        const e = getError(err);
+        throw new Error(e.message);
+    }
+}
+export async function signOut(tenant) {
+    var _a;
+    try {
+        let SESSIONID = "";
+        const sessionID = await fetchSessionId();
+        if (sessionID && sessionID.split(".").length > 1) {
+            const tokenData = await verifySessionToken(sessionID);
+            SESSIONID = (_a = tokenData === null || tokenData === void 0 ? void 0 : tokenData.SESSIONID) !== null && _a !== void 0 ? _a : "";
+        }
+        if (SESSIONID) {
+            const body = { tenant, SESSIONID };
+            const config = { tenant, module: "admin" };
+            const svc = localAPI.useService(config.tenant, config.module);
+            await svc.invoke("logoutService", "logout", body);
+            const auth_post_enabled = (String(process.env.AUTH_POST_ENABLED) === 'false' ? false : true);
+            if (auth_post_enabled) {
+                const sess = { timeout: new Date().toISOString().slice(0, 19) };
+                const path = `/sessions/update/${encodeURIComponent(SESSIONID)}`;
+                // await server.postMongoData(path, sess, config);
+            }
+        }
+        await clearSessionId();
+        return await fetchSessionId();
+    }
+    catch (err) {
+        console.error(err);
+        const e = getError(err);
+        throw new Error(e.message);
+    }
+}
+export async function getUser(tenant) {
+    var _a;
+    try {
+        const token = await fetchSessionId();
+        if (!token)
+            return null;
+        let USERNAME = "";
+        if (token.split(".").length > 1) {
+            const tokenData = await verifySessionToken(token);
+            USERNAME = (_a = tokenData === null || tokenData === void 0 ? void 0 : tokenData.USERNAME) !== null && _a !== void 0 ? _a : "";
+        }
+        if (!USERNAME)
+            return null;
+        const body = { username: USERNAME };
+        const config = { tenant, module: "admin" };
+        const svc = localAPI.useService(config.tenant, config.module);
+        const user = await svc.invoke("passwordService", "getUser", body);
+        return user;
+    }
+    catch (err) {
+        console.error(err);
+        const e = getError(err);
+        throw new Error(e.message);
+    }
+}
+export async function changePassword(tenant, username, oldpassword, newpassword) {
+    try {
+        const config = { tenant, module: "admin" };
+        const body = { username, oldpassword, newpassword };
+        const svc = localAPI.useService(config.tenant, config.module);
+        await svc.invoke("passwordService", "change", body);
+    }
+    catch (err) {
+        console.error(err);
+        const e = getError(err);
+        throw new Error(e.message);
+    }
+}
+export async function resetPassword(tenant, userid, password) {
+    try {
+        const config = { tenant, module: "admin" };
+        const body = { userid, password };
+        const svc = localAPI.useService(config.tenant, config.module);
+        await svc.invoke("passwordService", "reset", body);
+    }
+    catch (err) {
+        console.error(err);
+        const e = getError(err);
+        throw new Error(e.message);
+    }
+}
+function mergeUserInfo(source, target) {
+    const env = source !== null && source !== void 0 ? source : {};
+    const { USERID } = env;
+    if (!USERID)
+        return;
+    target._id = env.USERID;
+    target.username = env.USER;
+    target.fullname = env.FULLNAME;
+    target.name = env.NAME;
+    target.title = env.JOBTITLE;
+    target.txncode = env.TXNCODE;
+}

package/dist/core/auth/session.d.ts

@@ -0,0 +1,4 @@
+import * as server from "@ramesesinc/lib/server-actions";
+export declare function verifyToken(token: string): Promise<server.TokenData | null>;
+export declare function getUser(userid: string, tenant: string): Promise<Record<string, any> | null>;
+export declare function buildSessionHeader(): Promise<Record<string, any>>;

package/dist/core/auth/session.js

@@ -0,0 +1,45 @@
+import * as server from "@ramesesinc/lib/server-actions";
+import * as auth from "./index";
+export async function verifyToken(token) {
+    try {
+        const data = await auth.verifySessionToken(token);
+        if (data == null)
+            return data;
+        const auth_post_enabled = (String(process.env.AUTH_POST_ENABLED) === 'false' ? false : true);
+        if (auth_post_enabled)
+            return data;
+        const { USERID, USERNAME, FULLNAME } = data !== null && data !== void 0 ? data : {};
+        return Object.assign(Object.assign({}, data), { INFO: { _id: USERID, username: USERNAME, fullname: FULLNAME } });
+    }
+    catch (err) {
+        console.error(err);
+        const e = server.getError(err);
+        throw new Error(e.message);
+    }
+}
+export async function getUser(userid, tenant) {
+    try {
+        const path = `/users/${encodeURIComponent(userid)}`;
+        return await server.getMongoData(path, { tenant, module: 'admin' });
+    }
+    catch (err) {
+        console.error(err);
+        const e = server.getError(err);
+        throw new Error(e.message);
+    }
+}
+export async function buildSessionHeader() {
+    const key = 'x-session-token';
+    const headers = { [key]: '' };
+    try {
+        const token = await auth.fetchSessionId();
+        if (token == null || token.trim() === "") {
+            return headers;
+        }
+        headers[key] = token;
+        return headers;
+    }
+    catch (err) {
+        return headers;
+    }
+}

package/dist/core/index.d.ts

@@ -0,0 +1,3 @@
+export type EventHandler = {
+    [key: string]: (...args: any[]) => any;
+};

package/dist/core/index.js

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

package/dist/core/page-helper.d.ts

@@ -0,0 +1,27 @@
+import { TokenData } from "@ramesesinc/lib/server-actions";
+import { GetServerSidePropsContext, GetServerSidePropsResult } from "next";
+import { ReactNode } from "react";
+export type PageSession = TokenData;
+export declare const PageServerHook: {
+    getServerSideProps: <P extends Record<string, any> = Record<string, any>>(getProps?: (context: GetServerSidePropsContext, session?: PageSession | null) => Promise<GetServerSidePropsResult<P>>) => (context: GetServerSidePropsContext) => Promise<{
+        props: (P & {
+            session: TokenData | null;
+        }) | {
+            session: TokenData | null;
+            then<TResult1 = P, TResult2 = never>(onfulfilled?: ((value: P) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined): Promise<TResult1 | TResult2>;
+            catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined): Promise<P | TResult>;
+            finally(onfinally?: (() => void) | null | undefined): Promise<P>;
+            [Symbol.toStringTag]: string;
+        };
+    } | {
+        props: {
+            session: TokenData | null;
+        };
+    }>;
+};
+type PageHookProps = {
+    children?: ReactNode;
+    session?: PageSession;
+};
+export declare function PageHook({ children, session }: PageHookProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/core/page-helper.js

@@ -0,0 +1,47 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { verifySessionToken } from "@ramesesinc/lib/server-actions";
+import { useRouter } from "next/router";
+import HorizontalLayout from "../layouts/HorizontalLayout";
+import PageLayout from "../layouts/PageLayout";
+import Header from "../lib/components/Header";
+import { useApp } from "./AppContext";
+export const PageServerHook = {
+    getServerSideProps: (getProps) => {
+        return async (context) => {
+            var _a;
+            let session = null;
+            const token = context.req.cookies["session"];
+            if (token != null && token.trim() !== "") {
+                const akey = ((_a = process.env.API_KEY) !== null && _a !== void 0 ? _a : "").trim();
+                const tokenData = await verifySessionToken(token, akey);
+                if (tokenData)
+                    session = tokenData;
+            }
+            if (getProps != null) {
+                const result = await getProps(context, session);
+                if ("props" in result) {
+                    return { props: Object.assign(Object.assign({}, result.props), { session }) };
+                }
+            }
+            return { props: { session } };
+        };
+    },
+};
+export function PageHook({ children, session }) {
+    const app = useApp();
+    const router = useRouter();
+    const handleActivity = (item) => {
+        if ((app === null || app === void 0 ? void 0 : app.tenant) != null && (app === null || app === void 0 ? void 0 : app.module) != null && (item === null || item === void 0 ? void 0 : item.id) != null) {
+            const newPath = `/${app.tenant}/${app.module}/${item.id}`;
+            void router.push(newPath);
+        }
+    };
+    let leftView = null;
+    let headerView = null;
+    const hasSession = (session === null || session === void 0 ? void 0 : session.SESSIONID) != null;
+    if (hasSession) {
+        // leftView = <ActivityBar value={app?.activityid || ''} handler={handleActivity} />;
+        headerView = _jsx(Header, {});
+    }
+    return (_jsx(HorizontalLayout, { className: "h-screen bg-white", left: leftView, children: _jsx(PageLayout, { header: headerView, children: children }) }));
+}

package/dist/hooks/useUrlParams.d.ts

@@ -0,0 +1,11 @@
+export declare const useUrlParams: () => {
+    getUrl: () => string;
+    addPath: (value: string) => void;
+    removeLastPath: () => void;
+    getLastHash: () => string | null;
+    updateHash: (value: string, index?: number) => void;
+    addQuery: (params: Record<string, string>) => void;
+    getQuery: () => Record<string, string>;
+    setQuery: (params: Record<string, string>) => void;
+    setAnchorPath: (path: string) => void;
+};

package/dist/hooks/useUrlParams.js

@@ -0,0 +1,164 @@
+// src/hooks/useUrlParams.ts
+"use client";
+import { useCallback, useEffect, useState } from "react";
+export const useUrlParams = () => {
+    const [currentUrl, setCurrentUrl] = useState("");
+    useEffect(() => {
+        if (typeof window === "undefined")
+            return;
+        const syncUrl = () => {
+            setCurrentUrl(window.location.href);
+        };
+        window.addEventListener("popstate", syncUrl);
+        return () => {
+            window.removeEventListener("popstate", syncUrl);
+        };
+    }, []);
+    /** Returns the full current URL **/
+    const getUrl = useCallback(() => {
+        return currentUrl;
+    }, [currentUrl]);
+    /**
+     * Appends raw value to the end of the URL
+     * Example: addPath("#test")
+     */
+    const addPath = useCallback((value) => {
+        if (typeof window === "undefined")
+            return;
+        const newUrl = `${window.location.href}${value}`;
+        window.history.pushState({}, "", newUrl);
+        setCurrentUrl(newUrl);
+    }, []);
+    /**
+     * Removes the LAST #segment from the URL
+     * Example:
+     * http://x/main#one#two -> http://x/main#one
+     */
+    const removeLastPath = useCallback(() => {
+        if (typeof window === "undefined")
+            return;
+        const url = window.location.href;
+        const lastHashIndex = url.lastIndexOf("#");
+        if (lastHashIndex === -1)
+            return;
+        const newUrl = url.substring(0, lastHashIndex);
+        window.history.pushState({}, "", newUrl);
+        setCurrentUrl(newUrl);
+    }, []);
+    /**
+     * Gets the LAST #segment
+     * Example:
+     * http://x/main#one#two -> "#two"
+     */
+    const getLastHash = useCallback(() => {
+        const url = currentUrl;
+        const lastHashIndex = url.lastIndexOf("#");
+        if (lastHashIndex === -1)
+            return null;
+        return url.substring(lastHashIndex);
+    }, [currentUrl]);
+    const updateHash = useCallback((value, index) => {
+        if (typeof window === "undefined")
+            return;
+        const url = window.location.href;
+        const parts = url.split("#");
+        // Normalize value (remove leading #)
+        const cleanValue = value.startsWith("#") ? value.substring(1) : value;
+        // No hash exists → append
+        if (parts.length === 1) {
+            const newUrl = `${url}#${cleanValue}`;
+            window.history.pushState({}, "", newUrl);
+            setCurrentUrl(newUrl);
+            return;
+        }
+        // DEFAULT: update last hash only
+        if (index === undefined) {
+            parts[parts.length - 1] = cleanValue;
+            const newUrl = parts.join("#");
+            window.history.pushState({}, "", newUrl);
+            setCurrentUrl(newUrl);
+            return;
+        }
+        // Index-based update with truncation
+        const targetIndex = index + 1; // parts[0] is base URL
+        if (targetIndex < 1 || targetIndex >= parts.length)
+            return;
+        // Replace target
+        parts[targetIndex] = cleanValue;
+        // Remove everything after target
+        const newParts = parts.slice(0, targetIndex + 1);
+        const newUrl = newParts.join("#");
+        window.history.pushState({}, "", newUrl);
+        setCurrentUrl(newUrl);
+    }, []);
+    const addQuery = useCallback((params) => {
+        if (typeof window === "undefined")
+            return;
+        const url = window.location.href;
+        const hashIndex = url.indexOf("#");
+        const base = hashIndex === -1 ? url : url.substring(0, hashIndex);
+        const hashStack = hashIndex === -1 ? "" : url.substring(hashIndex);
+        const queryString = Object.entries(params)
+            .map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(v)}`)
+            .join("&");
+        const newUrl = `${base}${hashStack}?${queryString}`;
+        window.history.pushState({}, "", newUrl);
+        setCurrentUrl(newUrl);
+    }, []);
+    const getQuery = useCallback(() => {
+        if (typeof window === "undefined")
+            return {};
+        const url = window.location.href;
+        const params = {};
+        // Split off hash
+        const [base, hash] = url.split("#");
+        // Use query from hash first, if exists
+        const queryFromHash = (hash === null || hash === void 0 ? void 0 : hash.includes("?")) ? hash.split("?")[1] : "";
+        // If no query in hash, fallback to normal URL query
+        const queryString = queryFromHash || base.split("?")[1] || "";
+        if (!queryString)
+            return {};
+        queryString.split("&").forEach((pair) => {
+            const [key, value] = pair.split("=");
+            if (key)
+                params[decodeURIComponent(key)] = decodeURIComponent(value || "");
+        });
+        return params;
+    }, []);
+    const setQuery = useCallback((params) => {
+        if (typeof window === "undefined")
+            return;
+        const url = window.location.href;
+        const hashIndex = url.indexOf("#");
+        const base = hashIndex === -1 ? url.split("?")[0] : url.substring(0, hashIndex);
+        const hash = hashIndex === -1 ? "" : url.substring(hashIndex).split("?")[0];
+        const queryString = Object.entries(params)
+            .map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(v)}`)
+            .join("&");
+        const newUrl = `${base}${hash}?${queryString}`;
+        window.history.pushState({}, "", newUrl);
+        setCurrentUrl(newUrl);
+    }, []);
+    const setAnchorPath = (path) => {
+        const newPath = path.startsWith("#") ? path : `#${path}`;
+        let oldPath = window.location.href;
+        const idx = oldPath.indexOf("#");
+        if (idx > 0) {
+            oldPath = oldPath.substring(0, idx);
+        }
+        const newUrl = oldPath + newPath;
+        window.history.pushState({}, "", newUrl);
+        setCurrentUrl(newUrl);
+    };
+    return {
+        getUrl,
+        addPath,
+        removeLastPath,
+        getLastHash,
+        updateHash,
+        addQuery,
+        getQuery,
+        setQuery,
+        setAnchorPath,
+    };
+};

package/dist/index.d.ts

@@ -0,0 +1,65 @@
+export { AppProvider, useApp } from "./core/AppContext";
+export { AuthProvider, useAuth } from "./core/AuthContext";
+export { PageProvider, usePageContext } from "./core/PageContext";
+export { getComponent } from "./core/ComponentCache";
+export { getHtml } from "./core/HtmlCache";
+export { getPage } from "./core/PageCache";
+export { usePageRegistry } from "./core/PageRegistry";
+export { StepHandler } from "./core/StepHandler";
+export { PageHook, PageServerHook } from "./core/page-helper";
+export { PageViewProvider, usePageViewContext } from "./core/PageViewContext";
+export { default as DynamicIcon } from "./core/DynamicIcon";
+export { default as Page } from "./core/Page";
+export { default as RowContext, RowProvider, useRowContext } from "./core/RowContext";
+export { default as UIDependHandler } from "./core/UIDependHandler";
+export type { PageSession } from "./core/page-helper";
+export type { DataApiHandler, PageContextValue, PageHandle, PageProviderRef } from "./core/PageContext";
+export type { PageRegistry } from "./core/PageRegistry";
+export type { PageOptions, PageSelectionHandler, PageViewContextValue, PageViewHandle } from "./core/PageViewContext";
+export type { StepActionHandler } from "./core/StepHandler";
+export { useUrlParams } from "./hooks/useUrlParams";
+export { default as BasicTemplate } from "./templates/BasicTemplate";
+export { default as DataListTemplate } from "./templates/DataListTemplate";
+export { default as ExplorerTemplate } from "./templates/ExplorerTemplate";
+export { default as TxnFormTemplate } from "./templates/TxnFormTemplate";
+export { default as WizardTemplate } from "./templates/WizardTemplate";
+export { default as BorderLayout } from "./layouts/BorderLayout";
+export { default as CardLayout } from "./layouts/CardLayout";
+export { default as CenterLayout } from "./layouts/CenterLayout";
+export { default as GridLayout } from "./layouts/GridLayout";
+export { default as HorizontalLayout } from "./layouts/HorizontalLayout";
+export { default as HPanel } from "./layouts/HPanel";
+export { default as MainLayout } from "./layouts/MainLayout";
+export { default as PageLayout } from "./layouts/PageLayout";
+export { default as VPanel } from "./layouts/VPanel";
+export { default as XLayout } from "./layouts/XLayout";
+export { default as YLayout } from "./layouts/YLayout";
+export { default as DateField } from "./components/input/DateField";
+export { default as DayPicker } from "./components/input/DayPicker";
+export { default as JsonCode } from "./components/input/JsonCode";
+export { default as MonthPicker } from "./components/input/MonthPicker";
+export { default as Select } from "./components/input/Select";
+export { default as Text } from "./components/input/Text";
+export { default as StringDecision } from "./components/input/StringDecision";
+export { default as TabMenu } from "./components/list/TabMenu";
+export { default as TreeMenu } from "./components/list/TreeMenu";
+export { default as Label } from "./components/output/Label";
+export { default as DataList } from "./components/table/DataList";
+export { default as ComponentView } from "./components/view/ComponentView";
+export { default as FilterView } from "./components/view/FilterView";
+export { default as HtmlView } from "./components/view/HtmlView";
+export { default as IFrameView } from "./components/view/IFrameView";
+export { default as RootView } from "./components/view/RootView";
+export { default as WizardView } from "./components/view/WizardView";
+export { default as AlertMessage } from "./components/action/AlertMessage";
+export { default as Edit } from "./components/action/Edit";
+export { default as SaveData } from "./components/action/SaveData";
+export { default as UpdateContext } from "./components/action/UpdateContext";
+export { default as ViewBackPage } from "./components/action/ViewBackPage";
+export { default as ViewPage } from "./components/action/ViewPage";
+export { default as PageView } from "./components/view/PageView";
+export { default as IconMenu } from "./components/list/IconMenu";
+export { default as TxnTaskList } from "./components/list/TxnTaskList";
+export { handlePlatformRoute } from "./lib/PlatformRoute";
+export { ResourceLoader } from "./lib/utils/ResourceLoader";
+export { default as WebPlatform } from "./lib/WebPlatform";