fenrir-runtime 0.0.1

package/dist/runtime.js

@@ -0,0 +1,99 @@
+import { execSync } from 'child_process';
+import fs from 'fs-extra';
+import path from 'path';
+export class FenrirRuntime {
+    static instance;
+    packageCache = new Map();
+    runtimeCache = new Map();
+    static getInstance() {
+        if (!FenrirRuntime.instance) {
+            FenrirRuntime.instance = new FenrirRuntime();
+        }
+        return FenrirRuntime.instance;
+    }
+    log = (...args) => {
+        process.stdout.write(args.map(arg => typeof arg === 'object' ? JSON.stringify(arg, null, 2) : String(arg)).join(' ') + '\n');
+    };
+    readFile = (filePath) => {
+        try {
+            return fs.readFileSync(path.resolve(filePath), 'utf8');
+        }
+        catch (error) {
+            throw new Error(`File cannot be read: ${filePath}`);
+        }
+    };
+    writeFile = (filePath, content) => {
+        try {
+            fs.writeFileSync(path.resolve(filePath), content, 'utf8');
+        }
+        catch (error) {
+            throw new Error(`File could not be written: ${filePath}`);
+        }
+    };
+    fetch = async (url, options) => {
+        const https = require('https');
+        const http = require('http');
+        return new Promise((resolve, reject) => {
+            const client = url.startsWith('https') ? https : http;
+            const req = client.get(url, (res) => {
+                let data = '';
+                res.on('data', (chunk) => data += chunk);
+                res.on('end', () => {
+                    try {
+                        resolve(JSON.parse(data));
+                    }
+                    catch {
+                        resolve(data);
+                    }
+                });
+            });
+            req.on('error', reject);
+        });
+    };
+    require = (packageName) => {
+        if (this.packageCache.has(packageName)) {
+            return this.packageCache.get(packageName);
+        }
+        try {
+            const pkg = require(packageName);
+            this.packageCache.set(packageName, pkg);
+            return pkg;
+        }
+        catch (error) {
+            throw new Error(`Package not found: ${packageName}. Install it with the command 'fenrir install ${packageName}'.`);
+        }
+    };
+    exec = (command) => {
+        try {
+            return execSync(command, { encoding: 'utf8', stdio: 'inherit' });
+        }
+        catch (error) {
+            throw new Error(`Command could not be executed: ${command}`);
+        }
+    };
+    executeCommand = (command) => {
+        try {
+            return execSync(command, { encoding: 'utf8', stdio: 'inherit' });
+        }
+        catch (error) {
+            const errorMessage = error.message || 'Bilinmeyen bir hata oluştu.';
+            throw new Error(`Fenrir komutu çalıştırılamadı: ${command}. Hata: ${errorMessage}`);
+        }
+    };
+    now = () => Date.now();
+    time = () => new Date().toISOString();
+    sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+}
+const fenrirRuntime = FenrirRuntime.getInstance();
+Object.assign(globalThis, {
+    fenrir: fenrirRuntime.executeCommand,
+    log: fenrirRuntime.log,
+    readFile: fenrirRuntime.readFile,
+    writeFile: fenrirRuntime.writeFile,
+    fetch: fenrirRuntime.fetch,
+    exec: fenrirRuntime.exec,
+    now: fenrirRuntime.now,
+    sleep: fenrirRuntime.sleep
+});
+export { fenrirRuntime as fenrir };
+export default FenrirRuntime;

package/dist/transformer.js

@@ -0,0 +1,120 @@
+import path from 'path';
+export const transformFenrirCode = async (fenrirCode, filePath, aperiumImports) => {
+    if (fenrirCode.includes('import ')) {
+        throw new Error("Fenrir Error: The keyword 'import' cannot be used. Use 'declare' to identify modules.");
+    }
+    const lines = fenrirCode.split('\n');
+    let jsOutput = '';
+    let i = 0;
+    while (i < lines.length) {
+        const line = lines[i];
+        const trimmedLine = line.trim();
+        if (!trimmedLine) {
+            jsOutput += line + '\n';
+            i++;
+            continue;
+        }
+        let transformedLine = trimmedLine;
+        let isMultiLineStatement = false;
+        if (trimmedLine.startsWith('fn ')) {
+            transformedLine = transformedLine.replace(/^fn\s+/, 'function ');
+        }
+        else if (trimmedLine.startsWith('declare ')) {
+            const importMatch = trimmedLine.match(/declare\s+(.*?)\s+from\s+['"](.*?)['"]/);
+            if (importMatch) {
+                const importName = importMatch[1];
+                const modulePath = importMatch[2];
+                if (isNpmModule(modulePath)) {
+                    transformedLine = `import ${importName} from "${modulePath}";`;
+                }
+                else {
+                    const resolvedPath = path.resolve(path.dirname(filePath), modulePath);
+                    transformedLine = `import ${importName} from "file://${resolvedPath}";`;
+                }
+            }
+        }
+        transformedLine = transformedLine.replace(/\blog\(/g, 'console.log(');
+        if (transformedLine.includes('(') && !transformedLine.includes(')')) {
+            isMultiLineStatement = true;
+            let fullStatement = transformedLine;
+            let j = i + 1;
+            let openParens = (transformedLine.match(/\(/g) || []).length;
+            let closeParens = (transformedLine.match(/\)/g) || []).length;
+            while (j < lines.length && openParens > closeParens) {
+                const nextLine = lines[j];
+                fullStatement += '\n' + nextLine;
+                openParens += (nextLine.match(/\(/g) || []).length;
+                closeParens += (nextLine.match(/\)/g) || []).length;
+                j++;
+            }
+            const processedStatement = fullStatement.replace(/\blog\(/g, 'console.log(');
+            if (shouldAddSemicolon(processedStatement.trim())) {
+                jsOutput += processedStatement + ';\n';
+            }
+            else {
+                jsOutput += processedStatement + '\n';
+            }
+            i = j;
+            continue;
+        }
+        if (shouldAddSemicolon(transformedLine)) {
+            transformedLine += ';';
+        }
+        jsOutput += transformedLine + '\n';
+        i++;
+    }
+    return jsOutput;
+};
+function isNpmModule(modulePath) {
+    if (modulePath.startsWith('./') || modulePath.startsWith('../')) {
+        return false;
+    }
+    if (modulePath.startsWith('/')) {
+        return false;
+    }
+    if (modulePath.match(/\.(js|mjs|ts|json)$/)) {
+        return false;
+    }
+    return true;
+}
+function shouldAddSemicolon(line) {
+    const trimmed = line.trim();
+    if (trimmed.endsWith(';'))
+        return false;
+    if (trimmed.endsWith('{') ||
+        trimmed.endsWith('}') ||
+        (trimmed.endsWith(')') && !hasAssignmentOrCall(trimmed))) {
+        return false;
+    }
+    if (trimmed.startsWith('function ') ||
+        trimmed.startsWith('if ') ||
+        trimmed.startsWith('else') ||
+        trimmed.startsWith('for ') ||
+        trimmed.startsWith('while ') ||
+        trimmed.startsWith('switch ') ||
+        trimmed.startsWith('try') ||
+        trimmed.startsWith('catch') ||
+        trimmed.startsWith('finally') ||
+        trimmed.startsWith('import ') ||
+        trimmed.startsWith('export ') ||
+        trimmed.match(/^}\s*else/)) {
+        return false;
+    }
+    return (trimmed.includes('=') ||
+        trimmed.includes('console.log') ||
+        trimmed.includes('return ') ||
+        trimmed.startsWith('const ') ||
+        trimmed.startsWith('let ') ||
+        trimmed.startsWith('var ') ||
+        /^[a-zA-Z_$][a-zA-Z0-9_$.]*\s*\(/.test(trimmed) ||
+        Boolean(trimmed.match(/^\w+\s*\+\+/)) ||
+        Boolean(trimmed.match(/^\w+\s*--/)) ||
+        Boolean(trimmed.match(/^\w+\s*[+\-*/]=/)));
+}
+function hasAssignmentOrCall(line) {
+    const trimmedLine = line.trim();
+    return trimmedLine.includes('=') ||
+        trimmedLine.includes('console.log') ||
+        trimmedLine.includes('return ') ||
+        /^[a-zA-Z_$][a-zA-Z0-9_$.]*\s*\(/.test(trimmedLine);
+}

package/example/fenrir+aperium/aperium.json

@@ -0,0 +1,17 @@
+{
+  "project": {
+    "name": "fenrir-test",
+    "version": "1.0.0",
+    "description": "",
+    "author": "",
+    "license": "GPL-3.0-or-later"
+  },
+  "main": "app.fnr",
+  "dependencies": {
+    "hello-world": "1.0.0"
+  },
+  "imports": {},
+  "scripts": {
+    "start": "fenrir app.fnr"
+  }
+}

package/example/fenrir+aperium/aperium_modules/hello-world/index.js

@@ -0,0 +1,4 @@
+const greet = (name) => {
+  return `Hello, ${name}! Welcome to Aperium and Fenrir.`;
+};
+export default greet;

package/example/fenrir+aperium/aperium_modules/hello-world/module.json

@@ -0,0 +1,6 @@
+{
+  "name": "hello-world",
+  "version": "1.0.0",
+  "main": "index.js",
+  "description": "A simple 'hello world' module for Aperium projects."
+}

package/example/fenrir+aperium/app.fnr

@@ -0,0 +1,19 @@
+declare express from 'express'
+declare hw from 'hello-world'
+
+const app = express()
+const port = 3000
+
+fn handle_home_request(req, res) {
+  res.send(hw('World'))
+}
+
+app.get('/', handle_home_request)
+
+fn start_server() {
+  app.listen(port, () => {
+    log(`Server running at http://localhost:${port}`)
+  })
+}
+
+start_server()