@ramesesinc/platform-core 0.1.0

package/dist/core/AuthContext.js

@@ -0,0 +1,80 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// lib/context/AuthContext.tsx
+import { createContext, useContext, useEffect, useState } from "react";
+import * as auth from "../core/auth";
+import { useApp } from "./AppContext";
+export const useAuth = () => {
+    const ctx = useContext(AuthContext);
+    if (!ctx)
+        throw new Error("useAuth must be used within AuthProvider");
+    return ctx;
+};
+const AuthContext = createContext(undefined);
+export const AuthProvider = ({ children }) => {
+    const app = useApp();
+    const [sessionId, setSessionId] = useState(null);
+    const [activityId, setActivityId] = useState(null);
+    const getSessionId = async () => {
+        if (sessionId)
+            return sessionId;
+        // Only run on client side to prevent SSR issues
+        if (typeof window === "undefined")
+            return null;
+        try {
+            const sess_id = await auth.fetchSessionId();
+            // console.log({ sess_id});
+            setSessionId(sess_id);
+            return sess_id;
+        }
+        catch (err) {
+            console.error("getSessionId failed:", err);
+            setSessionId(null);
+            return null;
+        }
+    };
+    useEffect(() => {
+        // Only run on client side to prevent SSR issues
+        if (typeof window !== "undefined") {
+            getSessionId();
+        }
+    }, []);
+    const signIn = async (username, password) => {
+        var _a;
+        const data = await auth.signIn(username, password, app.tenant);
+        const { SESSIONID, USERID, USER: USERNAME, FULLNAME } = (_a = data === null || data === void 0 ? void 0 : data.SESSION) !== null && _a !== void 0 ? _a : {};
+        if (!SESSIONID)
+            throw new Error("failed to get SESSIONID upon signIn");
+        if (!USERID)
+            throw new Error("failed to get USERID upon signIn");
+        if (!USERNAME)
+            throw new Error("failed to get USERNAME upon signIn");
+        if (!FULLNAME)
+            throw new Error("failed to get FULLNAME upon signIn");
+        const token = await auth.createSessionToken({ SESSIONID, USERID, USERNAME, FULLNAME });
+        if (!token)
+            throw new Error("failed to create session token");
+        setSessionId(token);
+        return token;
+    };
+    const signOut = async () => {
+        try {
+            const session_id = await getSessionId();
+            if (session_id) {
+                await auth.signOut(app.tenant);
+            }
+            setSessionId(null);
+        }
+        catch (error) {
+            console.error("signOut failed:", error);
+            setSessionId(null);
+        }
+    };
+    const value_params = {
+        activityId,
+        sessionId,
+        getSessionId,
+        signIn,
+        signOut,
+    };
+    return _jsx(AuthContext.Provider, { value: value_params, children: children });
+};

package/dist/core/ComponentCache.d.ts

@@ -0,0 +1,15 @@
+import React from "react";
+interface CacheFallback {
+    getTenant: string | null;
+    getModule: string | null;
+}
+export declare const getComponent: (name: string, fallback: CacheFallback) => Promise<{
+    template: import("react/jsx-runtime").JSX.Element;
+    pageInfo: null;
+    info?: undefined;
+} | {
+    template: React.DetailedReactHTMLElement<React.HTMLAttributes<HTMLElement>, HTMLElement>;
+    info: any;
+    pageInfo?: undefined;
+}>;
+export {};

package/dist/core/ComponentCache.js

@@ -0,0 +1,25 @@
+"use client";
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { localAPI } from "@ramesesinc/lib/local-api";
+import React from "react";
+import { DynamicTemplate } from "./DynamicTemplate";
+// Simple in-memory cache
+const cache = {};
+export const getComponent = async (name, fallback) => {
+    if (!cache[name]) {
+        const { getTenant: tenant, getModule: module } = fallback;
+        const info = await localAPI.useMgmt(tenant, module).get("components", name);
+        if (!info) {
+            return { template: _jsxs("div", { className: "text-red-500 p-2 border border-red-500", children: ["Component \"", name, "\" not found."] }), pageInfo: null };
+        }
+        const { template, attr } = info !== null && info !== void 0 ? info : { template: null, attr: {} };
+        delete info.template;
+        delete info.attr;
+        const tmpl = _jsx(DynamicTemplate, { template: template, attr: attr });
+        // Store in cache
+        cache[name] = { template: tmpl, info };
+    }
+    const compCache = cache[name];
+    const newTemplate = React.cloneElement(compCache.template);
+    return { template: newTemplate, info: compCache.info };
+};

package/dist/core/DataContext.d.ts

@@ -0,0 +1,20 @@
+import { BindingModel } from "@ramesesinc/client";
+type DependCallback = (value?: any) => void;
+export type DataBindingValue = {
+    getBinding: () => BindingModel;
+    getData: () => Record<string, any>;
+    set: (name: string | null, value: any) => void;
+    get: (name: string | null) => any;
+    dependsTo: (name: string | null, callback: DependCallback) => () => void;
+    notifyDepends: (name?: string | null) => void;
+};
+export declare const useCreateContextValue: (source: Record<string, any>) => DataBindingValue;
+declare const DataBindingContext: import("react").Context<DataBindingValue | null>;
+export declare const useDataContext: () => DataBindingValue | null;
+type DataBindingProviderProps = {
+    data?: Record<string, any>;
+    handler?: DataBindingValue;
+    children: React.ReactNode;
+};
+export declare const DataBindingProvider: ({ data, handler, children }: DataBindingProviderProps) => import("react/jsx-runtime").JSX.Element;
+export default DataBindingContext;

package/dist/core/DataContext.js

@@ -0,0 +1,41 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useBinding } from "@ramesesinc/client";
+import { createContext, useContext, useMemo } from "react";
+const createDefaultValue = () => ({
+    getBinding: () => ({}),
+    getData: () => ({}),
+    set: () => { },
+    get: () => undefined,
+    dependsTo: () => () => { },
+    notifyDepends: () => { },
+});
+export const useCreateContextValue = (source) => {
+    const binding = useBinding(source !== null && source !== void 0 ? source : {});
+    return useMemo(() => ({
+        getBinding: () => binding,
+        getData: () => binding.getData(),
+        set: (name, value) => {
+            binding.set(name !== null && name !== void 0 ? name : "", value);
+        },
+        get: (name) => {
+            return binding.get(name !== null && name !== void 0 ? name : "");
+        },
+        dependsTo: (name, callback) => {
+            return binding.dependsTo(name, callback);
+        },
+        notifyDepends: (name) => {
+            binding.notifyDepends(name);
+        },
+    }), [binding, source]);
+};
+const DataBindingContext = createContext(null);
+export const useDataContext = () => {
+    const context = useContext(DataBindingContext);
+    return context;
+};
+export const DataBindingProvider = ({ data, handler, children }) => {
+    const dataWrapper = useCreateContextValue(data !== null && data !== void 0 ? data : {});
+    const value = handler !== null && handler !== void 0 ? handler : dataWrapper;
+    return _jsx(DataBindingContext.Provider, { value: value, children: children });
+};
+export default DataBindingContext;

package/dist/core/DynamicComponent.d.ts

@@ -0,0 +1,12 @@
+import React from "react";
+export interface DynamicComponentConfig {
+    component: string;
+    attr?: Record<string, any>;
+}
+interface DynamicComponentProps {
+    config: DynamicComponentConfig;
+    fallback?: React.ReactNode;
+    onError?: (error: Error) => void;
+}
+export declare const DynamicComponent: React.FC<DynamicComponentProps>;
+export {};

package/dist/core/DynamicComponent.js

@@ -0,0 +1,30 @@
+"use client";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { ResourceLoader } from "../lib/utils/ResourceLoader";
+import React from "react";
+export const DynamicComponent = ({ config, fallback = _jsx("div", { style: { color: "red" }, children: "Component not found" }), onError, }) => {
+    const { component, attr = {} } = config !== null && config !== void 0 ? config : {};
+    const _a = attr !== null && attr !== void 0 ? attr : {}, { key } = _a, restAttr = __rest(_a, ["key"]);
+    let Comp;
+    try {
+        Comp = ResourceLoader.getComponent(component);
+    }
+    catch (err) {
+        if (onError)
+            onError(err);
+        console.error(err);
+        return _jsx(_Fragment, { children: fallback });
+    }
+    return (_jsx(React.Suspense, { fallback: _jsx("div", { children: "Loading component..." }), children: _jsx(Comp, Object.assign({}, restAttr), key) }));
+};

package/dist/core/DynamicIcon.d.ts

@@ -0,0 +1,6 @@
+type DynamicIconProps = {
+    icon?: React.ReactNode | string;
+    size?: number;
+};
+declare const DynamicIcon: ({ icon, size }: DynamicIconProps) => import("react/jsx-runtime").JSX.Element;
+export default DynamicIcon;

package/dist/core/DynamicIcon.js

@@ -0,0 +1,48 @@
+import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { CircleDot } from "lucide-react";
+import { useEffect, useState } from "react";
+const isBase64 = (str) => str.startsWith("data:image/");
+const isSvg = (str) => str.trimStart().startsWith("<svg");
+const isUrl = (str) => str.startsWith("http://") || str.startsWith("https://") || str.startsWith("/");
+const DynamicIcon = ({ icon, size = 20 }) => {
+    const [resolved, setResolved] = useState(_jsx(CircleDot, { size: size }));
+    useEffect(() => {
+        if (!icon) {
+            setResolved(_jsx(CircleDot, { size: size }));
+            return;
+        }
+        // Already a React node
+        if (typeof icon !== "string") {
+            setResolved(icon);
+            return;
+        }
+        // Base64 image
+        if (isBase64(icon)) {
+            setResolved(_jsx("img", { src: icon, alt: "", className: "object-contain", style: { width: size, height: size } }));
+            return;
+        }
+        // Inline SVG string
+        if (isSvg(icon)) {
+            setResolved(_jsx("div", { style: { width: size, height: size }, className: "flex items-center justify-center", dangerouslySetInnerHTML: { __html: icon } }));
+            return;
+        }
+        // Image URL or path
+        if (isUrl(icon)) {
+            setResolved(_jsx("img", { src: icon, alt: "", className: "object-contain", style: { width: size, height: size } }));
+            return;
+        }
+        // Lucide icon name — dynamic import
+        import("lucide-react").then((lucide) => {
+            const LucideIcon = lucide[icon];
+            if (LucideIcon) {
+                setResolved(_jsx(LucideIcon, { size: size }));
+            }
+            else {
+                // Nothing matched — fallback
+                setResolved(_jsx(CircleDot, { size: size }));
+            }
+        });
+    }, [icon, size]);
+    return _jsx(_Fragment, { children: resolved });
+};
+export default DynamicIcon;

package/dist/core/DynamicTemplate.d.ts

@@ -0,0 +1,4 @@
+export declare const DynamicTemplate: ({ template, attr }: {
+    template: string;
+    attr?: Record<string, any>;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/core/DynamicTemplate.js

@@ -0,0 +1,17 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+import React from "react";
+import { ResourceLoader } from "../lib/utils/ResourceLoader";
+import { SectionProvider } from "../lib/utils/SectionProvider";
+export const DynamicTemplate = ({ template, attr }) => {
+    let Tmpl;
+    try {
+        Tmpl = ResourceLoader.getTemplate(template);
+    }
+    catch (err) {
+        console.error(err);
+        return _jsx("div", { children: "Template not found" });
+    }
+    const sectionProvider = SectionProvider(attr);
+    return (_jsx(React.Suspense, { fallback: _jsx("div", { children: "Loading template..." }), children: _jsx(Tmpl, Object.assign({}, attr, { sectionProvider: sectionProvider })) }));
+};

package/dist/core/ErrorMessage.d.ts

@@ -0,0 +1,5 @@
+type ErrorMessageProps = {
+    error?: string | null;
+};
+declare const ErrorMessage: ({ error }: ErrorMessageProps) => import("react/jsx-runtime").JSX.Element | null;
+export default ErrorMessage;

package/dist/core/ErrorMessage.js

@@ -0,0 +1,7 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+const ErrorMessage = ({ error }) => {
+    if (!error)
+        return null;
+    return (_jsx("div", { className: "bg-red-100 border border-red-400 text-red-700 px-4 py-3 rounded-md mb-2 flex items-center justify-between", children: _jsx("span", { className: "ml-2 text-sm", children: error }) }));
+};
+export default ErrorMessage;

package/dist/core/EventHandler.d.ts

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

package/dist/core/EventHandler.js

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

package/dist/core/HtmlCache.d.ts

@@ -0,0 +1,6 @@
+interface CacheFallback {
+    getTenant: string | null;
+    getModule: string | null;
+}
+export declare const getHtml: (name: string, fallback: CacheFallback) => Promise<any>;
+export {};

package/dist/core/HtmlCache.js

@@ -0,0 +1,17 @@
+"use client";
+import { localAPI } from "@ramesesinc/lib/local-api";
+// Simple in-memory cache
+const cache = {};
+export const getHtml = async (name, fallback) => {
+    if (!cache[name]) {
+        const { getTenant: tenant, getModule: module } = fallback;
+        const info = await localAPI.useMgmt(tenant, module).get("html_templates", name);
+        if (!info) {
+            throw new Error(`Component "${name}" not found.`);
+        }
+        const { htmlCode } = info !== null && info !== void 0 ? info : "no html code";
+        // Store in cache
+        cache[name] = htmlCode;
+    }
+    return cache[name];
+};

package/dist/core/Page.d.ts

@@ -0,0 +1,6 @@
+type PageProps = {
+    url?: string | null;
+    fallback?: React.ReactNode;
+};
+declare const Page: (props: PageProps) => import("react/jsx-runtime").JSX.Element;
+export default Page;

package/dist/core/Page.js

@@ -0,0 +1,141 @@
+import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+// 1. accepts template and definition
+// 2. init = (params: Record<string, any>) => { // params from url
+//    if definition has data call localAPI
+// }
+import { forwardRef, memo, useCallback, useEffect, useImperativeHandle, useLayoutEffect, useMemo, useRef, useState } from "react";
+import { replaceValues } from "../lib/utils/BeanUtils";
+import { getUrlPageParams, parseHashUrl } from "../lib/utils/PageUtils";
+import { useApp } from "./AppContext";
+import { PageProvider } from "./PageContext";
+import { usePageViewContext } from "./PageViewContext";
+const Page = (props) => {
+    const { url: finalUrl, fallback = _jsx("div", { children: "Loading page..." }) } = props !== null && props !== void 0 ? props : {};
+    const [uuid] = useState(() => Math.random().toString(36).slice(2));
+    const [value, setValue] = useState(null);
+    const [cache, setCache] = useState({});
+    const [template, setTemplate] = useState(null);
+    const slotRef = useRef(null); // stable — never changes
+    const pageContext = useRef({});
+    const mountedRef = useRef(true);
+    const { getPageCache } = useApp();
+    const pageView = usePageViewContext();
+    const originalData = useMemo(() => {
+        const result = {
+            mainPath: "",
+            selectedPath: "",
+        };
+        if (finalUrl != null && finalUrl !== "") {
+            const [mainPath, ...subPaths] = finalUrl.split("#");
+            const [selectedPath] = subPaths !== null && subPaths !== void 0 ? subPaths : [];
+            result.mainPath = mainPath;
+            result.selectedPath = selectedPath;
+        }
+        setValue(finalUrl !== null && finalUrl !== void 0 ? finalUrl : null);
+        return result;
+    }, [finalUrl]);
+    // useLayoutEffect(() => {
+    //   setValue(url ?? null);
+    // }, [url]);
+    useLayoutEffect(() => {
+        const loadPageCache = async () => {
+            var _a;
+            // console.log("Page value changed", uuid, value, originalData);
+            const url = value;
+            const findPageCache = async (page) => {
+                const pageCache = await getPageCache(page);
+                const { template, pageInfo, hasSelectionHandling = false } = pageCache !== null && pageCache !== void 0 ? pageCache : {};
+                return { template, pageInfo, hasSelectionHandling };
+            };
+            if (url) {
+                const infoCheck = {};
+                // Given: main#tasklist
+                // First test the main path
+                const segments = url.split("#")[0].split("?")[0].split("/");
+                infoCheck.page = (_a = segments.at(-1)) !== null && _a !== void 0 ? _a : "";
+                const { params } = parseHashUrl(url);
+                infoCheck.params = params;
+                let pageCache = await findPageCache(infoCheck.page);
+                const { hasSelectionHandling } = pageCache !== null && pageCache !== void 0 ? pageCache : {};
+                // console.log("page load template 1.1", url, infoCheck, hasSelectionHandling);
+                if (hasSelectionHandling !== true) {
+                    // get the last anchor as page
+                    const { page } = parseHashUrl(url);
+                    infoCheck.page = page;
+                    pageCache = await findPageCache(infoCheck.page);
+                }
+                const { template, pageInfo } = pageCache !== null && pageCache !== void 0 ? pageCache : {};
+                // console.log("page load template 1.2", url, infoCheck);
+                const { data } = pageInfo !== null && pageInfo !== void 0 ? pageInfo : {};
+                setCache({
+                    url: url,
+                    page: pageCache,
+                    api: data,
+                    params: infoCheck.params,
+                });
+                setTemplate(template);
+            }
+        };
+        loadPageCache();
+    }, [value]);
+    useEffect(() => {
+        // console.log("force update", value, cache);
+        const loadPage = async () => {
+            const result = await fetchData(cache === null || cache === void 0 ? void 0 : cache.api);
+            // console.log("fetchData result", uuid, value, result);
+            pageContext.current.setData(result !== null && result !== void 0 ? result : {});
+        };
+        loadPage();
+    }, [value, cache]);
+    const fetchData = useCallback(async (req) => {
+        // console.log("page fetchData", uuid, req);
+        let result = null;
+        if (req === null || req === void 0 ? void 0 : req.api) {
+            // console.log("url", window.location.href);
+            let params;
+            if (pageView.isStandalone()) {
+                const res = parseHashUrl(value !== null && value !== void 0 ? value : "");
+                params = res === null || res === void 0 ? void 0 : res.params;
+            }
+            else {
+                const res = getUrlPageParams();
+                params = res === null || res === void 0 ? void 0 : res.params;
+            }
+            // console.log({ page, params });
+            // const urlParams = pageContext?.getUrlParams();
+            // console.log("page fetchData exec service 1.1", req.params, params);
+            const resolveParams = replaceValues(req.params, params);
+            // console.log("page fetchData exec service 1.2", req.api, resolveParams);
+            const resp = await pageContext.current.execService(req.api, resolveParams);
+            const { data } = resp !== null && resp !== void 0 ? resp : {};
+            result = data !== null && data !== void 0 ? data : resp;
+        }
+        return result;
+        // pageContext.current.setData(result ?? {});
+    }, [value]);
+    // Push dynamic component into the slot — synchronous, no flash
+    useLayoutEffect(() => {
+        var _a;
+        (_a = slotRef.current) === null || _a === void 0 ? void 0 : _a.update(template);
+    }, [template]);
+    const pageHandle = {
+        init: (ref) => {
+            pageContext.current = ref;
+        },
+        getSelectedPath: () => {
+            return originalData.selectedPath;
+        },
+    };
+    return (_jsx(PageProvider, { handle: pageHandle, children: _jsx(ChildrenSlot, { ref: slotRef }) }));
+};
+const ChildrenSlot = memo(forwardRef((_, ref) => {
+    const [content, setContent] = useState(null);
+    const setContentImpl = (content) => {
+        setContent(content);
+    };
+    useImperativeHandle(ref, () => ({
+        update: setContentImpl,
+    }), []);
+    return _jsx(_Fragment, { children: content == null ? null : content });
+}));
+export default Page;

package/dist/core/PageCache.d.ts

@@ -0,0 +1,15 @@
+import React from "react";
+interface CacheFallback {
+    getTenant: string | null;
+    getModule: string | null;
+}
+export declare const getPage: (name: string, fallback: CacheFallback) => Promise<{
+    template: import("react/jsx-runtime").JSX.Element;
+    pageInfo: null;
+    hasSelectionHandling?: undefined;
+} | {
+    template: React.DetailedReactHTMLElement<React.HTMLAttributes<HTMLElement>, HTMLElement>;
+    pageInfo: any;
+    hasSelectionHandling: any;
+}>;
+export {};

package/dist/core/PageCache.js

@@ -0,0 +1,26 @@
+"use client";
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { localAPI } from "@ramesesinc/lib/local-api";
+import React from "react";
+import { DynamicTemplate } from "./DynamicTemplate";
+// Simple in-memory cache
+const cache = {};
+export const getPage = async (name, fallback) => {
+    const { getTenant: tenant, getModule: module } = fallback;
+    const key = `${module}/${name}`; // ✅ unique per module
+    if (!cache[key]) {
+        const pageInfo = await localAPI.useMgmt(tenant, module).get("pages", name);
+        if (!pageInfo) {
+            return { template: _jsxs("div", { className: "text-red-500 p-2 border border-red-500", children: ["Page \"", name, "\" not found."] }), pageInfo: null };
+        }
+        const { template, attr } = pageInfo !== null && pageInfo !== void 0 ? pageInfo : { template: null, attr: {} };
+        delete pageInfo.template;
+        delete pageInfo.attr;
+        const tmpl = _jsx(DynamicTemplate, { template: template, attr: attr });
+        const hasSelectionHandling = template === "ExplorerTemplate";
+        cache[key] = { template: tmpl, pageInfo, hasSelectionHandling };
+    }
+    const pageCache = cache[key];
+    const newTemplate = React.cloneElement(pageCache.template);
+    return { template: newTemplate, pageInfo: pageCache.pageInfo, hasSelectionHandling: pageCache.hasSelectionHandling };
+};

package/dist/core/PageContext.d.ts

@@ -0,0 +1,49 @@
+import { BindingModel, EntityMode } from "@ramesesinc/client";
+import React from "react";
+export type DataApiHandler = {
+    exec: (params: Record<string, any>) => Promise<any>;
+    getParams: () => Record<string, any>;
+};
+export type Callback = (value: any) => void;
+export type PageContextValue = {
+    parentContext: unknown;
+    /** page data (form / record / model) */
+    getData: () => Record<string, any>;
+    setData: (value: Record<string, any>, mode?: EntityMode) => void;
+    /** reactive dependency registration */
+    dependsTo: (name: string, callback: Callback) => () => void;
+    notifyDepends: (name?: string | null) => void;
+    /** set arbitrary page prop (internal only) */
+    set: (name: string, value: any) => void;
+    get: (name: string) => any;
+    binding: BindingModel;
+    uuid: string;
+    stack: PageContextValue[];
+    getDataApiHandler: () => DataApiHandler | null;
+    setDataApiHandler: (handler: DataApiHandler) => void;
+    buildParams: (inputParams: Record<string, any>, queryParams: Record<string, any>) => Record<string, any>;
+    execService: (path: string, params: Record<string, any>) => Promise<any>;
+    getAllData: () => Record<string, any>;
+    getMgmt: (collection: string, action: string) => Promise<any>;
+    postMgmt: (collection: string, action: string, params: Record<string, any>) => Promise<any>;
+    setPageParams: (params: Record<string, any>) => void;
+    getPageParams: () => Record<string, any>;
+    getPath: () => string;
+    getUrlParams: () => Record<string, any>;
+};
+export type PageHandle = {
+    init: (ref: PageContextValue) => void;
+    getSelectedPath: () => string | null;
+};
+export type PageProviderRef = {
+    set: (name: string, value: any) => void;
+    get: (name: string) => any;
+};
+export type RefreshHandler = () => void;
+type PageProviderProps = {
+    children: React.ReactNode;
+    handle?: PageHandle;
+};
+export declare const PageProvider: React.FC<PageProviderProps>;
+export declare const usePageContext: () => PageContextValue;
+export {};