Merge remote-tracking branch 'origin/master' into elm-references-to-guida

Conflicts:
	src/Node/Format.elm

Author: decioferreira

.github/pull_request_template.md

@@ -16,8 +16,7 @@ Briefly describe the goal of this pull request and what problem it solves.
 - [ ] The code compiles and all tests pass (`npm test`)
 - [ ] The change has been tested in:
   - [ ] CLI
-  - [ ] Browser
-  - [ ] Node (API)
+  - [ ] API
 - [ ] I’ve added or updated tests, if applicable
 - [ ] I’ve updated relevant documentation or comments
 - [ ] My changes follow the project's coding style

.github/workflows/main.yml

@@ -22,7 +22,7 @@ jobs:
           cache: "npm"
       - run: npm ci
       - run: npm run build:bin
-      - run: npm run build:browser
+      - run: npm run build:api
       - run: npm run test:eslint
       - run: npm run test:elm-format-validate
       - run: npm run test:jest

.gitignore

@@ -7,12 +7,8 @@ elm-stuff
 guida-stuff
 
 # Main
-lib/guida.node.js
-lib/guida.node.min.js
-
-# Browser
-lib/guida.browser.js
-lib/guida.browser.min.js
+lib/guida.js
+lib/guida.min.js
 
 # Command line
 bin/guida.js

.npmignore

@@ -2,8 +2,7 @@
 bin/guida.js
 elm-stuff
 examples
-lib/guida.node.js
-lib/guida.browser.js
+lib/guida.js
 guida-stuff
 review
 scripts

CONTRIBUTING.md

@@ -67,7 +67,7 @@ For detailed instructions on setting up your environment for contributing to Gui
 We aim for stability and consistency. If you’re adding features or fixing bugs, please:
 
 - Write tests if applicable.
-- Consider all 3 outputs of the project: bin (command line), browser and node (API).
+- Consider both outputs of the project: bin (command line) and API (browser and node).
 - Make sure to test all three output targets of the project:
   - CLI (bin) — the command-line interface
   - Browser — compiled for browser usage

eslint.config.mjs

@@ -8,18 +8,15 @@ export default defineConfig([
   globalIgnores([
     "bin/guida.js",
     "bin/guida.min.js",
-    "lib/guida.browser.js",
-    "lib/guida.browser.min.js",
-    "lib/guida.node.js",
-    "lib/guida.node.min.js",
+    "lib/guida.js",
+    "lib/guida.min.js",
     "elm-stuff",
     "guida-stuff",
   ]),
   { files: ["**/*.{js,mjs,cjs}"] },
   { files: ["**/*.js"], languageOptions: { sourceType: "commonjs" } },
   { files: ["bin/**/*.{js,mjs,cjs}"], languageOptions: { globals: globals.node } },
-  { files: ["lib/browser.js"], languageOptions: { globals: globals.browser } },
-  { files: ["lib/node.js"], languageOptions: { globals: globals.node } },
+  { files: ["lib/index.js"], languageOptions: { globals: { ...globals.browser, ...globals.node } } },
   { files: ["try/**/*.{js,mjs,cjs}"], languageOptions: { globals: { ...globals.browser, ...globals.node } } },
   { files: ["scripts/*.js"], languageOptions: { globals: globals.node } },
   {

lib/index.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Configuration object expected by the Guida runner.
+ */
+export interface GuidaConfig {
+    // XMLHttpRequest constructor for making HTTP requests.
+    XMLHttpRequest: typeof XMLHttpRequest;
+
+    // Write text or binary data to a path.
+    writeFile(path: string, data: string | ArrayBuffer | Uint8Array | Buffer): Promise<void>;
+
+    // Read file contents. Can return text or binary data.
+    readFile(path: string): Promise<string | ArrayBuffer | Uint8Array | Buffer | { buffer: ArrayBuffer }>;
+
+    // Read a directory and return a list of files.
+    readDirectory(path: string): Promise<{ files: string[] }>;
+
+    // Create a directory.
+    createDirectory(path: string): Promise<void>;
+
+    // Get details for a path (file or directory).
+    details(path: string): Promise<{ type: 'file' | 'directory' | string; createdAt?: number }>;
+
+    // Returns the current working directory.
+    getCurrentDirectory(): Promise<string>;
+
+    // Returns the string path of the current user's home directory.
+    homedir(): Promise<string>;
+
+    // Environment map used by the runner.
+    env?: Record<string, any>;
+}
+
+export interface MakeOptions {
+    debug?: boolean;
+    optimize?: boolean;
+    sourcemaps?: boolean;
+}
+
+// The runtime returns various JSON-able responses. Keep this generic to reflect the dynamic
+// nature of the results coming from the embedded Elm/runner process.
+export type GuidaResponse = any;
+
+declare const _default: {
+    make: (config: GuidaConfig, path: string, options?: MakeOptions) => Promise<GuidaResponse>;
+    format: (config: GuidaConfig, content: string) => Promise<GuidaResponse>;
+    install: (config: GuidaConfig, pkg: string) => Promise<GuidaResponse>;
+    uninstall: (config: GuidaConfig, pkg: string) => Promise<GuidaResponse>;
+    diagnostics: (config: GuidaConfig, args: { content: string } | { path: string }) => Promise<{ errors?: any }>;
+};
+
+export default _default;

lib/browser.js renamed to lib/index.js

@@ -1,24 +1,16 @@
-const { createFs } = require("indexeddb-fs");
 const { newServer } = require("mock-xmlhttprequest");
 const JSZip = require("jszip");
 
-const savedXMLHttpRequest = globalThis.XMLHttpRequest;
-const fs = createFs({ databaseName: "guida-fs" });
-
-const runGuida = function (extraEnv, args) {
+const runGuida = function (config, args) {
     return new Promise((resolve) => {
         let mVarsNextCounter = 0;
         const mVars = {};
         const lockedFiles = {};
 
-        const env = Object.assign({
-            GUIDA_HOME: "root/.guida",
-        }, extraEnv);
-
         const download = function (method, url) {
             const that = this;
 
-            const xhr = new savedXMLHttpRequest();
+            const xhr = new config.XMLHttpRequest();
             xhr.open(method, url, true);
             xhr.responseType = "arraybuffer";
 
@@ -85,16 +77,15 @@ const runGuida = function (extraEnv, args) {
         server.post("writeString", async (request) => {
             const path = request.requestHeaders.getHeader("path");
 
-            await fs.writeFile(path, request.body);
+            await config.writeFile(path, request.body);
             request.respond(200);
         });
 
         server.post("read", async (request) => {
-            const content = await fs.readFile(request.body);
+            const content = await config.readFile(request.body);
             request.respond(200, null, content);
         });
 
-
         server.post("getArchive", (request) => {
             download.apply({
                 send: ({ sha, archive }) => {
@@ -105,8 +96,7 @@ const runGuida = function (extraEnv, args) {
 
         server.post("dirDoesFileExist", async (request) => {
             try {
-                const stats = await fs.details(request.body);
-                console.log("dirDoesFileExist", request.body, stats);
+                const stats = await config.details(request.body);
                 request.respond(200, null, stats.type === "file");
             } catch (_err) {
                 request.respond(200, null, false);
@@ -116,19 +106,20 @@ const runGuida = function (extraEnv, args) {
         server.post("dirCreateDirectoryIfMissing", async (request) => {
             const { createParents, filename } = JSON.parse(request.body);
             let directories = [filename];
+            let prefix = filename.startsWith("/") ? "/" : "";
 
             if (createParents) {
                 directories = filename.split('/').filter(Boolean);
-                directories = directories.map((_, index) => directories.slice(0, index + 1).join('/'));
+                directories = directories.map((_, index) => prefix + directories.slice(0, index + 1).join('/'));
             }
 
             await directories.reduce(async (previousPromise, directory) => {
                 await previousPromise;
 
                 try {
-                    await fs.details(directory);
+                    await config.details(directory);
                 } catch (_err) {
-                    await fs.createDirectory(directory);
+                    await config.createDirectory(directory);
                 }
             }, Promise.resolve());
 
@@ -165,13 +156,13 @@ const runGuida = function (extraEnv, args) {
         });
 
         server.post("dirGetModificationTime", async (request) => {
-            const stats = await fs.details(request.body);
+            const stats = await config.details(request.body);
             request.respond(200, null, stats.createdAt);
         });
 
         server.post("dirDoesDirectoryExist", async (request) => {
             try {
-                const stats = await fs.details(request.body);
+                const stats = await config.details(request.body);
                 request.respond(200, null, stats.type === "directory");
             } catch (_err) {
                 request.respond(200, null, false);
@@ -183,33 +174,35 @@ const runGuida = function (extraEnv, args) {
         });
 
         server.post("dirListDirectory", async (request) => {
-            const { files } = await fs.readDirectory(request.body);
+            const { files } = await config.readDirectory(request.body);
             request.respond(200, null, JSON.stringify(files));
         });
 
         server.post("binaryDecodeFileOrFail", async (request) => {
-            const data = await fs.readFile(request.body);
+            const data = await config.readFile(request.body);
             request.respond(200, null, data.buffer);
         });
 
         server.post("write", async (request) => {
             const path = request.requestHeaders.getHeader("path");
 
-            await fs.writeFile(path, request.body);
+            await config.writeFile(path, request.body);
             request.respond(200);
         });
 
-        server.post("dirGetCurrentDirectory", (request) => {
-            request.respond(200, null, "root");
+        server.post("dirGetCurrentDirectory", async (request) => {
+            const currentDir = await config.getCurrentDirectory();
+            request.respond(200, null, currentDir);
         });
 
         server.post("envLookupEnv", (request) => {
-            const envVar = env[request.body] ?? null;
+            const envVar = config.env[request.body] ?? null;
             request.respond(200, null, JSON.stringify(envVar));
         });
 
-        server.post("dirGetAppUserDataDirectory", (request) => {
-            request.respond(200, null, `root/.${request.body}`);
+        server.post("dirGetAppUserDataDirectory", async (request) => {
+            const homedir = await config.homedir();
+            request.respond(200, null, `${homedir}/.${request.body}`);
         });
 
         // MVARS
@@ -282,7 +275,7 @@ const runGuida = function (extraEnv, args) {
             }
         });
 
-        // BROWSER
+        // API
         server.post("getArgs", (request) => {
             request.respond(200, null, JSON.stringify(args));
         });
@@ -297,11 +290,9 @@ const runGuida = function (extraEnv, args) {
         });
 
         server.setDefaultHandler((request) => {
-            console.log("defaultHandler", request.url);
-
             const headers = request.requestHeaders.getHash();
 
-            var xhr = new savedXMLHttpRequest();
+            var xhr = new config.XMLHttpRequest();
             xhr.open(request.method, request.url, true);
 
             for (const key in headers) {
@@ -317,63 +308,32 @@ const runGuida = function (extraEnv, args) {
 
         server.install();
 
-        const { Elm } = require("./guida.browser.min.js");
+        const { Elm } = require("./guida.min.js");
 
-        Elm.Browser.Main.init();
+        Elm.API.Main.init();
     });
-}
-
-const elmJsonContent = `{
-    "type": "application",
-    "source-directories": [
-        "src"
-    ],
-    "elm-version": "0.19.1",
-    "dependencies": {
-        "direct": {
-            "elm/browser": "1.0.2",
-            "elm/core": "1.0.5",
-            "elm/html": "1.0.0"
-        },
-        "indirect": {
-            "elm/json": "1.1.3",
-            "elm/time": "1.0.0",
-            "elm/url": "1.0.0",
-            "elm/virtual-dom": "1.0.3"
-        }
-    },
-    "test-dependencies": {
-        "direct": {},
-        "indirect": {}
-    }
-}`;
+};
 
 module.exports = {
-    init: async (extraEnv) => {
-        await fs.writeFile("root/elm.json", elmJsonContent);
-        await fs.createDirectory("root/src");
-
-        return {
-            make: async (content, options) => {
-                await fs.writeFile("root/src/Main.guida", content);
-
-                return await runGuida(extraEnv, {
-                    command: "make",
-                    path: "src/Main.guida",
-                    debug: !!options.debug,
-                    optimize: !!options.optimize,
-                    sourcemaps: !!options.sourcemaps
-                });
-            },
-            format: async (content) => {
-                return await runGuida(extraEnv, { command: "format", content });
-            },
-            install: async (pkg) => {
-                return await runGuida(extraEnv, { command: "install", pkg });
-            },
-            uninstall: async (pkg) => {
-                return await runGuida(extraEnv, { command: "uninstall", pkg });
-            }
-        };
+    make: async (config, path, options) => {
+        return await runGuida(config, {
+            command: "make",
+            path,
+            debug: !!options.debug,
+            optimize: !!options.optimize,
+            sourcemaps: !!options.sourcemaps
+        });
+    },
+    format: async (config, content) => {
+        return await runGuida(config, { command: "format", content });
+    },
+    install: async (config, pkg) => {
+        return await runGuida(config, { command: "install", pkg });
+    },
+    uninstall: async (config, pkg) => {
+        return await runGuida(config, { command: "uninstall", pkg });
+    },
+    diagnostics: async (config, args) => {
+        return await runGuida(config, { command: "diagnostics", ...args });
     }
 };