miqro 7.0.1 → 7.0.3

package/build/esm/editor/auth.d.ts

@@ -0,0 +1,6 @@
+import { AuthConfig } from "../src/types.js";
+export declare const ADMIN_EDITOR_AUTH_KEY = "$$ADMIN_EDITOR_AUTH_KEY$$";
+export declare const ADMIN_EDITOR_AUTH_QUERY = "key";
+export declare const ADMIN_EDITOR_AUTH_COOKIE = "$$ADMIN_EDITOR_AUTH_KEY$$";
+declare const _default: AuthConfig;
+export default _default;

package/build/esm/editor/auth.js

@@ -0,0 +1,41 @@
+export const ADMIN_EDITOR_AUTH_KEY = "$$ADMIN_EDITOR_AUTH_KEY$$";
+export const ADMIN_EDITOR_AUTH_QUERY = "key";
+export const ADMIN_EDITOR_AUTH_COOKIE = ADMIN_EDITOR_AUTH_KEY;
+export default {
+    authService: {
+        verify: async (args) => {
+            const adminInterface = args.req.editor;
+            const serverInterface = args.req.server;
+            const KEY = (adminInterface ? adminInterface.getCache() : serverInterface.cache).get(ADMIN_EDITOR_AUTH_KEY);
+            const validSesson = {
+                username: "username",
+                account: "account",
+                groups: [],
+                token: args.token
+            };
+            const queryToken = args.req.query[ADMIN_EDITOR_AUTH_QUERY];
+            const cookieToken = args.req.cookies[ADMIN_EDITOR_AUTH_COOKIE];
+            //console.log("\n\nqueryToken[%s] cookieToken[%s] KEY[%s]\n\n", queryToken, cookieToken, KEY);
+            if (queryToken) {
+                if (queryToken === KEY) {
+                    args.res.setCookie(ADMIN_EDITOR_AUTH_COOKIE, KEY, {
+                        expires: new Date(Date.now() + 1000 * 60 * 60 * 24 * 31 * 12 * 500),
+                        httpOnly: true,
+                        //secure: true,
+                        path: "/",
+                        //sameSite: "strict"
+                    });
+                    args.req.searchParams.delete(ADMIN_EDITOR_AUTH_QUERY);
+                    const queryString = args.req.searchParams.toString();
+                    const redirect = args.req.path + (queryString ? "?" + queryString : "");
+                    await args.res.redirect(redirect);
+                    return validSesson;
+                }
+            }
+            else if (cookieToken) {
+                return cookieToken === KEY ? validSesson : null;
+            }
+            return null;
+        },
+    }
+};

package/build/esm/editor/common/admin-interface.d.ts

@@ -0,0 +1,36 @@
+import { RouterHandlerOptions } from "@miqro/core";
+import { CacheInterface, ServerRequest } from "../../src/types.js";
+import { MigrationModule } from "../../src/inflate/setup-db.js";
+export interface EditorAdminInterface {
+    getCache: () => CacheInterface;
+    getMigrations(): MigrationModule[];
+    stop: () => Promise<void>;
+    reload: () => Promise<null | {
+        filePath: string;
+        error: Error;
+    }[]>;
+    restart: () => Promise<null | {
+        filePath: string;
+        error: Error;
+    }[]>;
+    getHotReloadHTML(): string;
+    getInflateErrors(): null | {
+        filePath: string;
+        error: Error;
+    }[];
+    getServices(): string[];
+    getRouteFileMap(): {
+        [filePath: string]: {
+            routes: {
+                path?: string;
+                method?: string | null;
+                options?: RouterHandlerOptions;
+                inflatePath?: string;
+            }[];
+            previewMethod: "api" | "html" | null;
+        };
+    };
+}
+export interface AdminRequest extends ServerRequest {
+    editor?: EditorAdminInterface;
+}

package/build/esm/editor/common/admin-interface.js

@@ -0,0 +1,44 @@
+export {};
+/*let currentAdminInterface: EditorAdminInterface | null = null;
+function createFakeAdminInterface(server: any): EditorAdminInterface {
+  return {
+    getCache: () => {
+      return server.cache;
+    },
+    stop: async () => {
+
+    },
+    restart: async () => {
+      return null;
+    },
+    reload: async () => {
+      return null;
+    },
+    getHotReloadHTML: () => {
+      return "";
+    },
+    getMigrations: () => {
+      return [];
+    },
+    getServices: () => {
+      return ["."];
+    },
+    getRouteFileMap: () => {
+      return {};
+    },
+    getInflateErrors: () => {
+      return [];
+    },
+    inflateJSX: async function inflateJSX(path, minify: boolean = true) {
+      return "";
+    }
+  }
+}
+
+export function getEditorAdmin(server): EditorAdminInterface {
+  return currentAdminInterface ? currentAdminInterface : createFakeAdminInterface(server);
+}
+
+export function setEditorAdmin(admin: EditorAdminInterface): void {
+  currentAdminInterface = admin;
+}*/

package/build/esm/editor/common/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const BASEEDITOR_PATH = "/admin/editor";
+export declare const LOG_SOCKET_PATH = "/admin/socket";
+export declare const LOG_WRITE_EVENT = "LogWrite";
+export declare const SUPPORTED_LANGUAGES: string[];

package/build/esm/editor/common/constants.js

@@ -0,0 +1,20 @@
+export const BASEEDITOR_PATH = "/admin/editor";
+export const LOG_SOCKET_PATH = "/admin/socket";
+export const LOG_WRITE_EVENT = "LogWrite";
+export const SUPPORTED_LANGUAGES = [
+    "text",
+    "json",
+    "javascript",
+    "typescript",
+    "dockerfile",
+    "yaml",
+    "xml",
+    "html",
+    "css",
+    "scss",
+    "markdown",
+    "c",
+    "cpp",
+    "bash",
+    "python"
+];

package/build/esm/editor/common/constants.server.d.ts

@@ -0,0 +1,2 @@
+export declare const PORT: string;
+export declare const BASE_PATH: string;

package/build/esm/editor/common/constants.server.js

@@ -0,0 +1,4 @@
+import { resolve } from "node:path";
+import { cwd } from "node:process";
+export const PORT = process.env["PORT"] ? process.env["PORT"] : "8080";
+export const BASE_PATH = resolve(cwd());

package/build/esm/editor/common/editor-index.d.ts

@@ -0,0 +1,2 @@
+import { AdminRequest } from "./admin-interface.js";
+export declare function EditorIndex(editorCSS: string, editorJS: string, enableHotReload: boolean): (req: AdminRequest, res: any) => Promise<void>;

package/build/esm/editor/common/editor-index.js

@@ -0,0 +1,14 @@
+import { scanDir } from "../http/admin/editor/api/fs/scan.api.js";
+import { parseInflateErrors } from "../http/admin/editor/api/server/restart.api.js";
+import { HTMLEncode } from "./html-encode.js";
+export function EditorIndex(editorCSS, editorJS, enableHotReload) {
+    return async function editorIndex(req, res) {
+        const admin = req.editor;
+        const errors = parseInflateErrors(admin ? admin.getInflateErrors() : []);
+        const files = scanDir(req);
+        const migrations = admin ? admin.getMigrations().map(m => m.name) : [];
+        const services = admin ? admin.getServices() : ["."];
+        const hotReload = enableHotReload ? (admin ? admin.getHotReloadHTML() : "") : "";
+        res.html(`<!DOCTYPE html><html><body><style>${editorCSS}</style><script type="module">${editorJS}</script><editor-component class="main-container" reloadstring="${req.uuid}" migrations="${HTMLEncode(JSON.stringify(migrations))}" services="${HTMLEncode(JSON.stringify(services))}" errors="${HTMLEncode(JSON.stringify(errors))}" files="${HTMLEncode(JSON.stringify(files))}"><noscript>Enable JavaScript</noscript></editor-component>${hotReload}</body></html>`);
+    };
+}

package/build/esm/editor/common/html-encode.d.ts

@@ -0,0 +1 @@
+export declare function HTMLEncode(str: string): string;

package/build/esm/editor/common/html-encode.js

@@ -0,0 +1,14 @@
+export function HTMLEncode(str) {
+    let i = str.length;
+    const aRet = [];
+    while (i--) {
+        const iC = str[i].charCodeAt(0);
+        if (iC < 65 || iC > 127 || (iC > 90 && iC < 97)) {
+            aRet[i] = '&#' + iC + ';';
+        }
+        else {
+            aRet[i] = str[i];
+        }
+    }
+    return aRet.join('');
+}

package/build/esm/editor/common/log-socket.d.ts

@@ -0,0 +1,15 @@
+interface LogLine {
+    out: string;
+    identifier: string;
+    level: "error" | "warn" | "debug" | "trace" | "info";
+}
+export interface LogSocket {
+    lines: LogLine[];
+    clearLog: () => void;
+    getMaxlogsize: () => number | "unlimited";
+    setMaxLogSize: (val: number | "unlimited") => void;
+}
+export declare function useLogSocket(options: {
+    disableLog?: boolean;
+}): LogSocket;
+export {};

package/build/esm/editor/common/log-socket.js

@@ -0,0 +1,71 @@
+import * as jsx from "@miqro/jsx";
+export function useLogSocket(options) {
+    const [_, setmaxLogSize, getMaxlogsize] = jsx.useState(1000000);
+    const [__, setlines, getLines] = jsx.useState([]);
+    const refresh = jsx.useRefresh();
+    jsx.useEffect(() => {
+        let timeout;
+        function setupSocket() {
+            try {
+                if (options.disableLog) {
+                    return;
+                }
+                console.log("setting up log socket");
+                const socket = new WebSocket("/admin/socket");
+                socket.addEventListener("error", (err) => {
+                    console.error(err);
+                    clearTimeout(timeout);
+                    timeout = setTimeout(() => {
+                        setupSocket();
+                    }, 1000);
+                });
+                socket.addEventListener("open", () => {
+                    console.log("log socket open");
+                    clearTimeout(timeout);
+                    socket.addEventListener("message", (msg) => {
+                        const lines = getLines();
+                        const data = JSON.parse(msg.data);
+                        //console.log(data.out);
+                        const maxLogSize = getMaxlogsize();
+                        if (maxLogSize !== "unlimited" && lines.length >= maxLogSize) {
+                            lines.splice(0, (lines.length - maxLogSize) + 1);
+                        }
+                        lines.push(data);
+                        setlines(lines);
+                        refresh();
+                    });
+                });
+                socket.addEventListener("close", () => {
+                    console.log("log socket close");
+                    clearTimeout(timeout);
+                    timeout = setTimeout(() => {
+                        setupSocket();
+                    }, 1000);
+                });
+            }
+            catch (e) {
+                console.error(e);
+                clearTimeout(timeout);
+                timeout = setTimeout(() => {
+                    setupSocket();
+                }, 1000);
+            }
+        }
+        setupSocket();
+    }, []);
+    return {
+        lines: getLines(),
+        clearLog: () => {
+            setlines([]);
+        },
+        getMaxlogsize,
+        setMaxLogSize: (newValue) => {
+            if (newValue === "unlimited") {
+                setmaxLogSize(newValue);
+            }
+            else {
+                setmaxLogSize(newValue);
+            }
+        }
+    };
+}

package/build/esm/editor/common/templates.d.ts

@@ -0,0 +1,11 @@
+export declare const TEMPLATES: {
+    [name: string]: {
+        displayName: string;
+        template?: ((filename: string, httpPath: string) => string);
+        httpSufix?: string;
+        sufix?: string;
+        prefix?: string;
+        language: string;
+        filename?: string;
+    };
+};