arcanajs 1.0.0 → 2.0.1

package/lib/server/ResponseHandlerMiddleware.d.ts

@@ -0,0 +1,27 @@
+import type { NextFunction, Request, Response } from "express";
+declare global {
+    namespace Express {
+        interface Response {
+            /**
+             * Sends a success response with a standard format.
+             *
+             * @param data - The data payload to include in the response (default: {}).
+             * @param message - A descriptive message for the success (default: "Success").
+             * @param status - The HTTP status code to return (default: 200).
+             * @returns The Express Response object.
+             */
+            success: (data?: string | object | null, message?: string, status?: number) => Response;
+            /**
+             * Sends an error response with a standard format.
+             *
+             * @param message - A descriptive message for the error (default: "Error").
+             * @param status - The HTTP status code to return (default: 500).
+             * @param error - Additional error details or object (default: null).
+             * @param data - Optional data payload to include in the error response (default: null).
+             * @returns The Express Response object.
+             */
+            error: (message?: string, status?: number, error?: string | object | null, data?: string | object | null) => Response;
+        }
+    }
+}
+export declare const responseHandler: (req: Request, res: Response, next: NextFunction) => void;

package/lib/server/ResponseHandlerMiddleware.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.responseHandler = void 0;
+const responseHandler = (req, res, next) => {
+    res.success = (data = {}, message = "Success", status = 200) => {
+        return res.status(status).json({
+            success: true,
+            message,
+            data,
+            error: null,
+        });
+    };
+    res.error = (message = "Error", status = 500, error = null, data = null) => {
+        const errorResponse = error
+            ? typeof error === "object" && error !== null
+                ? error instanceof Error
+                    ? error.toString()
+                    : error
+                : error.toString()
+            : null;
+        return res.status(status).json({
+            success: false,
+            message,
+            data,
+            error: errorResponse,
+        });
+    };
+    next();
+};
+exports.responseHandler = responseHandler;

package/lib/server/Router.d.ts

@@ -0,0 +1,94 @@
+import express, { Router as ExpressRouter, RequestHandler } from "express";
+/**
+ * Provides Routing syntax for defining routes with prefixes, middlewares, and groups
+ */
+export declare class Router {
+    private router;
+    private middlewareStack;
+    private prefixStack;
+    constructor();
+    /**
+     * Create a new router instance
+     */
+    static create(): Router;
+    /**
+     * Add middleware to the current stack
+     */
+    middleware(...middleware: RequestHandler[]): Router;
+    /**
+     * Add prefix to the current stack
+     */
+    prefix(prefix: string): Router;
+    /**
+     * Create a route group
+     */
+    group(callback: (router: Router) => void): Router;
+    /**
+     * Define a GET route
+     */
+    get(path: string, ...args: any[]): Router;
+    /**
+     * Define a POST route
+     */
+    post(path: string, ...args: any[]): Router;
+    /**
+     * Define a PUT route
+     */
+    put(path: string, ...args: any[]): Router;
+    /**
+     * Define a DELETE route
+     */
+    delete(path: string, ...args: any[]): Router;
+    /**
+     * Define a PATCH route
+     */
+    patch(path: string, ...args: any[]): Router;
+    /**
+     * Define an OPTIONS route
+     */
+    options(path: string, ...args: any[]): Router;
+    /**
+     * Get the underlying Express router
+     */
+    getRouter(): ExpressRouter;
+    /**
+     * Mount this router to an Express app or router
+     */
+    mount(app: express.Application | ExpressRouter, basePath?: string): void;
+    /**
+     * Clone the current router instance
+     */
+    private _clone;
+    /**
+     * Add a route to the router
+     */
+    private _addRoute;
+    /**
+     * Build the full path with prefixes
+     */
+    private _buildPath;
+    /**
+     * Build the route handler
+     */
+    private _buildHandler;
+}
+/**
+ * Static Route class for Laravel-like syntax
+ */
+export declare class Route {
+    private static _router;
+    static create(): Router;
+    static middleware(...middleware: RequestHandler[]): Router;
+    static prefix(prefix: string): Router;
+    static group(callback: (router: Router) => void): Router;
+    static get(path: string, ...args: any[]): Router;
+    static post(path: string, ...args: any[]): Router;
+    static put(path: string, ...args: any[]): Router;
+    static delete(path: string, ...args: any[]): Router;
+    static patch(path: string, ...args: any[]): Router;
+    static options(path: string, ...args: any[]): Router;
+    static getRouter(): ExpressRouter;
+    static mount(app: express.Application, basePath?: string): void;
+    static reset(): void;
+}
+export default Route;

package/lib/server/Router.js

@@ -0,0 +1,203 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Route = exports.Router = void 0;
+const express_1 = __importDefault(require("express"));
+const ControllerBinder_1 = __importDefault(require("./ControllerBinder"));
+/**
+ * Provides Routing syntax for defining routes with prefixes, middlewares, and groups
+ */
+class Router {
+    constructor() {
+        this.router = express_1.default.Router();
+        this.middlewareStack = [];
+        this.prefixStack = [];
+    }
+    /**
+     * Create a new router instance
+     */
+    static create() {
+        return new Router();
+    }
+    /**
+     * Add middleware to the current stack
+     */
+    middleware(...middleware) {
+        const newRouter = this._clone();
+        newRouter.middlewareStack = [...this.middlewareStack, ...middleware];
+        return newRouter;
+    }
+    /**
+     * Add prefix to the current stack
+     */
+    prefix(prefix) {
+        const newRouter = this._clone();
+        newRouter.prefixStack = [
+            ...this.prefixStack,
+            prefix.replace(/^\/|\/$/g, ""),
+        ];
+        return newRouter;
+    }
+    /**
+     * Create a route group
+     */
+    group(callback) {
+        callback(this);
+        return this;
+    }
+    /**
+     * Define a GET route
+     */
+    get(path, ...args) {
+        const action = args.pop();
+        const middlewares = args;
+        return this._addRoute("get", path, action, middlewares);
+    }
+    /**
+     * Define a POST route
+     */
+    post(path, ...args) {
+        const action = args.pop();
+        const middlewares = args;
+        return this._addRoute("post", path, action, middlewares);
+    }
+    /**
+     * Define a PUT route
+     */
+    put(path, ...args) {
+        const action = args.pop();
+        const middlewares = args;
+        return this._addRoute("put", path, action, middlewares);
+    }
+    /**
+     * Define a DELETE route
+     */
+    delete(path, ...args) {
+        const action = args.pop();
+        const middlewares = args;
+        return this._addRoute("delete", path, action, middlewares);
+    }
+    /**
+     * Define a PATCH route
+     */
+    patch(path, ...args) {
+        const action = args.pop();
+        const middlewares = args;
+        return this._addRoute("patch", path, action, middlewares);
+    }
+    /**
+     * Define an OPTIONS route
+     */
+    options(path, ...args) {
+        const action = args.pop();
+        const middlewares = args;
+        return this._addRoute("options", path, action, middlewares);
+    }
+    /**
+     * Get the underlying Express router
+     */
+    getRouter() {
+        return this.router;
+    }
+    /**
+     * Mount this router to an Express app or router
+     */
+    mount(app, basePath = "/") {
+        app.use(basePath, this.router);
+    }
+    /**
+     * Clone the current router instance
+     */
+    _clone() {
+        const newRouter = new Router();
+        newRouter.router = this.router;
+        newRouter.middlewareStack = [...this.middlewareStack];
+        newRouter.prefixStack = [...this.prefixStack];
+        return newRouter;
+    }
+    /**
+     * Add a route to the router
+     */
+    _addRoute(method, path, action, routeMiddlewares = []) {
+        const fullPath = this._buildPath(path);
+        const handler = this._buildHandler(action);
+        const flatMiddlewares = routeMiddlewares.flat(Infinity);
+        const middlewares = [...this.middlewareStack, ...flatMiddlewares, handler];
+        this.router[method](fullPath, ...middlewares);
+        return this;
+    }
+    /**
+     * Build the full path with prefixes
+     */
+    _buildPath(path) {
+        const cleanPath = path.replace(/^\//, "");
+        const prefixes = this.prefixStack.filter((p) => p !== "");
+        if (prefixes.length === 0) {
+            return `/${cleanPath}`;
+        }
+        return `/${prefixes.join("/")}/${cleanPath}`.replace(/\/+/g, "/");
+    }
+    /**
+     * Build the route handler
+     */
+    _buildHandler(action) {
+        if (typeof action === "function") {
+            return action;
+        }
+        if (Array.isArray(action) && action.length === 2) {
+            const [controller, method] = action;
+            return ControllerBinder_1.default.handle(controller, method);
+        }
+        throw new Error('Action must be a function or array [Controller, "method"]');
+    }
+}
+exports.Router = Router;
+/**
+ * Static Route class for Laravel-like syntax
+ */
+class Route {
+    static create() {
+        return Router.create();
+    }
+    static middleware(...middleware) {
+        return this._router.middleware(...middleware);
+    }
+    static prefix(prefix) {
+        return this._router.prefix(prefix);
+    }
+    static group(callback) {
+        return this._router.group(callback);
+    }
+    static get(path, ...args) {
+        return this._router.get(path, ...args);
+    }
+    static post(path, ...args) {
+        return this._router.post(path, ...args);
+    }
+    static put(path, ...args) {
+        return this._router.put(path, ...args);
+    }
+    static delete(path, ...args) {
+        return this._router.delete(path, ...args);
+    }
+    static patch(path, ...args) {
+        return this._router.patch(path, ...args);
+    }
+    static options(path, ...args) {
+        return this._router.options(path, ...args);
+    }
+    static getRouter() {
+        return this._router.getRouter();
+    }
+    static mount(app, basePath = "/") {
+        return this._router.mount(app, basePath);
+    }
+    static reset() {
+        this._router = new Router();
+    }
+}
+exports.Route = Route;
+Route._router = new Router();
+exports.default = Route;

package/lib/server.d.ts

@@ -0,0 +1,6 @@
+export * from "./server/ArcanaJSMiddleware";
+export * from "./server/ArcanaJSServer";
+export { default as ControllerBinder } from "./server/ControllerBinder";
+export * from "./server/DynamicRouter";
+export * from "./server/Router";
+export { default as Route } from "./server/Router";

package/lib/server.js

@@ -0,0 +1,28 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Route = exports.ControllerBinder = void 0;
+__exportStar(require("./server/ArcanaJSMiddleware"), exports);
+__exportStar(require("./server/ArcanaJSServer"), exports);
+var ControllerBinder_1 = require("./server/ControllerBinder");
+Object.defineProperty(exports, "ControllerBinder", { enumerable: true, get: function () { return __importDefault(ControllerBinder_1).default; } });
+__exportStar(require("./server/DynamicRouter"), exports);
+__exportStar(require("./server/Router"), exports);
+var Router_1 = require("./server/Router");
+Object.defineProperty(exports, "Route", { enumerable: true, get: function () { return __importDefault(Router_1).default; } });

package/lib/shared/ArcanaJSApp.d.ts

@@ -0,0 +1,11 @@
+import React from "react";
+export interface ArcanaJSAppProps {
+    initialPage: string;
+    initialData: any;
+    initialUrl?: string;
+    views: Record<string, React.FC<any>>;
+    layout?: React.FC<{
+        children: React.ReactNode;
+    }>;
+}
+export declare const ArcanaJSApp: React.FC<ArcanaJSAppProps>;

package/lib/shared/ArcanaJSApp.js

@@ -0,0 +1,79 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArcanaJSApp = void 0;
+const react_1 = __importStar(require("react"));
+const Page_1 = require("./components/Page");
+const RouterContext_1 = require("./context/RouterContext");
+const ArcanaJSApp = ({ initialPage, initialData, initialUrl, views, layout: Layout, }) => {
+    const [page, setPage] = (0, react_1.useState)(initialPage);
+    const [data, setData] = (0, react_1.useState)(initialData);
+    const [url, setUrl] = (0, react_1.useState)(initialUrl ||
+        (typeof window !== "undefined" ? window.location.pathname : "/"));
+    (0, react_1.useEffect)(() => {
+        const handlePopState = (event) => {
+            if (event.state) {
+                setPage(event.state.page);
+                setData(event.state.data);
+                setUrl(window.location.pathname);
+            }
+        };
+        window.addEventListener("popstate", handlePopState);
+        return () => window.removeEventListener("popstate", handlePopState);
+    }, []);
+    const navigateTo = async (newUrl) => {
+        try {
+            const response = await fetch(newUrl, {
+                headers: { "x-arcanajs-request": "true" },
+            });
+            const json = await response.json();
+            setPage(json.page);
+            setData(json.data);
+            setUrl(newUrl);
+            window.history.pushState({ page: json.page, data: json.data }, "", newUrl);
+        }
+        catch (error) {
+            console.error("Navigation failed", error);
+        }
+    };
+    const renderPage = () => {
+        const Component = views[page] || views["NotFoundPage"] || (() => react_1.default.createElement("div", null, "404 Not Found"));
+        return (react_1.default.createElement(Page_1.Page, { data: data },
+            react_1.default.createElement(Component, { data: data, navigateTo: navigateTo })));
+    };
+    const content = renderPage();
+    return (react_1.default.createElement(RouterContext_1.RouterProvider, { value: { navigateTo, currentPage: page, currentUrl: url, params: {} } }, Layout ? react_1.default.createElement(Layout, null, content) : react_1.default.createElement(react_1.default.Fragment, null, content)));
+};
+exports.ArcanaJSApp = ArcanaJSApp;

package/lib/shared/components/Body.d.ts

@@ -0,0 +1,6 @@
+import React from "react";
+interface BodyProps {
+    children: React.ReactNode;
+}
+export declare const Body: React.FC<BodyProps>;
+export {};

package/lib/shared/components/Body.js

@@ -0,0 +1,11 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Body = void 0;
+const react_1 = __importDefault(require("react"));
+const Body = ({ children }) => {
+    return react_1.default.createElement(react_1.default.Fragment, null, children);
+};
+exports.Body = Body;

package/lib/shared/components/Head.d.ts

@@ -0,0 +1,4 @@
+import React from "react";
+export declare const Head: React.FC<{
+    children: React.ReactNode;
+}>;

package/lib/shared/components/Head.js

@@ -0,0 +1,125 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Head = void 0;
+const react_1 = __importStar(require("react"));
+const useHead_1 = require("../hooks/useHead");
+const Head = ({ children }) => {
+    const headManager = (0, useHead_1.useHead)();
+    // Server-side: Push tags to context
+    if (typeof window === "undefined" && headManager) {
+        react_1.default.Children.forEach(children, (child) => {
+            if (react_1.default.isValidElement(child)) {
+                headManager.push(react_1.default.cloneElement(child, {
+                    "data-arcanajs-head": "true",
+                }));
+            }
+        });
+    }
+    // Client-side: Update DOM
+    (0, react_1.useEffect)(() => {
+        const managedElements = [];
+        react_1.default.Children.forEach(children, (child) => {
+            if (react_1.default.isValidElement(child)) {
+                const reactElement = child;
+                if (reactElement.type === "title") {
+                    document.title = reactElement.props.children;
+                }
+                else if (reactElement.type === "meta") {
+                    const props = reactElement.props;
+                    // Try to find existing meta tag
+                    let selector = "meta";
+                    if (props.name)
+                        selector += `[name="${props.name}"]`;
+                    if (props.property)
+                        selector += `[property="${props.property}"]`;
+                    // Only select if we have a specific identifier
+                    if (props.name || props.property) {
+                        let element = document.querySelector(selector + '[data-arcanajs-head="true"]') || document.querySelector(selector);
+                        if (element) {
+                            // Update existing
+                            element.setAttribute("content", props.content);
+                            element.setAttribute("data-arcanajs-head", "true");
+                            managedElements.push(element);
+                        }
+                        else {
+                            // Create new
+                            const newMeta = document.createElement("meta");
+                            Object.keys(props).forEach((key) => {
+                                newMeta.setAttribute(key, props[key]);
+                            });
+                            newMeta.setAttribute("data-arcanajs-head", "true");
+                            document.head.appendChild(newMeta);
+                            managedElements.push(newMeta);
+                        }
+                    }
+                }
+                else if (reactElement.type === "link") {
+                    const props = reactElement.props;
+                    let selector = "link";
+                    if (props.rel)
+                        selector += `[rel="${props.rel}"]`;
+                    if (props.href)
+                        selector += `[href="${props.href}"]`;
+                    let element = document.querySelector(selector + '[data-arcanajs-head="true"]') ||
+                        document.querySelector(selector);
+                    if (element) {
+                        element.setAttribute("data-arcanajs-head", "true");
+                        managedElements.push(element);
+                    }
+                    else {
+                        const newLink = document.createElement("link");
+                        Object.keys(props).forEach((key) => {
+                            newLink.setAttribute(key, props[key]);
+                        });
+                        newLink.setAttribute("data-arcanajs-head", "true");
+                        document.head.appendChild(newLink);
+                        managedElements.push(newLink);
+                    }
+                }
+            }
+        });
+        return () => {
+            // Cleanup managed elements
+            managedElements.forEach((el) => {
+                // We remove the element to ensure clean state for the next page
+                // Note: This might cause a momentary flicker if the next page re-adds it immediately
+                el.remove();
+            });
+        };
+    }, [children]);
+    return null;
+};
+exports.Head = Head;

package/lib/shared/components/Link.d.ts

@@ -0,0 +1,6 @@
+import React from "react";
+interface LinkProps extends React.AnchorHTMLAttributes<HTMLAnchorElement> {
+    href: string;
+}
+export declare const Link: React.FC<LinkProps>;
+export {};

package/lib/shared/components/Link.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Link = void 0;
+const react_1 = __importDefault(require("react"));
+const useRouter_1 = require("../hooks/useRouter");
+const Link = ({ href, children, ...props }) => {
+    const { navigateTo } = (0, useRouter_1.useRouter)();
+    const handleClick = (e) => {
+        e.preventDefault();
+        navigateTo(href);
+    };
+    return (react_1.default.createElement("a", { href: href, onClick: handleClick, ...props }, children));
+};
+exports.Link = Link;

package/lib/shared/components/NavLink.d.ts

@@ -0,0 +1,8 @@
+import React from "react";
+interface NavLinkProps extends React.AnchorHTMLAttributes<HTMLAnchorElement> {
+    href: string;
+    activeClassName?: string;
+    exact?: boolean;
+}
+export declare const NavLink: React.FC<NavLinkProps>;
+export {};