@ramesesinc/platform-core 0.1.0

package/dist/core/PageContext.js

@@ -0,0 +1,207 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useBinding } from "@ramesesinc/client";
+import { localAPI } from "@ramesesinc/lib/local-api";
+import { createContext, useContext, useEffect, useLayoutEffect, useMemo, useRef, useState } from "react";
+import { parseHashUrl } from "../lib/utils/PageUtils";
+import { useApp } from "./AppContext";
+import { DataBindingProvider } from "./DataContext";
+import { usePageViewContext } from "./PageViewContext";
+const contextStack = [];
+/* ------------------ Context ------------------ */
+const PageContext = createContext({
+    parentContext: null,
+    getData: () => ({}),
+    setData: () => { },
+    dependsTo: () => () => { },
+    notifyDepends: () => { },
+    set: () => { },
+    get: () => undefined,
+    binding: {},
+    uuid: "",
+    stack: [],
+    getDataApiHandler: () => null,
+    setDataApiHandler: () => { },
+    buildParams: () => ({}),
+    execService: async () => ({}),
+    getAllData: () => ({}),
+    getMgmt: async () => ({}),
+    postMgmt: async () => ({}),
+    setPageParams: () => { },
+    getPageParams: () => ({}),
+    getPath: () => "",
+    getUrlParams: () => ({}),
+});
+export const PageProvider = ({ handle, children }) => {
+    const [uuid] = useState(() => "PageProvider-" + Math.random().toString(36).slice(2));
+    // console.log("PageContext paths", uuid, paths);
+    const parentContext = useContext(PageContext);
+    const pageView = usePageViewContext();
+    const binding = useBinding();
+    // setup the selectedPath from the handle
+    useMemo(() => {
+        const path = handle === null || handle === void 0 ? void 0 : handle.getSelectedPath();
+        binding.set("selectedPage", path);
+        return path;
+    }, [handle]);
+    // for DEV purposes only
+    useMemo(() => {
+        const dependHandler = () => {
+            // console.log("selectedPage changed => ", binding.get("selectedPage"));
+        };
+        binding.dependsTo("selectedPage", dependHandler);
+    }, []);
+    const dataApiHandler = useRef(null);
+    const { tenant, module } = useApp();
+    const providerRef = {
+        set: (name, value) => {
+            set(name, value);
+        },
+        get: (name) => {
+            return get(name);
+        },
+    };
+    const getPath = () => {
+        const path = get("selectedPage");
+        return path !== null && path !== void 0 ? path : "";
+    };
+    const getUrlParams = () => {
+        const path = getPath();
+        const targets = [];
+        if (path != null && path.trim() !== "") {
+            targets.push(path);
+        }
+        const collectPath = (ctx, targets) => {
+            if (ctx == null)
+                return;
+            const currentCtx = ctx;
+            if (typeof currentCtx.getPath === "function") {
+                const path = currentCtx.getPath();
+                if (path != null && path.trim() !== "") {
+                    targets.push(path);
+                }
+            }
+            collectPath(currentCtx.parentContext, targets);
+        };
+        collectPath(parentContext, targets);
+        const fullPath = targets.reverse().join("#");
+        const { params } = parseHashUrl(fullPath);
+        return params;
+    };
+    /* ------------------ Data ------------------ */
+    const getData = () => {
+        return binding.getData();
+    };
+    const setData = (value, mode) => {
+        binding.setData(value, mode !== null && mode !== void 0 ? mode : "read");
+    };
+    /* ------------------ Reactive deps ------------------ */
+    const dependsTo = (name, callback) => {
+        return binding.dependsTo(name, callback);
+    };
+    const notifyDepends = (name) => {
+        binding.notifyDepends(name);
+        const { refresh } = pageView.getEventHandler();
+        // console.log("pageview event handler", refresh, pageView.getEventHandler());
+        if (refresh && typeof refresh === "function") {
+            refresh();
+        }
+    };
+    /* ------------------ Internal props setter ------------------ */
+    const set = (name, value) => {
+        if (name === "data") {
+            binding.setData(value);
+        }
+        else {
+            binding.set(name, value);
+        }
+    };
+    const get = (name) => {
+        if (name === "data") {
+            return binding.getData();
+        }
+        const val = binding.get(name);
+        // console.log("page context get", name, val, binding.getData());
+        return val;
+    };
+    const buildParams = (inputParams, queryParams) => {
+        return inputParams;
+    };
+    const execService = async (path, params) => {
+        const result = await localAPI.exec(`/services/exec/${tenant}/${module}/${path}`, params);
+        if (result.error) {
+            // throw new Error(result.error.message); to be uncomment
+            console.log("execService error", result.error);
+        }
+        return result;
+    };
+    const getMgmt = async (collection, action) => {
+        const result = await localAPI.useMgmt(tenant, module).get(collection, action);
+        return result;
+    };
+    const postMgmt = async (collection, action, params) => {
+        const result = await localAPI.useMgmt(tenant, module).post(collection, action, params);
+        return result;
+    };
+    const setPageParams = (params) => {
+        binding.set("pageParams", params);
+    };
+    const getPageParams = () => {
+        return binding.get("pageParams");
+    };
+    /* ------------------ Context value ------------------ */
+    const values = {
+        parentContext,
+        getData,
+        setData,
+        set,
+        get,
+        dependsTo,
+        notifyDepends,
+        binding,
+        uuid,
+        stack: [],
+        getDataApiHandler: () => dataApiHandler.current,
+        setDataApiHandler: (handler) => {
+            dataApiHandler.current = handler;
+        },
+        buildParams,
+        execService,
+        getMgmt,
+        postMgmt,
+        getAllData: () => {
+            const allData = Object.assign(Object.assign({}, binding.getUiData()), { data: binding.getData(), pageParams: getPageParams() });
+            return allData;
+        },
+        setPageParams,
+        getPageParams,
+        getPath,
+        getUrlParams,
+    };
+    const stack = [...((parentContext === null || parentContext === void 0 ? void 0 : parentContext.stack) || []), Object.assign({}, values)];
+    // Push/pop to global stack for demonstration
+    useEffect(() => {
+        const idx = contextStack.length;
+        const parent = idx > 0 ? contextStack[idx - 1] : null;
+        values.parentContext = parent;
+        contextStack.push(values);
+        return () => {
+            const index = contextStack.findIndex((c) => c.uuid === values.uuid);
+            if (index >= 0)
+                contextStack.splice(index, 1);
+        };
+    }, []);
+    const contextValue = values;
+    const dataBindingValue = Object.assign(Object.assign({}, contextValue), { getBinding: () => binding });
+    useLayoutEffect(() => {
+        if (handle == null)
+            return;
+        handle.init(contextValue);
+    }, []);
+    return (_jsx(PageContext.Provider, { value: contextValue, children: _jsx(DataBindingProvider, { handler: dataBindingValue, children: children }) }));
+};
+/* ------------------ Hook ------------------ */
+export const usePageContext = () => {
+    const ctx = useContext(PageContext);
+    return ctx;
+};

package/dist/core/PageRegistry.d.ts

@@ -0,0 +1,7 @@
+export type PageRegistry = {
+    get: (name: string, config?: {
+        tenant?: string;
+        module?: string;
+    }) => Promise<Record<string, any>>;
+};
+export declare const usePageRegistry: () => PageRegistry;

package/dist/core/PageRegistry.js

@@ -0,0 +1,11 @@
+import { localAPI } from "@ramesesinc/lib/local-api";
+export const usePageRegistry = () => {
+    const reg = {
+        get: async (name, config) => {
+            var _a, _b;
+            const result = await localAPI.useMgmt((_a = config.tenant) !== null && _a !== void 0 ? _a : "", (_b = config.module) !== null && _b !== void 0 ? _b : "").get("pages", name);
+            return result;
+        },
+    };
+    return reg;
+};

package/dist/core/PageViewContext.d.ts

@@ -0,0 +1,45 @@
+import React from "react";
+import { EventHandler } from ".";
+export type PageOptions = {
+    mode?: "window" | "popup";
+    [key: string]: any;
+};
+export type PageViewContextValue = {
+    uuid: string;
+    parentContext: PageViewContextValue | null;
+    stack: PageViewContextValue[];
+    paths: string[];
+    setPage: (page: string | null, options?: PageOptions) => void;
+    setSelectedPage: (page: string | null) => void;
+    getSelectedPage: () => string | null;
+    pushPage: (page: string) => void;
+    popPage: () => void;
+    hasBackPage: () => boolean;
+    isStandalone: () => boolean;
+    hasSelectionHandling: () => boolean;
+    setSelectionHandling: (hasHandling: boolean) => void;
+    getOriginalLocationInfo: () => PageChainInfo | null;
+    getEventHandler: () => EventHandler | null;
+};
+export type PageViewHandle = {
+    init: (ref: PageViewContextValue) => void;
+    renderPage: (page: string | null) => void;
+    isStandalone: () => boolean;
+};
+export type PageSelectionHandler = {};
+type PageChainInfo = {
+    path: string;
+    base: string;
+    page: string;
+    options: PageOptions;
+};
+type PageViewProviderProps = {
+    paths: string[];
+    handle: PageViewHandle;
+    children: React.ReactNode;
+    prefix?: string;
+    eventHandler?: EventHandler | null;
+};
+export declare const PageViewProvider: React.FC<PageViewProviderProps>;
+export declare const usePageViewContext: () => PageViewContextValue;
+export {};

package/dist/core/PageViewContext.js

@@ -0,0 +1,277 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useCallback, useContext, useEffect, useLayoutEffect, useMemo, useRef, useState } from "react";
+import { useApp } from "./AppContext";
+/* ------------------ Global Stack ------------------ */
+const contextStack = [];
+/* ------------------ Context ------------------ */
+const PageViewContext = createContext({
+    uuid: "",
+    parentContext: null,
+    stack: [],
+    paths: [],
+    setPage: () => { },
+    getSelectedPage: () => null,
+    pushPage: () => { },
+    popPage: () => { },
+    setSelectedPage: () => { },
+    hasBackPage: () => false,
+    isStandalone: () => false,
+    hasSelectionHandling: () => false,
+    setSelectionHandling: () => null,
+    getOriginalLocationInfo: () => null,
+    getEventHandler: () => null,
+});
+export const PageViewProvider = ({ paths, handle, children, prefix = "page", eventHandler = {}, }) => {
+    const parentContext = useContext(PageViewContext);
+    const [uuid] = useState(() => `${prefix}-${Math.random().toString(36).slice(2)}`);
+    const app = useApp();
+    const [hasSelectionHandling, setSelectionHandling] = useState(false);
+    const isStandalone = useCallback(() => {
+        return handle == null ? true : handle.isStandalone();
+    }, [handle]);
+    const getLocationInfo = useCallback(() => {
+        var _a, _b;
+        const result = {
+            root: "",
+            path: "",
+            base: "",
+        };
+        try {
+            if (window == null)
+                return result;
+            const pathname = window.location.pathname;
+            let paths = pathname.split("/");
+            result.root = paths.slice(0, -1).join("/");
+            paths.length = 0;
+            paths = [pathname];
+            const query = (_a = window.location.search) !== null && _a !== void 0 ? _a : "";
+            if (query.length > 0) {
+                if (!query.startsWith("?")) {
+                    paths.push("?");
+                }
+                paths.push(query);
+            }
+            const finalBasePaths = [];
+            finalBasePaths.push(paths.join(""));
+            const hash = (_b = window.location.hash) !== null && _b !== void 0 ? _b : "";
+            if (hash.length > 0) {
+                if (!hash.startsWith("#")) {
+                    paths.push("#");
+                }
+                paths.push(hash);
+            }
+            let [, ...anchors] = hash.split("#");
+            anchors = anchors.slice(0, -1);
+            if (anchors.length > 0) {
+                finalBasePaths.push("#" + anchors.join("#"));
+            }
+            result.base = finalBasePaths.join("");
+            result.path = paths.join("");
+            return result;
+        }
+        catch (err) {
+            console.log("Error getting path location info:", err);
+            return result;
+        }
+    }, []);
+    const originalLocInfo = useMemo(() => {
+        const [, selectedPath] = paths;
+        const standalone = isStandalone();
+        const chainInfo = { base: "", path: "", page: "" };
+        if (standalone) {
+            chainInfo.path = selectedPath !== null && selectedPath !== void 0 ? selectedPath : "";
+            chainInfo.page = chainInfo.path;
+        }
+        else {
+            const loc = getLocationInfo();
+            chainInfo.base = loc.base;
+            chainInfo.path = [loc.path, selectedPath].filter(Boolean).join("#");
+        }
+        // console.log("pageview original loc info ", chainInfo);
+        return chainInfo;
+    }, [paths, handle]);
+    const [pageChain, setPageChain] = useState(() => {
+        var _a;
+        const [, selectedPath] = paths;
+        const standalone = isStandalone();
+        const chainInfo = { path: "", base: "", page: "", options: {} };
+        const result = { current: chainInfo, previous: null };
+        if (standalone) {
+            chainInfo.path = selectedPath !== null && selectedPath !== void 0 ? selectedPath : "";
+            chainInfo.page = chainInfo.path;
+        }
+        else {
+            const loc = getLocationInfo();
+            chainInfo.path = [loc.path, selectedPath].filter(Boolean).join("#");
+            chainInfo.base = loc.base;
+            if (loc.base !== "") {
+                chainInfo.page = (_a = loc.base.split("/").at(-1)) !== null && _a !== void 0 ? _a : "";
+            }
+        }
+        return result;
+    });
+    const handleRef = useRef(handle);
+    useLayoutEffect(() => {
+        handleRef.current = handle;
+    }, [handle]);
+    useEffect(() => {
+        const standalone = isStandalone();
+        // console.log("pageChain changed", uuid, standalone, pageChain);
+    }, [pageChain]);
+    const setSelectedPage = (page) => {
+        const chainInfo = pageChain.current;
+        const newChainInfo = Object.assign(Object.assign({}, chainInfo), { page });
+        if (page == null || page === "") {
+            // do nothing
+        }
+        else {
+            newChainInfo.path = newChainInfo.base + "#" + page;
+            newChainInfo.page = page;
+        }
+        pageChain.current = newChainInfo;
+    };
+    const setPage = (page, options = {}) => {
+        var _a;
+        if (page == null || page.trim() === "") {
+            return;
+        }
+        const standalone = isStandalone();
+        const pageOptions = options !== null && options !== void 0 ? options : {};
+        const { mode = "default" } = pageOptions;
+        const locInfo = getLocationInfo();
+        const { current: currentChain, previous: previousChain } = pageChain;
+        const newChainInfo = { path: "", base: "", page: "", options: pageOptions };
+        const newPageChain = { current: newChainInfo, previous: null };
+        if (mode != null && mode === "window") {
+            newChainInfo.page = page;
+            newChainInfo.base = locInfo.root;
+            newChainInfo.path = locInfo.root + "/" + page;
+            newPageChain.previous = { current: currentChain, previous: previousChain };
+        }
+        else {
+            newChainInfo.page = page;
+            newChainInfo.base = originalLocInfo.base;
+            newChainInfo.path = [originalLocInfo.base, page].filter(Boolean).join("#");
+        }
+        setPageChain((prev) => (Object.assign({}, newPageChain)));
+        if (!standalone) {
+            history.pushState(null, "", newChainInfo.path);
+        }
+        (_a = handleRef.current) === null || _a === void 0 ? void 0 : _a.renderPage(page);
+    };
+    const pushPage = (page) => {
+        var _a;
+        if (page == null)
+            return;
+        const standalone = isStandalone();
+        // console.log("pushPage (pageChain)", uuid, prefix, pageChain, standalone, parentContext);
+        const { current: chainInfo, previous: prevChain } = pageChain;
+        if (standalone && (chainInfo.path == null || chainInfo.path === "")) {
+            Object.assign(chainInfo, { path: paths[0], base: "", page: paths[0] });
+        }
+        const newChainInfo = {
+            path: [chainInfo.path, page].filter(Boolean).join("#"),
+            base: chainInfo.path,
+            page: page,
+        };
+        const newPageChain = {
+            current: newChainInfo,
+            previous: { current: chainInfo, previous: prevChain },
+        };
+        setPageChain(newPageChain);
+        if (!standalone) {
+            history.pushState(null, "", newChainInfo.path);
+        }
+        (_a = handleRef.current) === null || _a === void 0 ? void 0 : _a.renderPage(page);
+    };
+    const popPage = () => {
+        var _a, _b, _c;
+        // console.log("popPage (pageChain)", uuid, prefix, pageChain);
+        const { previous: prevChain } = pageChain;
+        if (prevChain == null) {
+            return;
+        }
+        const standalone = isStandalone();
+        const current = (_a = prevChain === null || prevChain === void 0 ? void 0 : prevChain.current) !== null && _a !== void 0 ? _a : {};
+        const { path, options = {} } = current;
+        if (path == null || path === "") {
+            return;
+        }
+        // extract page from path
+        let page = "";
+        if (prefix === "root") {
+            let newPath = path.split("#")[0].split("?")[0];
+            const idx = newPath.lastIndexOf("/");
+            if (idx >= 0) {
+                newPath = path.substring(idx + 1);
+            }
+            page = newPath;
+            // console.log("popPage 1.1", uuid, page);
+        }
+        else {
+            const [, ...anchors] = path.split("#");
+            page = (_b = anchors.at(-1)) !== null && _b !== void 0 ? _b : "";
+            if (page === "") {
+                page = path;
+            }
+        }
+        const newPageChain = Object.assign({}, prevChain);
+        setPageChain(newPageChain);
+        if (!standalone) {
+            history.pushState(null, "", path);
+        }
+        (_c = handleRef.current) === null || _c === void 0 ? void 0 : _c.renderPage(page);
+    };
+    const hasBackPage = () => {
+        const { previous } = pageChain;
+        if (previous == null)
+            return false;
+        const { path } = previous.current;
+        return path != null && path !== "";
+    };
+    const values = {
+        parentContext,
+        uuid,
+        stack: [...((parentContext === null || parentContext === void 0 ? void 0 : parentContext.stack) || [])],
+        paths,
+        setPage,
+        setSelectedPage,
+        getSelectedPage: () => {
+            const { current } = pageChain;
+            return current === null || current === void 0 ? void 0 : current.path;
+        },
+        pushPage,
+        popPage,
+        hasBackPage,
+        isStandalone,
+        hasSelectionHandling: () => hasSelectionHandling,
+        setSelectionHandling,
+        getOriginalLocationInfo: () => (Object.assign({}, originalLocInfo)),
+        getEventHandler: () => {
+            return eventHandler !== null && eventHandler !== void 0 ? eventHandler : {};
+        },
+    };
+    useEffect(() => {
+        const idx = contextStack.length;
+        const parent = idx > 0 ? contextStack[idx - 1] : null;
+        values.parentContext = parent;
+        contextStack.push(values);
+        return () => {
+            const index = contextStack.findIndex((c) => c.uuid === values.uuid);
+            if (index >= 0)
+                contextStack.splice(index, 1);
+        };
+    }, []);
+    const stack = [...((parentContext === null || parentContext === void 0 ? void 0 : parentContext.stack) || []), Object.assign({}, values)];
+    values.stack = stack;
+    useLayoutEffect(() => {
+        handle === null || handle === void 0 ? void 0 : handle.init(values);
+    }, []);
+    return _jsx(PageViewContext.Provider, { value: values, children: children });
+};
+/* ------------------ Hook ------------------ */
+export const usePageViewContext = () => {
+    const ctx = useContext(PageViewContext);
+    return ctx;
+};

package/dist/core/Panel.d.ts

@@ -0,0 +1,16 @@
+interface PanelContent {
+    component?: string;
+    attr?: Record<string, any>;
+    elements?: PanelContent[];
+    styles?: Record<string, any>;
+    orientation?: "vertical" | "horizontal";
+    [key: string]: any;
+}
+interface PanelProps {
+    content: PanelContent | PanelContent[] | null;
+    orientation?: "vertical" | "horizontal";
+    styles?: Record<string, any>;
+    className?: string;
+}
+declare const Panel: ({ content, orientation, styles, className }: PanelProps) => import("react/jsx-runtime").JSX.Element | null;
+export default Panel;

package/dist/core/Panel.js

@@ -0,0 +1,39 @@
+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 } from "react/jsx-runtime";
+import { DynamicComponent } from "./DynamicComponent";
+const Panel = ({ content, orientation = "vertical", styles = {}, className = "" }) => {
+    if (content == undefined || content == null) {
+        return null;
+    }
+    return (_jsx("div", { className: className, style: styles, children: renderContent(content, orientation) }));
+};
+const renderContent = (content, orientation = "vertical") => {
+    //console.log(content)
+    // 1. Array → flex container, each item rendered recursively with flipped orientation for nested arrays
+    if (Array.isArray(content)) {
+        const isHorizontal = orientation === "horizontal";
+        return (_jsx("div", { style: { display: "flex", flexDirection: isHorizontal ? "row" : "column", gap: 12, flexWrap: "wrap" }, children: content.map((item, i) => Array.isArray(item) ? (_jsx("div", { children: renderContent(item, isHorizontal ? "vertical" : "horizontal") }, i)) : (_jsx("div", { children: renderContent(item, orientation) }, i))) }));
+    }
+    // 2. Object with `component` → DynamicComponent
+    if (content && typeof content === "object" && content.component) {
+        const { component, attr } = content;
+        return _jsx(DynamicComponent, { config: { component, attr } });
+    }
+    // 3. Object without `component` → Panel with nested elements
+    if (content && typeof content === "object") {
+        const { elements, styles, className, orientation: innerOrientation } = content, rest = __rest(content, ["elements", "styles", "className", "orientation"]);
+        return (_jsx(Panel, { content: elements || null, orientation: innerOrientation || orientation, styles: Object.assign(Object.assign({}, styles), rest), className: className || "" }));
+    }
+    return null;
+};
+export default Panel;

package/dist/core/RowContext.d.ts

@@ -0,0 +1,11 @@
+interface RowContextType {
+    getData: () => Record<string, any>;
+}
+interface RowProviderProps {
+    data: Record<string, any>;
+    children: React.ReactNode;
+}
+declare const RowContext: import("react").Context<RowContextType | null>;
+export declare const useRowContext: () => RowContextType | null;
+export declare const RowProvider: ({ data, children }: RowProviderProps) => import("react/jsx-runtime").JSX.Element;
+export default RowContext;

package/dist/core/RowContext.js

@@ -0,0 +1,16 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext } from "react";
+import { DataBindingProvider, useCreateContextValue } from "./DataContext";
+const RowContext = createContext(null);
+export const useRowContext = () => {
+    const context = useContext(RowContext);
+    return context;
+};
+export const RowProvider = ({ data, children }) => {
+    const dataWrapper = useCreateContextValue(data !== null && data !== void 0 ? data : {});
+    const values = {
+        getData: () => dataWrapper.getData(),
+    };
+    return (_jsx(RowContext.Provider, { value: values, children: _jsx(DataBindingProvider, { handler: dataWrapper, children: children }) }));
+};
+export default RowContext;

package/dist/core/StepHandler.d.ts

@@ -0,0 +1,9 @@
+export type StepActionHandler = {
+    getCurrentIndex: () => number;
+    getLastIndex: () => number;
+    hasPrev: () => boolean;
+    hasNext: () => boolean;
+    next: () => void;
+    back: () => void;
+};
+export declare const StepHandler: (items: Record<string, any>[], callback: (item: Record<string, any>) => void) => StepActionHandler;

package/dist/core/StepHandler.js

@@ -0,0 +1,39 @@
+export const StepHandler = (items, callback) => {
+    let currentIndex = 0;
+    let lastIndex = 0; // max index visited
+    const hasPrev = () => {
+        if (items.length == 0)
+            return false;
+        if (currentIndex - 1 < 0)
+            return false;
+        return true;
+    };
+    const hasNext = () => {
+        if (items.length == 0)
+            return false;
+        if (currentIndex + 1 >= items.length)
+            return false;
+        return true;
+    };
+    const next = () => {
+        currentIndex++;
+        if (currentIndex > lastIndex) {
+            lastIndex = currentIndex;
+        }
+        const selected = items[currentIndex];
+        callback(selected);
+    };
+    const back = () => {
+        currentIndex--;
+        const selected = items[currentIndex];
+        callback(selected);
+    };
+    return {
+        getCurrentIndex: () => currentIndex,
+        getLastIndex: () => lastIndex,
+        hasPrev,
+        hasNext,
+        next,
+        back,
+    };
+};