elegance-js 2.1.23 → 2.1.26

package/dist/server/log.js

@@ -0,0 +1,64 @@
+import util from "node:util";
+var LogLevel;
+(function (LogLevel) {
+    LogLevel[LogLevel["NONE"] = 0] = "NONE";
+    LogLevel[LogLevel["ERROR"] = 1] = "ERROR";
+    LogLevel[LogLevel["WARN"] = 2] = "WARN";
+    LogLevel[LogLevel["INFO"] = 3] = "INFO";
+    LogLevel[LogLevel["DEBUG"] = 4] = "DEBUG";
+})(LogLevel || (LogLevel = {}));
+let logLevel = LogLevel.INFO;
+function setLogLevel(level) {
+    logLevel = level;
+}
+function formatToLog(level, ...args) {
+    if (level === LogLevel.NONE) {
+        throw new Error("Can't log with LogLevel none.");
+    }
+    let tag;
+    let tagColor;
+    let msgColor;
+    switch (level) {
+        case LogLevel.ERROR:
+            tag = "[ERROR]";
+            tagColor = "\x1b[41;30m"; // red bg, black text
+            msgColor = "\x1b[31m"; // red text
+            break;
+        case LogLevel.WARN:
+            tag = "[WARN]";
+            tagColor = "\x1b[43;30m"; // yellow bg, black text
+            msgColor = "\x1b[33m"; // yellow text
+            break;
+        case LogLevel.INFO:
+            tag = "[INFO]";
+            tagColor = "\x1b[44;37m"; // blue bg, white text
+            msgColor = "\x1b[36m"; // cyan text
+            break;
+        case LogLevel.DEBUG:
+            tag = "[DEBUG]";
+            tagColor = "\x1b[45;37m"; // magenta bg, white text
+            msgColor = "\x1b[90m"; // gray text
+            break;
+    }
+    const ts = new Date().toLocaleTimeString("en-us");
+    const formattedArgs = [
+        `${ts} Elegance-JS `,
+        `${tagColor}${tag}\x1b[0m `,
+        msgColor,
+        ...args,
+        "\x1b[0m"
+    ];
+    return formattedArgs.map(arg => {
+        if (typeof arg === "string")
+            return arg;
+        return util.inspect(arg, { colors: false, depth: null });
+    }).join('');
+}
+function formattedLog(level, ...args) {
+    if (level > logLevel) {
+        return;
+    }
+    const str = formatToLog(level, ...args);
+    console.log(str);
+}
+export { formattedLog, setLogLevel, LogLevel, logLevel, formatToLog, };

package/dist/server/page.d.ts

@@ -0,0 +1,32 @@
+import { CompilerOptions } from "../compilation/compiler";
+import { AnyElement } from "../elements/element";
+import { LayoutInformation } from "./layout";
+type PageParams = Record<any, unknown>;
+type PageConstructor = ((params: PageParams) => AnyElement) | ((params: PageParams) => Promise<AnyElement>);
+type PageMetadataConstructor = ((params: PageParams) => AnyElement) | ((params: PageParams) => Promise<AnyElement>);
+/**
+ * Described the formatted supported exports of a given page.
+ */
+type PageExports = {
+    isDynamic: boolean;
+    pageConstructor: PageConstructor;
+    pageMetadataConstructor: PageMetadataConstructor;
+    enumerateRoutes: (() => string[]) | null;
+};
+/**
+ * Holds information about a given user-defined page within the project.
+ */
+type PageInformation = {
+    /** The absolute path to the .ts file containing the module for this page. */
+    modulePath: string;
+    /** The pathname of this page relative to pagesDirectory */
+    pathname: string;
+    exports: PageExports;
+    /** This is just the result of pathname.split("/") */
+    pathnameParts: string[];
+    /** An in-order list of the layouts that apply to this page. */
+    applicableLayouts: LayoutInformation[];
+};
+declare function invalidPageError(compilerOptions: CompilerOptions, modulePath: string, reason: string): Error;
+export { invalidPageError, };
+export type { PageInformation, PageExports, PageParams, PageConstructor, PageMetadataConstructor, };

package/dist/server/page.js

@@ -0,0 +1,6 @@
+import { relative } from "path";
+function invalidPageError(compilerOptions, modulePath, reason) {
+    const relativePath = relative(compilerOptions.pagesDirectory, modulePath);
+    return new Error(`The page at path: "${relativePath}" is invalid.\n${reason}`);
+}
+export { invalidPageError, };

package/dist/server/runtime.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Run the elegance runtime, and if hot-reloading is enabled, will start the hot-reload server.
+ * @param file The runtime file to execute.
+ */
+declare function startEleganceRuntime(file: string): void;
+export { startEleganceRuntime, };

package/dist/server/runtime.js

@@ -0,0 +1,72 @@
+import { spawn } from "child_process";
+import { resolve } from "path";
+import { formattedLog, LogLevel } from "./log.js";
+import { createServer } from "http";
+let child;
+let childPath;
+const clients = new Set();
+let server;
+let serverIsActive = false;
+/**
+ * Run the elegance runtime, and if hot-reloading is enabled, will start the hot-reload server.
+ * @param file The runtime file to execute.
+ */
+function startEleganceRuntime(file) {
+    formattedLog(LogLevel.INFO, "Starting Elegance..");
+    childPath = resolve(file);
+    server = createServer((req, res) => {
+        formattedLog(LogLevel.DEBUG, "Received hot-reload listener.");
+        if (req.url === "/elegance-hot-reload") {
+            res.writeHead(200, {
+                "Content-Type": "text/event-stream",
+                "Cache-Control": "no-cache",
+                "Connection": "keep-alive",
+                "Access-Control-Allow-Origin": "*"
+            });
+            res.write(":ok\n\n");
+            clients.add(res);
+            req.on("close", () => {
+                clients.delete(res);
+            });
+            return;
+        }
+        res.writeHead(404);
+        res.end();
+    });
+    restartEleganceRuntime();
+}
+function restartEleganceRuntime() {
+    if (child && child.killed === false) {
+        child.kill();
+    }
+    child = spawn("node", ["--import", "ts-arc/register", childPath], {
+        stdio: ['inherit', 'inherit', 'inherit', 'ipc'],
+        env: { ...process.env }
+    });
+    child.on("message", (content) => {
+        if (content === "restart-me") {
+            formattedLog(LogLevel.INFO, "Rebuilding..");
+            restartEleganceRuntime();
+        }
+        if (content === "hot-reload-finish") {
+            if (!serverIsActive) {
+                serverIsActive = true;
+                server.listen(4000, () => {
+                    formattedLog(LogLevel.INFO, "Hot-reload server listening on port 4000");
+                });
+            }
+            for (const client of clients) {
+                client.write("data: hot-reload\n\n");
+            }
+        }
+        if (content === "enable-hot-reload") {
+        }
+        if (content === "disable-hot-reload") {
+            if (!serverIsActive)
+                return;
+            serverIsActive = false;
+            server.close();
+        }
+    });
+}
+export { startEleganceRuntime, };

package/dist/server/server.d.ts

@@ -1,11 +1,103 @@
-import { IncomingMessage, ServerResponse } from 'http';
-interface ServerOptions {
-    root: string;
-    pagesDirectory: string;
-    port?: number;
-    host?: string;
-    environment?: 'production' | 'development';
-    DIST_DIR: string;
-}
-export declare function startServer({ root, pagesDirectory, port, host, environment, DIST_DIR }: ServerOptions): import("http").Server<typeof IncomingMessage, typeof ServerResponse>;
-export {};
+/**
+ * The Elegance.JS server.
+ * This server can be used to run your project.
+ *
+ * It's HTTP only, so if you want HTTPS, use a proxy.
+ */
+import { CompiledLayout, CompiledPage } from "../compilation/compiler";
+import { LayoutInformation } from "./layout";
+import { PageInformation } from "./page";
+import { IncomingMessage, ServerResponse } from "http";
+import { URLSearchParams } from "url";
+type ServerOptions = {
+    /** If a port is not available, it will increment the port +1 in a loop until it finds a valid one. */
+    port: number;
+    hostname: string;
+    /** Whether or not to use the built-in api handler. */
+    serveAPI: boolean;
+    /**
+     * Setting this to true allows dynamic pages to be compiled whenever a user requests them.
+     */
+    allowDynamic: boolean;
+    /**
+     * Setting this to true will make statuscode pages like 404.ts be returned in-favor of simple HTTP error codes.
+     */
+    allowStatusCodePages: boolean;
+    /**
+     * If basename is /my-website/, and the user makes a request to `/my-website/home`,
+     * the page that we will look for will be `/home`.
+     */
+    base?: string;
+    /** These are gathered by the compiler, you just need to pass them in. */
+    allLayouts: Map<string, LayoutInformation>;
+    /** These are gathered by the compiler, you just need to pass them in. */
+    allPages: Map<string, PageInformation>;
+    /** These are gathered by the compiler, you just need to pass them in. */
+    allStatusCodePages: Map<string, PageInformation>;
+    /** These are gathered by the compiler, you just need to pass them in. */
+    builtStaticPages: Map<string, CompiledPage>;
+    /** These are gathered by the compiler, you just need to pass them in. */
+    builtStaticLayouts: Map<string, CompiledLayout>;
+};
+type ServerStartupResult = {
+    /** The port that we ended up actually using (might differ from the one given, if it was not available) */
+    port: number;
+};
+/**
+ * Starts the Elegance server and distributes the DIST directory to the public.
+ * If hot-reloading is enabled, this also tells the clients to refresh the page.
+ */
+declare function serveProject(startupServerOptions: ServerOptions): Promise<ServerStartupResult>;
+/** Get the current query as `URLSearchParams` */
+declare function getQuery(): URLSearchParams;
+/** Get the current page's request and response. */
+declare function getRequest(): {
+    req: IncomingMessage;
+    res: ServerResponse;
+};
+/**
+ * Get the cookies for the current request.
+ * Requires a dynamic page.
+ */
+declare function getCookieStore(): {
+    /**
+     * Get a cookie value by name
+     */
+    get(name: string): string | undefined;
+    /**
+     * Check if a cookie exists
+     */
+    has(name: string): boolean;
+    /**
+     * Get all cookies as a plain object
+     */
+    getAll(): Record<string, string>;
+    /**
+     * Set a cookie
+     *
+     * @param name Cookie name
+     * @param value Cookie value
+     * @param options Optional cookie attributes
+     */
+    set(name: string, value: string, options?: {
+        maxAge?: number;
+        expires?: Date;
+        path?: string;
+        domain?: string;
+        secure?: boolean;
+        httpOnly?: boolean;
+        sameSite?: "Strict" | "Lax" | "None";
+    }): void;
+    /**
+     * Delete a cookie (sets it to expire immediately)
+     */
+    delete(name: string, path?: string, domain?: string): void;
+};
+declare function redirect(location: string, statusCode?: number): void;
+declare const respondWith: {
+    notFound(): Promise<void>;
+    notAuthorized(): Promise<void>;
+    forbidden(): Promise<void>;
+    internalError(): Promise<void>;
+};
+export { serveProject, getQuery, getRequest, getCookieStore, redirect, respondWith };