@ramesesinc/platform-core 0.1.0

package/dist/lib/layouts/HorizontalLayout.tsx

@@ -0,0 +1,29 @@
+import React, { ReactNode } from "react";
+
+type HorizontalLayoutProps = {
+    layoutid?: string;
+    className?: string;
+    gap?: number;
+    left?: ReactNode;
+    right?: ReactNode;
+    children?: ReactNode;
+};
+
+const HorizontalLayout = ({ layoutid, className, gap = 0, left, right, children }: HorizontalLayoutProps) => {
+
+    const preferredLayoutId = ((layoutid ?? '') ? layoutid : 'horizontallayout');
+
+    return (
+        <div className={`${preferredLayoutId}-container ${className ?? ""} flex flex-row h-full gap-${gap}`}>
+            {left}
+
+            <div className="flex-1">
+                {children}
+            </div>
+
+            {right}
+        </div>
+    );
+};
+
+export default HorizontalLayout;

package/dist/lib/layouts/MainLayout.tsx

@@ -0,0 +1,16 @@
+// src/layouts/MainLayout.tsx
+import { ReactNode } from "react";
+
+interface MainLayoutProps {
+  children: ReactNode;
+}
+
+export const MainLayout = ({ children }: MainLayoutProps) => {
+  return (
+    <div className="min-h-screen flex flex-col">
+      <main className="flex-1">{children}</main>
+    </div>
+  );
+};
+
+export default MainLayout;

package/dist/lib/layouts/PageLayout.tsx

@@ -0,0 +1,29 @@
+import React, { ReactNode } from "react";
+
+type PageLayoutProps = {
+    layoutid?: string;
+    className?: string;
+    gap?: number;
+    header?: ReactNode;
+    footer?: ReactNode;
+    children?: ReactNode;
+};
+
+const PageLayout = ({ layoutid, className, gap = 0, header, footer, children }: PageLayoutProps) => {
+
+    const preferredLayoutId = ((layoutid ?? '') ? layoutid : 'pagelayout');
+
+    return (
+        <div className={`${preferredLayoutId}-container ${className ?? ""} flex flex-col h-full gap-${gap}`}>
+            {header}
+
+            <div className="flex-1">
+                {children}
+            </div>
+
+            {footer}
+        </div>
+    );
+};
+
+export default PageLayout;

package/dist/lib/layouts/VPanel.tsx

@@ -0,0 +1,27 @@
+"use client";
+
+import React, { CSSProperties, ReactNode } from "react";
+
+interface VPanelProps {
+  children?: ReactNode;
+  gap?: number | string; // spacing between items
+  style?: CSSProperties; // custom styles
+  className?: string; // optional tailwind or other class
+}
+
+const VPanel: React.FC<VPanelProps> = ({ children, gap = 0, style, className }) => {
+  const panelStyle: CSSProperties = {
+    display: "flex",
+    flexDirection: "column",
+    gap: gap,
+    ...style,
+  };
+
+  return (
+    <div style={panelStyle} className={className}>
+      {children}
+    </div>
+  );
+};
+
+export default VPanel;

package/dist/lib/layouts/XLayout.tsx

@@ -0,0 +1,29 @@
+import React from "react";
+
+type XLayoutAlignment = "left" | "center" | "right";
+
+type XLayoutProps = {
+  className?: string;
+  gap?: number; 
+  align?: XLayoutAlignment;
+  children?: React.ReactNode;
+};
+
+const XLayout: React.FC<XLayoutProps> = ({
+  className,
+  gap = 2,
+  align = "left",
+  children,
+}) => {
+  let justifyClass = "justify-start"; // default = left
+  if (align === "center") justifyClass = "justify-center";
+  if (align === "right") justifyClass = "justify-end";
+
+  return (
+    <div className={`${className ?? ""} flex flex-row gap-${gap} ${justifyClass}`.trim()}>
+      {children}
+    </div>
+  );
+};
+
+export default XLayout;

package/dist/lib/layouts/YLayout.tsx

@@ -0,0 +1,29 @@
+import React from "react";
+
+type YLayoutAlignment = "top" | "center" | "bottom";
+
+type YLayoutProps = {
+  className?: string;
+  gap?: number; 
+  align?: YLayoutAlignment;
+  children?: React.ReactNode;
+};
+
+const YLayout: React.FC<YLayoutProps> = ({
+  className,
+  gap = 2,
+  align = "top",
+  children,
+}) => {
+  let justifyClass = "justify-start"; // default = left
+  if (align === "center") justifyClass = "justify-center";
+  if (align === "bottom") justifyClass = "justify-end";
+
+  return (
+    <div className={`${className ?? ""} flex flex-col gap-${gap} ${justifyClass}`.trim()}>
+      {children}
+    </div>
+  );
+};
+
+export default YLayout;

package/dist/lib/utils/BeanUtils.d.ts

@@ -0,0 +1,3 @@
+export declare const getValue: (path: string | Record<string, any>, data: any) => any;
+export declare const replaceValues: (obj: any, source: any) => any;
+export declare const substituteExpr: (expression: string, source: any) => string;

package/dist/lib/utils/BeanUtils.js

@@ -0,0 +1,75 @@
+export const getValue = (path, data) => {
+    if (path == null)
+        return undefined;
+    // If path is an object, recursively resolve all its values
+    if (typeof path === "object") {
+        const resolved = {};
+        for (const key in path) {
+            resolved[key] = getValue(path[key], data);
+        }
+        return resolved;
+    }
+    if (typeof path !== "string")
+        return undefined;
+    if (!path.includes("{"))
+        return path;
+    // If the entire string is a single placeholder e.g. "{vdata}" or "{vdata.company.name}"
+    // return the raw value instead of a string replacement
+    const singlePlaceholder = path.match(/^\{([^}]+)\}$/);
+    if (singlePlaceholder) {
+        const tokens = singlePlaceholder[1].split(".").filter(Boolean);
+        let current = data;
+        for (const token of tokens) {
+            if (current == null)
+                return undefined;
+            current = current[token];
+        }
+        return current !== undefined ? current : undefined;
+    }
+    // If the string contains placeholders mixed with other text e.g. "Hello {name}!"
+    // fall back to string replacement
+    return path.replace(/\{([^}]+)\}/g, (match, subPath) => {
+        const tokens = subPath.split(".").filter(Boolean);
+        let current = data;
+        for (const token of tokens) {
+            if (current == null)
+                return match;
+            current = current[token];
+        }
+        return current !== undefined ? current : match;
+    });
+};
+export const replaceValues = (obj, source) => {
+    // Handle null or undefined
+    if (obj === null || obj === undefined) {
+        return obj;
+    }
+    // Handle primitives (numbers, booleans)
+    if (typeof obj !== 'object' && typeof obj !== 'string') {
+        return obj;
+    }
+    // Handle strings - use getValue to resolve any templates
+    if (typeof obj === 'string') {
+        // getValue already handles both {id} and "text {id} more text" patterns
+        return getValue(obj, source);
+    }
+    // Handle arrays
+    if (Array.isArray(obj)) {
+        return obj.map(item => replaceValues(item, source));
+    }
+    // Handle objects - recursively replace all values
+    const result = {};
+    for (const key in obj) {
+        if (obj.hasOwnProperty(key)) {
+            result[key] = replaceValues(obj[key], source);
+        }
+    }
+    return result;
+};
+export const substituteExpr = (expression, source) => {
+    if (!expression || typeof expression !== 'string') {
+        return expression;
+    }
+    // Use getValue which already handles the replacement logic
+    return getValue(expression, source);
+};

package/dist/lib/utils/ComponentLoader.d.ts

@@ -0,0 +1,13 @@
+import React from "react";
+export type ComponentLoaderFunc = (name: string) => React.ComponentType<any>;
+/**
+ * Loads components (blocks) with caching: local → package → error
+ */
+export declare class ComponentLoader {
+    private static defaultLoader;
+    private static cache;
+    /** Set default loader for components */
+    static setDefaultLoader(loader: ComponentLoaderFunc): void;
+    /** Get component by name (uses cache) */
+    static get(name: string): React.ComponentType<any>;
+}

package/dist/lib/utils/ComponentLoader.js

@@ -0,0 +1,26 @@
+// src/lib/utils/ComponentLoader.tsx
+import React from "react";
+/**
+ * Loads components (blocks) with caching: local → package → error
+ */
+export class ComponentLoader {
+    /** Set default loader for components */
+    static setDefaultLoader(loader) {
+        this.defaultLoader = loader;
+    }
+    /** Get component by name (uses cache) */
+    static get(name) {
+        if (this.cache[name])
+            return this.cache[name];
+        if (!this.defaultLoader) {
+            const fallback = () => React.createElement("div", { style: { color: "red", padding: 8 } }, `Component "${name}" not found: no loader registered`);
+            this.cache[name] = fallback;
+            return fallback;
+        }
+        const Comp = this.defaultLoader(name);
+        this.cache[name] = Comp;
+        return Comp;
+    }
+}
+ComponentLoader.defaultLoader = null;
+ComponentLoader.cache = {};

package/dist/lib/utils/ExprUtil.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Renders an expression template with the provided data
+ * @param expr - The expression template string
+ * @param data - The data object to use for rendering
+ * @returns The rendered string
+ */
+export declare const render: (expr: string, data: any) => string;

package/dist/lib/utils/ExprUtil.js

@@ -0,0 +1,44 @@
+// import nunjucks from "nunjucks";
+const nunjucks = require("nunjucks");
+let _nunjucksEnv = null;
+const getNunjucksEnv = () => {
+    if (!_nunjucksEnv) {
+        _nunjucksEnv = new nunjucks.Environment(null, {
+            autoescape: false,
+            tags: {
+                variableStart: "{{",
+                variableEnd: "}}",
+            },
+        });
+    }
+    return _nunjucksEnv;
+};
+/**
+ * Renders an expression template with the provided data
+ * @param expr - The expression template string
+ * @param data - The data object to use for rendering
+ * @returns The rendered string
+ */
+export const render = (expr, data) => {
+    if (!expr)
+        return "";
+    try {
+        return getNunjucksEnv().renderString(expr, data);
+    }
+    catch (error) {
+        console.error("Expression render error:", error);
+        return expr;
+    }
+};
+// import Mustache from "mustache";
+// // Disable HTML escaping since you control the source
+// Mustache.escape = (text) => text;
+// export const render = (expr: string, data: any): string => {
+//   if (!expr) return "";
+//   try {
+//     return Mustache.render(expr, data);
+//   } catch (error) {
+//     console.error("Expression render error:", error);
+//     return expr;
+//   }
+// };

package/dist/lib/utils/PageUtils.d.ts

@@ -0,0 +1,6 @@
+export interface ParsedHashUrl {
+    page: string;
+    params: Record<string, string>;
+}
+export declare function parseHashUrl(url: string): ParsedHashUrl;
+export declare function getUrlPageParams(): ParsedHashUrl;

package/dist/lib/utils/PageUtils.js

@@ -0,0 +1,121 @@
+/*
+export const substitute = (template: string, data: any) => {
+  if (typeof template !== "string") return template;
+
+  return template.replace(/\{([^}]+)\}/g, (_, path) => {
+    const value = getValue(path, data);
+    return value !== undefined ? value : "";
+  });
+};
+*/
+export function parseHashUrl(url) {
+    const result = {};
+    // Remove leading slash
+    const cleaned = url.startsWith("/") ? url.slice(1) : url;
+    // Split by '#' to get segments
+    const segments = cleaned.split("#");
+    // If only one segment, params go to root level, page is the path
+    if (segments.length === 1) {
+        const [path, queryString] = segments[0].split("?");
+        if (queryString) {
+            parseParams(queryString).forEach(([key, value]) => {
+                result[key] = value;
+            });
+        }
+        return { page: path, params: result };
+    }
+    // Parse all segments first
+    const parsed = segments.map((segment) => {
+        const [path, queryString] = segment.split("?");
+        const params = queryString ? Object.fromEntries(parseParams(queryString)) : {};
+        return { path, params };
+    });
+    const lastIndex = parsed.length - 1;
+    const page = parsed[lastIndex].path;
+    // Collect all keys that will exist in the result:
+    // - group names (non-last segment paths)
+    // - last segment's param keys (always flat)
+    // - non-last segments' param keys (candidates for flattening)
+    const lastParams = parsed[lastIndex].params;
+    const groupNames = new Set(parsed.slice(0, lastIndex).map((s) => s.path));
+    const lastParamKeys = new Set(Object.keys(lastParams));
+    // Build a flat key registry to detect conflicts
+    // Start with group names and last segment keys
+    const reservedKeys = new Set([...groupNames, ...lastParamKeys]);
+    // For each non-last segment, decide: flatten or nest
+    // Process in order, updating reservedKeys as we go
+    const segmentDecisions = [];
+    for (let i = 0; i < lastIndex; i++) {
+        const { path, params } = parsed[i];
+        const paramKeys = Object.keys(params);
+        // Can flatten if none of the param keys conflict with already reserved keys
+        // and the path name itself won't be lost (path is already in reservedKeys as a group name,
+        // but we only add it if nesting — so check param keys against reservedKeys excluding own path)
+        const canFlatten = paramKeys.every((k) => !reservedKeys.has(k));
+        if (canFlatten) {
+            // Remove the group name from reserved (we won't be using it as a key)
+            reservedKeys.delete(path);
+            // Add flattened keys to reserved
+            paramKeys.forEach((k) => reservedKeys.add(k));
+            segmentDecisions.push({ path, params, flatten: true });
+        }
+        else {
+            segmentDecisions.push({ path, params, flatten: false });
+        }
+    }
+    // Build result
+    for (const { path, params, flatten } of segmentDecisions) {
+        if (flatten) {
+            Object.assign(result, params);
+        }
+        else {
+            result[path] = params;
+        }
+    }
+    // Last segment always flat at root
+    Object.assign(result, lastParams);
+    return { page, params: result };
+}
+function parseParams(queryString) {
+    return queryString.split("&").map((pair) => {
+        const [key, value] = pair.split("=");
+        return [decodeURIComponent(key), decodeURIComponent(value !== null && value !== void 0 ? value : "")];
+    });
+}
+export function getUrlPageParams() {
+    return parseHashUrl(window.location.href);
+}
+// export type ParsedPage = {
+//   pagename: string;
+//   params: Record<string, string>;
+// };
+// export const parseUrl = (url: string): ParsedPage[] => {
+//   const urlObj = url.startsWith("http") ? new URL(url) : new URL(url, window.location.origin);
+//   const pages: ParsedPage[] = [];
+//   // ---- main page ----
+//   const mainParams: Record<string, string> = {};
+//   urlObj.searchParams.forEach((value, key) => {
+//     mainParams[key] = value;
+//   });
+//   pages.push({
+//     pagename: urlObj.pathname.substring(1) || "home",
+//     params: mainParams,
+//   });
+//   // ---- hash page (next page) ----
+//   if (urlObj.hash) {
+//     const rawHash = urlObj.hash.substring(1); // remove #
+//     const [hashPath, hashQuery] = rawHash.split("?", 2);
+//     const hashParams: Record<string, string> = {};
+//     if (hashQuery) {
+//       const searchParams = new URLSearchParams(hashQuery);
+//       searchParams.forEach((value, key) => {
+//         hashParams[key] = value;
+//       });
+//     }
+//     pages.push({
+//       pagename: hashPath || "home",
+//       params: hashParams,
+//     });
+//   }
+//   return pages;
+// };

package/dist/lib/utils/ResourceLoader.d.ts

@@ -0,0 +1,11 @@
+import React from "react";
+export type ComponentLoader = (name: string) => React.ComponentType<any>;
+export declare class ResourceLoader {
+    private static loaders;
+    private static defaultLoader;
+    private static cache;
+    static registerLoader(key: string, loader: ComponentLoader): void;
+    static setDefaultLoader(loader: ComponentLoader): void;
+    static getTemplate(name: string, loaderKey?: string): React.ComponentClass<{}, any> | React.FunctionComponent<{}>;
+    static getComponent(name: string): React.ComponentClass<{}, any> | React.FunctionComponent<{}>;
+}

package/dist/lib/utils/ResourceLoader.js

@@ -0,0 +1,37 @@
+// src/lib/utils/ResourceLoader.tsx
+import dynamic from "next/dynamic";
+import React from "react";
+export class ResourceLoader {
+    static registerLoader(key, loader) {
+        this.loaders[key] = loader;
+    }
+    static setDefaultLoader(loader) {
+        this.defaultLoader = loader;
+    }
+    static getTemplate(name, loaderKey = "default") {
+        const cacheKey = `${loaderKey}:${name}`;
+        if (this.cache[cacheKey])
+            return this.cache[cacheKey];
+        const loader = loaderKey === "default" ? this.defaultLoader : this.loaders[loaderKey];
+        if (!loader) {
+            const Fallback = dynamic(() => Promise.resolve({
+                default: () => React.createElement("div", { style: { color: "red" } }, `No loader registered for "${loaderKey}"`),
+            }));
+            this.cache[cacheKey] = Fallback;
+            return Fallback;
+        }
+        const Comp = loader(name);
+        // this is temporary it should be cloned
+        // if (loaderKey != "component") {
+        //   this.cache[cacheKey] = Comp;
+        // }
+        return Comp;
+    }
+    // Convenience helpers
+    static getComponent(name) {
+        return this.getTemplate(name, "component");
+    }
+}
+ResourceLoader.loaders = {};
+ResourceLoader.defaultLoader = null;
+ResourceLoader.cache = {};

package/dist/lib/utils/SectionProvider.d.ts

@@ -0,0 +1,5 @@
+import React from "react";
+export declare const SectionProvider: (attr?: Record<string, any>) => {
+    getSection: (name: string) => React.ReactNode;
+};
+export declare const renderListDef: (list?: Record<string, any>[]) => React.ReactNode[];

package/dist/lib/utils/SectionProvider.js

@@ -0,0 +1,39 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { DynamicComponent } from "../../core/DynamicComponent";
+import HPanel from "../../layouts/HPanel";
+export const SectionProvider = (attr = {}) => {
+    const sections = {};
+    return {
+        getSection: (name) => {
+            if (!sections[name]) {
+                const sectionDef = attr[name];
+                if (sectionDef == null)
+                    return null;
+                if (Array.isArray(sectionDef)) {
+                    sections[name] = renderListDef(sectionDef);
+                }
+                else if (sectionDef != null && typeof sectionDef === "object") {
+                    sections[name] = renderListDef([sectionDef]);
+                }
+                else {
+                    sections[name] = [_jsx(DynamicComponent, { config: { component: sectionDef.toString(), attr: {} } })];
+                }
+            }
+            return sections[name];
+        },
+    };
+};
+export const renderListDef = (list = []) => {
+    const results = [];
+    for (const [index, it] of list.entries()) {
+        if (Array.isArray(it)) {
+            const subItems = renderListDef(it);
+            results.push(_jsx(HPanel, { gap: 8, children: subItems }, index));
+        }
+        else {
+            const item = it;
+            results.push(_jsx(DynamicComponent, { config: item }, index));
+        }
+    }
+    return results;
+};

package/dist/lib/utils/initResourceLoader.js

@@ -0,0 +1,95 @@
+"use strict";
+// import dynamic from "next/dynamic";
+// import React from "react";
+// import { ResourceLoader } from "./ResourceLoader";
+// const isDev = process.env.NODE_ENV === "development";
+// console.log("dev mode, is", isDev);
+// const packageLoaders: Record<string, () => Promise<any>> = {
+//   "@ramesesinc/platform-core": () => import("@ramesesinc/platform-core"),
+//   "@ramesesinc/client": () => import("@ramesesinc/client"),
+// };
+// const templateLoaders: Record<string, () => Promise<any>> = isDev
+//   ? { "@/templates": () => import("@/templates"), ...packageLoaders }
+//   : { ...packageLoaders, "@/templates": () => import("@/templates") };
+// const componentLoaders: Record<string, () => Promise<any>> = isDev
+//   ? { "@/components": () => import("@/components"), ...packageLoaders }
+//   : { ...packageLoaders, "@/components": () => import("@/components") };
+// /* ======================== Template Loader ======================== */
+// const templateLoader = (name: string) =>
+//   dynamic(async () => {
+//     for (const loader of Object.values(templateLoaders)) {
+//       try {
+//         const mod = await loader();
+//         const Temp = (mod as Record<string, any>)[name];
+//         if (Temp) {
+//           let hasSelectionHandling = false;
+//           try {
+//             hasSelectionHandling = Temp.hasSelectionHandling ?? false;
+//           } catch (err) {}
+//           return { default: Temp, hasSelectionHandling };
+//         }
+//       } catch (err) {
+//         console.log("template loader Error", name, err);
+//       }
+//     }
+//     // fallback → template not found in any path
+//     return {
+//       default: () =>
+//         React.createElement(
+//           "div",
+//           {
+//             style: { color: "red", padding: "8px", border: "1px solid red" },
+//           },
+//           `Template "${name}" is not registered`,
+//         ),
+//     };
+//   });
+// /* ======================== Component Loader ======================== */
+// const componentLoader = (name: string) =>
+//   dynamic(async () => {
+//     for (const loader of Object.values(componentLoaders)) {
+//       try {
+//         const mod = await loader();
+//         const Comp = (mod as Record<string, any>)[name];
+//         if (Comp) {
+//           return { default: Comp };
+//         }
+//       } catch (err) {
+//         console.log("component loader Error", name, err);
+//       }
+//     }
+//     return {
+//       default: () =>
+//         React.createElement(
+//           "div",
+//           {
+//             style: { color: "red", padding: "8px", border: "1px solid red" },
+//           },
+//           `Component "${name}" is not registered`,
+//         ),
+//     };
+//   });
+// // const actionLoader = (name: string) =>
+// //   dynamic(async () => {
+// //     try {
+// //       // 1️⃣ local component
+// //       const mod = await import(`@/actions`);
+// //       return { default: mod[name as keyof typeof mod] };
+// //     } catch {
+// //       try {
+// //         // 2️⃣ package component
+// //         const pkg = await import("@ramesesinc/react-ui");
+// //         const Comp = (pkg as Record<string, any>)[name];
+// //         if (!Comp) throw new Error();
+// //         return { default: Comp };
+// //       } catch {
+// //         // 3️⃣ neither found → throw
+// //         throw new Error(`Component "${name}" not found in local components or "@ramesesinc/react-ui"`);
+// //       }
+// //     }
+// //   });
+// /* ---------------- Register loaders ---------------- */
+// ResourceLoader.setDefaultLoader(templateLoader);
+// ResourceLoader.registerLoader("component", componentLoader);
+// // ResourceLoader.registerLoader("action", actionLoader);
+// export default ResourceLoader;