@vandenberghinc/volt 1.1.2

package/backend/src/volt.js

@@ -0,0 +1,25 @@
+/*
+ * Author: Daan van den Bergh
+ * Copyright: © 2022 - 2024 Daan van den Bergh.
+ */
+
+// ---------------------------------------------------------
+// Exports.
+
+// Create volt lib.
+export { FrontendError, APIError } from "./utils.js"
+export * from "./status.js"
+export * from "./meta.js"
+export * from "./splash_screen.js"
+export * from "./view.js"
+export * from "./stream.js"
+export * from "./endpoint.js"
+export * from "./server.js"
+export * from "./database.js"
+export * from "./rate_limit.js"
+export * from "./logger.js"
+export * from "./file_watcher.js"
+export * as Mail from "./plugins/mail.js"
+// export * as PDF from "./plugins/pdf.js"
+export * as TypeScript from "./plugins/ts/compiler.js"
+export * from "./frontend.js"

package/backend/tsconfig.cjs.json

@@ -0,0 +1,29 @@
+{
+    "compilerOptions": {
+        "target": "es2023",
+        "module": "CommonJS",
+        "lib": [
+            "es2021"
+        ],
+        "declaration": true,
+        "declarationDir": "./dist/cjs",
+        "outDir": "./dist/cjs",
+        "rootDir": "./src/",
+        "strict": true,
+        "esModuleInterop": true,
+        "skipLibCheck": true,
+        "allowJs": true,
+        "checkJs": false,
+        "noImplicitAny": false,
+        "baseUrl": ".",
+        "paths": {
+            "@vinc": ["./src/vinc.js"],
+            "@vlib": [ "/Users/administrator/persistance/private/dev/vinc/vlib/js/dist/esm/vlib.js", ],
+            "@vhighlight": [ "/Users/administrator/persistance/private/dev/vinc/vhighlight/dist/esm/vhighlight.js", ],
+        },
+        "types": ["./src/globals.d.ts"],
+    },
+    "include": [
+        "./src/**/*",
+    ],
+}

package/backend/tsconfig.esm.dev.json

@@ -0,0 +1,34 @@
+{
+    "compilerOptions": {
+        "target": "es2023",
+        "module": "NodeNext",
+        "moduleResolution": "NodeNext",
+        "lib": [
+            "es2021"
+        ],
+        "declaration": true,
+        "declarationDir": "./dist/esm-dev",
+        "outDir": "./dist/esm-dev",
+        "rootDir": "./src/",
+        "strict": true,
+        "esModuleInterop": true,
+        "skipLibCheck": true,
+        "allowJs": true,
+        "checkJs": false,
+        "noImplicitAny": false,
+        "baseUrl": "./",
+        "paths": {
+            "@vinc": ["./src/vinc.dev.js"],
+            "@vlib": [ "/Users/administrator/persistance/private/dev/vinc/vlib/js/dist/esm/vlib.js", ],
+            "@vhighlight": [ "/Users/administrator/persistance/private/dev/vinc/vhighlight/dist/esm/vhighlight.js", ],
+        },
+        "types": ["./src/globals.d.ts"],
+    },
+    "include": [
+        "./src/**/*",
+    ],
+    "exclude": [
+        "/Users/administrator/persistance/private/dev/vinc/vlib/js/dist/esm/vlib.js",
+        "/Users/administrator/persistance/private/dev/vinc/vhighlight/dist/esm/vhighlight.js",
+    ]
+}

package/backend/tsconfig.esm.json

@@ -0,0 +1,30 @@
+{
+    "compilerOptions": {
+        "target": "es2023",
+        "module": "NodeNext",
+        "moduleResolution": "NodeNext",
+        "lib": [
+            "es2021"
+        ],
+        "declaration": true,
+        "declarationDir": "./dist/esm",
+        "outDir": "./dist/esm",
+        "rootDir": "./src/",
+        "strict": true,
+        "esModuleInterop": true,
+        "skipLibCheck": true,
+        "allowJs": true,
+        "checkJs": false,
+        "noImplicitAny": false,
+        "baseUrl": ".",
+        "paths": {
+            "@vinc": ["./src/vinc.js"],
+            "@vlib": [ "/Users/administrator/persistance/private/dev/vinc/vlib/js/dist/esm/vlib.js", ],
+            "@vhighlight": [ "/Users/administrator/persistance/private/dev/vinc/vhighlight/dist/esm/vhighlight.js", ],
+        },
+        "types": ["./src/globals.d.ts"],
+    },
+    "include": [
+        "./src/**/*",
+    ]
+}

package/backend/tsconfig.json

@@ -0,0 +1,2 @@
+/* Purely for VScode */
+{ "extends": "./tsconfig.esm.json" }

package/frontend/compile.js

@@ -0,0 +1,436 @@
+
+import process from 'node:process';
+
+// const typescript = require("../backend/dist/plugins/typescript.js");
+import * as vlib from "/Users/administrator/persistance/private/dev/vinc/vlib/js/dist/esm/vlib.js";
+import * as vhighlight from "/Users/administrator/persistance/private/dev/vinc/vhighlight/dist/esm/vhighlight.js";
+
+// -------------------------------------------------------------------------------------------------------------------------
+// Compile Test.
+
+import * as Preprocessing from "../backend/dist/esm/plugins/ts/preprocessing.js";
+import * as TypeScript from "../backend/dist/esm/plugins/ts/compiler.js";
+
+import * as ts from "typescript";
+import * as fs from "fs";
+
+
+import { fileURLToPath } from 'node:url';
+import { dirname } from 'node:path';
+import { argv } from 'node:process';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// if (true) {
+//     (async () => {
+//         for (const path of await new vlib.Path(__dirname).paths({recursive: true})) {
+//             if (path.str().endsWith(".d.ts")) {
+//                 console.log("Remove", path.str())
+//                 await path.del();
+//                 continue;
+//             } else if (path.extension() === ".js") {
+//                 const tspath = new vlib.Path(path.str().slice(0, -2) + "ts");
+//                 if (tspath.exists()) {
+//                     console.log("Remove", path.str())
+//                     await path.del();
+//                     continue;
+//                 }
+//             }
+//             console.log("Dont remove", path.str())
+//         }
+//     })()
+// }
+// else
+
+if (process.argv.includes("--test")) {
+    (async () => {
+
+        vlib.print_marker("Test mode enabled.");
+
+        // const input_path = `/Users/administrator/persistance/private/dev/libris/libris/core/frontend/home/home.ts`;
+        const input_path = `/Users/administrator/persistance/private/dev/libris/libris/core/frontend/auth/signin.ts`;
+        // const input_path = `/Users/administrator/persistance/private/dev/libris/libris/core/frontend/dashboard/dashboard.ts`
+
+        let now = Date.now()
+        const compiled = await TypeScript.compile({
+            entry_paths: [input_path],
+            output: "/tmp/test-dir/",
+            preprocess: Preprocessing.volt_auto_imports,
+            // watch: true,
+            compiler_opts: {
+                target: "ES2023",
+                module: "es6",
+                lib: ["ES2023", "DOM"],
+                declaration: false,
+                strict: true,
+                esModuleInterop: true,
+                allowJs: true,
+                checkJs: false,
+                noImplicitAny: false,
+                skipLibCheck: true,
+                types: [],
+                rootDir: "/", // keep absolute file paths.
+                // "baseUrl": ".",  // Base directory for module resolution
+                paths: {
+                    // "vhighlight": [
+                    //     "/Users/administrator/persistance/private/dev/vinc/vhighlight/vhighlight.js",
+                    //     "/Volumes/persistance/private/dev/vinc/vhighlight/vhighlight.js",
+                    // ]
+                },
+            }
+        })
+        console.log("Compile time:", Date.now() - now);
+        console.log(compiled)
+
+        // Find the common base path.
+        const base_input_path = vlib.Path.find_common_base_path(compiled.inputs);
+        const base_output_path = vlib.Path.find_common_base_path(compiled.outputs);
+        const output_path = compiled.outputs.find(path => new vlib.Path(path).name(false) === new vlib.Path(input_path).name(false))
+        // const output_path = input_path.replace(base_input_path, base_output_path).slice(0, -2) + "js";
+
+        console.log({
+            base_input_path,
+            base_output_path,
+            input_path,
+            output_path,
+        })
+
+
+
+
+        // compiled.debug()
+        // console.log("BUNDLE!", compiled.errors.length === 0)
+        if (compiled.errors.length === 0) {
+            console.log("BUNDLE!")
+            now = Date.now()
+            const bundle = await TypeScript.bundle({
+                entry_paths: [output_path],
+                bundler: "rollup",
+                extract_inputs: true,
+                // minify: true,
+            })
+            console.log(bundle)
+            bundle.debug();
+            console.log("Bundle time:", Date.now() - now);
+        }
+
+    })()
+}
+
+// -------------------------------------------------------------------------------------------------------------------------
+// Compile Frontend.
+else {
+    (async () => {
+
+        // Settings.
+        const frontend =  new vlib.Path(`${__dirname}/src/`).abs().str();
+
+
+
+        // Create VElement interface.
+        // async function create_velement_interface(name, source_code) {
+        //     const source_file = ts.createSourceFile(
+        //         'temp.ts',
+        //         Preprocessing.preprocess(
+        //             "elements/create.ts",
+        //             new vlib.Path(name.replace("/types.ts", "/create.ts")).load_sync(),
+        //             { macros: true },
+        //         ),
+        //         // source_code,
+        //         ts.ScriptTarget.Latest,
+        //         true
+        //     );
+
+        //     let instance_interface_text = '';
+        //     let static_interface_text = '';
+        //     let static_class_text = '';
+        //     let class_name = '';
+        //     let extends_clause = '';
+        //     let implements_clause = '';
+
+        //     // Track method overloads
+        //     const method_overloads = new Map();
+
+        //     // First pass to collect all method overloads
+        //     function collect_overloads(node) {
+        //         if (ts.isClassDeclaration(node)) {
+        //             node.members.forEach(member => {
+        //                 if (ts.isMethodDeclaration(member)) {
+        //                     const method_name = member.name.getText(source_file);
+                            
+        //                     // Check if it's a method overload (no body)
+        //                     const is_overload = !member.body;
+                            
+        //                     if (!method_overloads.has(method_name)) {
+        //                         method_overloads.set(method_name, []);
+        //                     }
+                            
+        //                     if (is_overload || method_overloads.get(method_name)/*!*/.length === 0) {
+        //                         method_overloads.get(method_name)/*!*/.push(member);
+        //                     }
+        //                 }
+        //             });
+        //         }
+        //         ts.forEachChild(node, collect_overloads);
+        //     }
+
+        //     // Main visitor function
+        //     // @v2 by gpt o1
+        //     const override_html_element_methods = [
+        //         "blur",
+        //         "animate",
+        //         "translate",
+        //         "dir",
+        //         "draggable",
+        //         "id",
+        //         "lang",
+        //         "title",
+        //         // "X",
+        //         // "X",
+        //     ];
+        //     function visit(node) {
+        //         if (ts.isClassDeclaration(node)) {
+        //             class_name = node.name ? node.name.text : 'Anonymous';
+        //             if (class_name === "VBaseElement") {
+        //                 if (node.heritageClauses) {
+        //                     node.heritageClauses.forEach(clause => {
+        //                         if (clause.token === ts.SyntaxKind.ExtendsKeyword && clause.types[0]?.expression) {
+        //                             extends_clause = clause.types[0].expression.getText(source_file);
+        //                         } else if (clause.token === ts.SyntaxKind.ImplementsKeyword) {
+        //                             implements_clause = clause.types.map(t => t.expression.getText(source_file)).join(', ');
+        //                         }
+        //                     });
+        //                 }
+
+        //                 node.members.forEach(member => {
+        //                     const indent = '    ';
+                            
+        //                     if (ts.isPropertyDeclaration(member)) {
+        //                         const modifier = member.modifiers?.some(m => m.kind === ts.SyntaxKind.StaticKeyword) 
+        //                             ? 'static '
+        //                             : '';
+        //                         const name = member.name.getText(source_file);
+        //                         const type = member.type 
+        //                             ? member.type.getText(source_file)
+        //                             : 'any';
+        //                         const optional = member.questionToken ? '?' : '';
+                                
+        //                         if (modifier === 'static ') {
+        //                             // static_interface_text += `${indent}${name}${optional}: ${type};\n`;
+        //                             static_interface_text += `${indent}${name}${optional}: ${type};\n`;
+        //                             static_class_text += `${indent}${modifier}${name}${optional}: ${type};\n`;
+        //                         } else {
+        //                             instance_interface_text += indent;
+        //                             if (override_html_element_methods.includes(name)) {
+        //                                 instance_interface_text += "// @ts-ignore\n "+indent;
+        //                             }
+        //                             instance_interface_text += `${name}${optional}: ${type};\n`;
+        //                         }
+        //                     }
+                            
+        //                     else if (ts.isMethodDeclaration(member)) {
+        //                         const method_name = member.name.getText(source_file);
+        //                         const overloads = method_overloads.get(method_name);
+                                
+        //                         if (!member.body || !overloads || overloads.length === 1) {
+        //                             const params = member.parameters.map(p => {
+        //                                 // Handle parameter name
+        //                                 let param_name;
+        //                                 if (ts.isIdentifier(p.name)) {
+        //                                     param_name = p.name.getText(source_file);
+        //                                 } else {
+        //                                     // For BindingPattern (e.g., destructuring), use a generic name
+        //                                     param_name = 'options';
+        //                                 }
+        //                                 const param_type = p.type 
+        //                                     ? p.type.getText(source_file)
+        //                                     : 'any';
+        //                                 // Combine questionToken and initializer to determine if parameter is optional
+        //                                 const optional = p.questionToken || p.initializer ? '?' : '';
+        //                                 // Check for rest parameter
+        //                                 const dotDotDot = p.dotDotDotToken ? '...' : '';
+        //                                 return `${dotDotDot}${param_name}${optional}: ${param_type}`;
+        //                             }).join(', ');
+                                    
+        //                             const return_type = member.type 
+        //                                 ? member.type.getText(source_file)
+        //                                 : 'void';
+                                    
+        //                             // Only add the generic type parameter if it was present in the original method signature
+        //                             if (member.typeParameters) {
+        //                                 const type_parameters = member.typeParameters.map(t => t.getText(source_file)).join(', ');
+        //                                 if (member.modifiers?.some(m => m.kind === ts.SyntaxKind.StaticKeyword)) {
+        //                                     static_interface_text += `${indent}${method_name}<${type_parameters}>(${params}): ${return_type};\n`;
+        //                                     static_class_text += `${indent}static ${method_name}<${type_parameters}>(${params}): ${return_type};\n`;
+        //                                 } else {
+        //                                     instance_interface_text += indent;
+        //                                     if (override_html_element_methods.includes(method_name)) {
+        //                                         instance_interface_text += "// @ts-ignore\n "+indent;
+        //                                     }
+        //                                     instance_interface_text += `${method_name}<${type_parameters}>(${params}): ${return_type};\n`;
+        //                                 }
+        //                             } else {
+        //                                 if (member.modifiers?.some(m => m.kind === ts.SyntaxKind.StaticKeyword)) {
+        //                                     static_interface_text += `${indent}${method_name}(${params}): ${return_type};\n`;
+        //                                     static_class_text += `${indent}static ${method_name}(${params}): ${return_type};\n`;
+        //                                 } else {
+        //                                     instance_interface_text += indent;
+        //                                     if (override_html_element_methods.includes(method_name)) {
+        //                                         instance_interface_text += "// @ts-ignore\n "+indent;
+        //                                     }
+        //                                     instance_interface_text += `${method_name}(${params}): ${return_type};\n`;
+        //                                 }
+        //                             }
+        //                         }
+        //                     }
+        //                 });
+        //             }
+        //         }
+
+        //         ts.forEachChild(node, visit);
+        //     }
+
+        //     // First collect all overloads
+        //     collect_overloads(source_file);
+
+        //     // Then generate the interface
+        //     visit(source_file);
+
+        //     // Make some replacements.
+        //     // instance_interface_text = instance_interface_text.replace(/\bVBaseElement\b/g, "this");
+
+        //     // instance_interface_text = instance_interface_text.replace(/\bVBaseElement\b/g, "VElementInstance");
+        //     // static_interface_text = static_interface_text.replace(/\bVBaseElement\b/g, "VElementInstance");
+        //     // static_class_text = static_class_text.replace(/\bVBaseElement\b/g, "VElementInstance");
+
+        //     instance_interface_text = instance_interface_text.replace(/\bVBaseElement\b/g, "this");
+        //     static_interface_text = static_interface_text.replace(/\bVBaseElement\b/g, "this");
+        //     static_class_text = static_class_text.replace(/\bVBaseElement\b/g, "this");
+
+        //     new vlib.Path(`/tmp/velement.interface.ts`).save_sync(source_code
+        //         .replaceAll("{{EMBED_VELEMENT_INSTANCE}}", instance_interface_text)
+        //         .replaceAll("{{EMBED_VELEMENT_STATIC}}", static_class_text)
+        //         .replaceAll("{{EMBED_VELEMENT_INTERFACE_STATIC}}", static_interface_text))
+
+        //     return source_code
+        //         .replaceAll("{{EMBED_VELEMENT_INSTANCE}}", instance_interface_text)
+        //         .replaceAll("{{EMBED_VELEMENT_STATIC}}", static_class_text)
+        //         .replaceAll("{{EMBED_VELEMENT_INTERFACE_STATIC}}", static_interface_text);
+        // }
+
+        // Embed scripts
+        const embed_script = (input, output, postprocess = undefined) => {
+
+            // Compile data to indicate that is should not be edited.
+            const path = new vlib.Path(input);
+            let data = path.load_sync();
+            if (input.includes("scheme.js")) {
+                data = `const volt = {};\n/* DO NOT EDIT THIS FILE IT IS LOCATED AT ${input}. */ \n` + data.replaceAll("vlib", "volt");
+                data = "import { Colors } from \"./colors\";\n" + data;
+                data = data.replaceAll("volt.colors.end", "Colors.end")
+                data = data.replaceAll("volt.colors.yellow", "Colors.yellow")
+                data += `\nconst Scheme = volt.Scheme;\nexport { Scheme };\n`
+            } else if (input.includes("date.js")) {
+                data = `const volt = {};\n/* DO NOT EDIT THIS FILE IT IS LOCATED AT ${input}. */ \n` + data.replaceAll("vlib", "volt");
+                data = data.replaceAll("extends Date", "extends window.Date")
+                data += `\nexport const VDate = volt.Date;\n`
+                // data += `\nconst Date = volt.Date;\nexport { Date };\n`
+            } else if (input.endsWith("/vhighlight.browser.js")) {
+                data = `/** \n * @type any \n */\n` + data;
+            }
+            if (postprocess) {
+                const res = postprocess(data);
+                if (res) { data = res; }
+            }
+
+            // Save.
+            new vlib.Path(output).save_sync(data)
+        }
+
+        // Embed vlib scripts.
+        embed_script(`${process.env.PERSISTANCE}/private/dev/vinc/vlib/js/src/types/global/string.ts`, `${frontend}/modules/string.ts`)
+        embed_script(`${process.env.PERSISTANCE}/private/dev/vinc/vlib/js/src/types/global/number.ts`, `${frontend}/modules/number.ts`)
+        embed_script(`${process.env.PERSISTANCE}/private/dev/vinc/vlib/js/src/types/global/object.ts`, `${frontend}/modules/object.ts`)
+        embed_script(`${process.env.PERSISTANCE}/private/dev/vinc/vlib/js/src/types/global/array.ts`, `${frontend}/modules/array.ts`)
+        embed_script(`${process.env.PERSISTANCE}/private/dev/vinc/vlib/js/src/types/global/scheme.ts`, `${frontend}/modules/scheme.ts`, data => {
+            if (data.includes('import { Colors } from "../system/colors.js"')) {
+                return data.replace('import { Colors } from "../system/colors.js"', 'import { Colors } from "./colors.js"')
+            }
+            return data;
+        })
+        embed_script(`${process.env.PERSISTANCE}/private/dev/vinc/vlib/js/src/types/global/date.ts`, `${frontend}/modules/date.ts`)
+
+        // embed_script(`${process.env.PERSISTANCE}/private/dev/vinc/vhighlight/dist/esm/vhighlight.web.min.js`, `${frontend}/libs/vhighlight.js`)
+        // embed_script(`${process.env.PERSISTANCE}/private/dev/vinc/vhighlight/dist/esm/vhighlight.web.d.ts`, `${frontend}/libs/vhighlight.d.ts`)
+
+        // const embed_dir = async (src, dst) => {
+        //     dst = new vlib.Path(dst);
+        //     if (dst.exists()) {
+        //         try { await dst.del({recursive: true}); } catch (e) {console.error(e)}
+        //     }
+        //     await new vlib.Path(src).cp(dst)
+        // }
+        // await embed_dir(`${process.env.PERSISTANCE}/private/dev/vinc/vhighlight/dist/esm`, `${frontend}/libs/vhighlight`)
+        // await embed_dir(`${process.env.PERSISTANCE}/private/dev/vinc/vhighlight/src`, `${frontend}/libs/vhighlight`)
+
+        // Compile.
+        let debug_file = vlib.cli.get({id: "--debug-file", type: "string"});
+        // if (debug_file != null && debug_file[0] !== "/") {
+        //     debug_file = __dirname + "/" + debug_file;
+        // }
+        const response = await TypeScript.compile({
+        	include: [
+                frontend + "/ui/any_element.d.ts",
+                frontend + "/elements/create.ts",
+                frontend + "/ui/any_element.ts",
+                frontend,
+            ],
+            exclude: [frontend + "/../dist/"],
+            output: frontend + "/../dist/",
+            compiler_opts: {
+                "target": "ES2021",
+                "module": "NodeNext",
+                "moduleResolution": "NodeNext",
+                "skipLibCheck": true,
+                "lib": ["ES2021", "DOM"],
+                "declaration": true,
+                "strict": true,
+                "esModuleInterop": true,
+                "allowJs": true,
+                "checkJs": false,
+                "noImplicitAny": false,
+                "types": [],
+                "baseUrl": ".",
+                "paths": {
+                    "vhighlight": [
+                        // `${process.env.PERSISTANCE}/private/dev/vinc/vhighlight/dist/esm/vhighlight.web.js`,
+                        `${process.env.PERSISTANCE}/private/dev/vinc/vhighlight/dist/web/`,
+                    ]
+                },
+            },
+            error_limit: vlib.cli.get({id: "--error-limit", type: "number", def: 25}),
+            debug_file,//: "/Users/administrator/persistance/private/dev/vinc/volt/frontend/ui/element.ts",
+            extract_exports: true,
+        	// async preprocess(name, data) {
+            //     // console.log("Processing",name)
+            //     // Create Velement interface.
+            //     if (name.endsWith("elements/types.ts")) {
+            //         return await create_velement_interface(name, data);
+            //     }
+
+            //     // Default.
+            //     return data;
+        	// },
+        })
+        response.debug();
+
+        // Save exports.
+        const exps = {};
+        for (const [name, exp] of Object.entries(response.exports)) {
+            if (name.includes("/dist/")) { continue; }
+            exps[new vlib.Path(name).abs().str().slice(frontend.length + 1)] = exp;
+        }
+        new vlib.Path(`${__dirname}/exports.json`).save_sync(JSON.stringify(exps, null, 4))
+        console.log("Saved ./exports.json");
+    })()
+}