Mint, the new bundling tool chain for TurboWarp extensions

[kanebuilt]

Mint (or the Mint Tooling) is a custom, WIP bundling tool chain for TurboWarp extensions. I built it because handling large code in general is very finicky — especially TurboWarp extensions. Since there was no remedy for this, I made it myself. It concatenates JavaScript files in a source directory and uses a manifest to make the top comment header.

It's meant to be drop-in for the TurboWarp Extensions Gallery, in hopes that a Mint extension will be present in the Extensions Gallery at some point.

Try Mint out!

Screenshot in VS Code:

Mint's build output

Yes, Mint has a build system. But, since it's meant to be a drop-in tool chain, bundled extensions are easily readable. Here is the build output of my (also WIP) VFS extension, Next4.

// Name: Next4
// ID: Next4
// Version: 0.1.0
// Description: Persistent virtual filesystem extension for TurboWarp using OPFS, with namespaces, permissions, binary file support, and import/export tools.
// By: KaneBuilt <https://github.com/kanebuilt>
// License: LGPL-2.1-only

// This extension was created by the Mint tooling, a new
// bundling toolchain for TurboWarp extensions. Do not
// manually modify this file, go to:
// https://github.com/kanebuilt/next4

(function (Scratch) {
    'use strict';

    const __mintAssets__ = Object.assign(Object.create(null), {"lgpl.png":"data:image/png;base64,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"});
    const __mintManifest__ = Object.assign(Object.create(null), {"name":"Next4","id":"Next4","description":"Persistent virtual filesystem extension for TurboWarp using OPFS, with namespaces, permissions, binary file support, and import/export tools.","author":"KaneBuilt","authorLink":"https://github.com/kanebuilt","license":"LGPL-2.1-only","version":"0.1.0"});
    const mint = { asset: { get: function(name) { return Object.prototype.hasOwnProperty.call(__mintAssets__, name) ? __mintAssets__[name] : ""; } }, manifest: { get: function(key) { return Object.prototype.hasOwnProperty.call(__mintManifest__, key) ? __mintManifest__[key] : ""; } } };
      // src/index.js
      var Next4Extension = class {
        constructor() {
          this.root = null;
          this.namespaceHandle = null;
          this.isInitialized = false;
          this.currentDir = "/";
          this.journal = [];
          this.lastError = "";
          this.activeNamespace = "";
          this.permissions = /* @__PURE__ */ new Map();
        }
        getInfo() {
          return {
            id: "Next4",
            name: Scratch.translate("Next4"),
            color1: "#7d52ff",
            // Mint Assets is coming soon, Mint Assets is coming soon...
            menuIconURI: "data:image/svg+xml,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20height%3D%2224px%22%20viewBox%3D%220%20-960%20960%20960%22%20width%3D%2224px%22%20fill%3D%22%237d52ff%22%3E%3Cpath%20d%3D%22M480-120q-151%200-255.5-46.5T120-280v-400q0-66%20105.5-113T480-840q149%200%20254.5%2047T840-680v400q0%2067-104.5%20113.5T480-120Zm0-479q89%200%20179-25.5T760-679q-11-29-100.5-55T480-760q-91%200-178.5%2025.5T200-679q14%2030%20101.5%2055T480-599Zm0%20199q42%200%2081-4t74.5-11.5q35.5-7.5%2067-18.5t57.5-25v-120q-26%2014-57.5%2025t-67%2018.5Q600-528%20561-524t-81%204q-42%200-82-4t-75.5-11.5Q287-543%20256-554t-56-25v120q25%2014%2056%2025t66.5%2018.5Q358-408%20398-404t82%204Zm0%20200q46%200%2093.5-7t87.5-18.5q40-11.5%2067-26t32-29.5v-98q-26%2014-57.5%2025t-67%2018.5Q600-328%20561-324t-81%204q-42%200-82-4t-75.5-11.5Q287-343%20256-354t-56-25v99q5%2015%2031.5%2029t66.5%2025.5q40%2011.5%2088%2018.5t94%207Z%22%2F%3E%3C%2Fsvg%3E",
            blocks: [
              {
                opcode: "initFs",
                blockType: Scratch.BlockType.COMMAND,
                text: Scratch.translate("initialize filesystem with namespace [NAMESPACE]"),
                arguments: {
                  NAMESPACE: {
                    type: Scratch.ArgumentType.STRING,
                    defaultValue: "my-project"
                  }
                }
              },
              "---",
              {
                opcode: "listNamespaces",
                blockType: Scratch.BlockType.REPORTER,
                text: Scratch.translate("list all filesystems")
              },
              {
                opcode: "deleteNamespace",
                blockType: Scratch.BlockType.COMMAND,
                text: Scratch.translate("delete filesystem: [NAMESPACE]"),
                arguments: {
                  NAMESPACE: {
                    type: Scratch.ArgumentType.STRING,
                    defaultValue: "old-project"
                  }
                }
              },
              {
                opcode: "formatNamespace",
                blockType: Scratch.BlockType.COMMAND,
                text: Scratch.translate("format current filesystem")
              },
              "---",
              {
                opcode: "setPermission",
                blockType: Scratch.BlockType.COMMAND,
                text: Scratch.translate("set [PERM] to [VALUE] for path: [PATH]"),
                arguments: {
                  PERM: { type: Scratch.ArgumentType.STRING, menu: "permMenu" },
                  VALUE: { type: Scratch.ArgumentType.STRING, menu: "boolMenu" },
                  PATH: {
                    type: Scratch.ArgumentType.STRING,
                    defaultValue: "notes.txt"
                  }
                }
              },
              "---",
              {
                opcode: "manageEntry",
                blockType: Scratch.BlockType.COMMAND,
                text: Scratch.translate("[MODE] path: [PATH]"),
                arguments: {
                  MODE: { type: Scratch.ArgumentType.STRING, menu: "entryMenu" },
                  PATH: {
                    type: Scratch.ArgumentType.STRING,
                    defaultValue: "my-folder"
                  }
                }
              },
              {
                opcode: "moveOrCopy",
                blockType: Scratch.BlockType.COMMAND,
                text: Scratch.translate("[OP] path: [SRC] to: [DEST]"),
                arguments: {
                  OP: { type: Scratch.ArgumentType.STRING, menu: "moveCopyMenu" },
                  SRC: {
                    type: Scratch.ArgumentType.STRING,
                    defaultValue: "file.txt"
                  },
                  DEST: {
                    type: Scratch.ArgumentType.STRING,
                    defaultValue: "folder/file.txt"
                  }
                }
              },
              {
                opcode: "writeOrAppend",
                blockType: Scratch.BlockType.COMMAND,
                text: Scratch.translate("[MODE] path: [PATH] format: [FORMAT] content [CONTENT]"),
                arguments: {
                  MODE: { type: Scratch.ArgumentType.STRING, menu: "writeMenu" },
                  PATH: {
                    type: Scratch.ArgumentType.STRING,
                    defaultValue: "image.png"
                  },
                  FORMAT: { type: Scratch.ArgumentType.STRING, menu: "writeFormatMenu" },
                  CONTENT: {
                    type: Scratch.ArgumentType.STRING,
                    defaultValue: "Hello world"
                  }
                }
              },
              {
                opcode: "readFile",
                blockType: Scratch.BlockType.REPORTER,
                text: Scratch.translate("read path: [PATH] as [FORMAT]"),
                arguments: {
                  PATH: {
                    type: Scratch.ArgumentType.STRING,
                    defaultValue: "notes.txt"
                  },
                  FORMAT: { type: Scratch.ArgumentType.STRING, menu: "formatMenu" }
                }
              },
              "---",
              {
                opcode: "exportFsString",
                blockType: Scratch.BlockType.REPORTER,
                text: Scratch.translate("export filesystem")
              },
              {
                opcode: "importFsString",
                blockType: Scratch.BlockType.COMMAND,
                text: Scratch.translate("import filesystem from: [STR]"),
                arguments: {
                  STR: { type: Scratch.ArgumentType.STRING, defaultValue: "{}" }
                }
              },
              "---",
              {
                opcode: "listFiles",
                blockType: Scratch.BlockType.REPORTER,
                text: Scratch.translate("list files/directories in path: [PATH]"),
                arguments: {
                  PATH: { type: Scratch.ArgumentType.STRING, defaultValue: "/" }
                }
              },
              {
                opcode: "searchFiles",
                blockType: Scratch.BlockType.REPORTER,
                text: Scratch.translate("search for [QUERY] in filesystem"),
                arguments: {
                  QUERY: { type: Scratch.ArgumentType.STRING, defaultValue: ".png" }
                }
              },
              {
                opcode: "exists",
                blockType: Scratch.BlockType.BOOLEAN,
                text: Scratch.translate("does path: [PATH] exist?"),
                arguments: {
                  PATH: {
                    type: Scratch.ArgumentType.STRING,
                    defaultValue: "notes.txt"
                  }
                }
              }
            ],
            menus: {
              entryMenu: { acceptReporters: true, items: ["create", "delete"] },
              writeMenu: { acceptReporters: true, items: ["write", "append"] },
              writeFormatMenu: { acceptReporters: true, items: ["text", "base64", "data"] },
              formatMenu: {
                acceptReporters: true,
                items: ["text", "base64", "data: URI"]
              },
              permMenu: { acceptReporters: true, items: ["read", "write", "see"] },
              boolMenu: { acceptReporters: true, items: ["allow", "deny"] },
              moveCopyMenu: { acceptReporters: true, items: ["move", "copy"] }
            }
          };
        }
        async _init(namespace) {
          try {
            const storageRoot = await navigator.storage.getDirectory();
            const next4Root = await storageRoot.getDirectoryHandle(".next4_systems", {
              create: true
            });
            const safeNamespace = namespace.replace(/[^a-z0-9_-]/gi, "_") || "default";
            this.namespaceHandle = await next4Root.getDirectoryHandle(safeNamespace, {
              create: true
            });
            try {
              const permFile = await this.namespaceHandle.getFileHandle(".perms", {
                create: true
              });
              const file = await permFile.getFile();
              const text = await file.text();
              if (text) {
                const data = JSON.parse(text);
                this.permissions = new Map(Object.entries(data));
              }
            } catch (_e) {
              this.permissions = /* @__PURE__ */ new Map();
            }
            this.activeNamespace = safeNamespace;
            this.isInitialized = true;
            return true;
          } catch (e) {
            this.lastError = e.toString();
            return false;
          }
        }
        async _savePermissions() {
          try {
            const permFile = await this.namespaceHandle.getFileHandle(".perms", {
              create: true
            });
            const writable = await permFile.createWritable();
            const obj = Object.fromEntries(this.permissions);
            await writable.write(JSON.stringify(obj));
            await writable.close();
          } catch (e) {
            console.error("Failed to save permissions", e);
          }
        }
        _getPerms(path) {
          return this.permissions.get(path) || { read: true, write: true, see: true };
        }
        _resolvePath(path) {
          if (!path.startsWith("/")) {
            path = this.currentDir + (this.currentDir.endsWith("/") ? "" : "/") + path;
          }
          return path.split("/").filter(Boolean);
        }
        async listNamespaces() {
          try {
            const storageRoot = await navigator.storage.getDirectory();
            const next4Root = await storageRoot.getDirectoryHandle(".next4_systems", {
              create: true
            });
            const namespaces = [];
            for await (const entry of next4Root.values()) {
              if (entry.kind === "directory") namespaces.push(entry.name);
            }
            return JSON.stringify(namespaces);
          } catch (_e) {
            return "[]";
          }
        }
        async deleteNamespace(args) {
          try {
            const storageRoot = await navigator.storage.getDirectory();
            const next4Root = await storageRoot.getDirectoryHandle(".next4_systems", {
              create: true
            });
            const target = args.NAMESPACE.replace(/[^a-z0-9_-]/gi, "_");
            await next4Root.removeEntry(target, { recursive: true });
            if (this.activeNamespace === target) {
              this.isInitialized = false;
              this.namespaceHandle = null;
            }
          } catch (e) {
            this.lastError = e.toString();
          }
        }
        async formatNamespace() {
          if (!this.isInitialized) return;
          try {
            const names = [];
            for await (const entry of this.namespaceHandle.values()) {
              names.push(entry.name);
            }
            for (const name of names) {
              await this.namespaceHandle.removeEntry(name, { recursive: true });
            }
            this.permissions.clear();
            await this._savePermissions();
          } catch (e) {
            this.lastError = e.toString();
          }
        }
        async initFs(args) {
          return await this._init(args.NAMESPACE);
        }
        async setPermission(args) {
          if (!this.isInitialized) return;
          const path = args.PATH;
          const current = this._getPerms(path);
          current[args.PERM] = args.VALUE === "allow";
          this.permissions.set(path, current);
          await this._savePermissions();
        }
        async manageEntry(args) {
          if (!this.isInitialized) return;
          if (!this._getPerms(args.PATH).write) return;
          try {
            const parts = this._resolvePath(args.PATH);
            if (args.MODE === "create") {
              let dirHandle = this.namespaceHandle;
              for (const part of parts) {
                dirHandle = await dirHandle.getDirectoryHandle(part, {
                  create: true
                });
              }
            } else if (args.MODE === "delete") {
              const target = parts.pop();
              let dirHandle = this.namespaceHandle;
              for (const part of parts) {
                dirHandle = await dirHandle.getDirectoryHandle(part);
              }
              await dirHandle.removeEntry(target, { recursive: true });
            }
          } catch (e) {
            this.lastError = e.toString();
          }
        }
        async writeOrAppend(args) {
          if (!this.isInitialized) return;
          if (!this._getPerms(args.PATH).write) return;
          try {
            const parts = this._resolvePath(args.PATH);
            const fileName = parts.pop();
            let dirHandle = this.namespaceHandle;
            for (const part of parts) {
              dirHandle = await dirHandle.getDirectoryHandle(part, { create: true });
            }
            const fileHandle = await dirHandle.getFileHandle(fileName, {
              create: true
            });
            const content = String(args.CONTENT ?? "");
            const format = String(args.FORMAT ?? "").toLowerCase();
            let blob;
            if (format === "data") {
              if (!content.startsWith("data:")) {
                throw new Error("CONTENT must be a data URI when FORMAT is 'data'.");
              }
              const res = await Scratch.fetch(content);
              blob = await res.blob();
            } else if (format === "base64") {
              const byteCharacters = atob(content);
              const byteNumbers = new Array(byteCharacters.length);
              for (let i = 0; i < byteCharacters.length; i++) {
                byteNumbers[i] = byteCharacters.charCodeAt(i);
              }
              blob = new Blob([new Uint8Array(byteNumbers)]);
            } else if (format === "text") {
              blob = new Blob([content]);
            } else {
              throw new Error("FORMAT must be 'text', 'base64', or 'data' for write/append operations.");
            }
            const writable = await fileHandle.createWritable(
              args.MODE === "append" ? { keepExistingData: true } : {}
            );
            if (args.MODE === "append") {
              const file = await fileHandle.getFile();
              await writable.seek(file.size);
            }
            await writable.write(blob);
            await writable.close();
          } catch (e) {
            this.lastError = e.toString();
          }
        }
        async readFile(args) {
          if (!this.isInitialized) return "";
          if (!this._getPerms(args.PATH).read) return "Permission Denied";
          try {
            const parts = this._resolvePath(args.PATH);
            const fileName = parts.pop();
            let dirHandle = this.namespaceHandle;
            for (const part of parts) {
              dirHandle = await dirHandle.getDirectoryHandle(part);
            }
            const fileHandle = await dirHandle.getFileHandle(fileName);
            const file = await fileHandle.getFile();
            if (args.FORMAT === "text") return await file.text();
            const buffer = await file.arrayBuffer();
            const bytes = new Uint8Array(buffer);
            let binary = "";
            for (let i = 0; i < bytes.byteLength; i++) binary += String.fromCharCode(bytes[i]);
            const base64 = btoa(binary);
            if (args.FORMAT === "base64") return base64;
            if (args.FORMAT === "data: URI") {
              return `data:${file.type || "application/octet-stream"};base64,${base64}`;
            }
            return await file.text();
          } catch (_e) {
            return "";
          }
        }
        async _copyEntryRecursive(parentHandle, name, destParent, destName) {
          let fileHandle;
          try {
            fileHandle = await parentHandle.getFileHandle(name);
          } catch (_e) {
          }
          if (fileHandle) {
            const file = await fileHandle.getFile();
            const newFile = await destParent.getFileHandle(destName, { create: true });
            const writable = await newFile.createWritable();
            await writable.write(await file.arrayBuffer());
            await writable.close();
            return;
          }
          const dirHandle = await parentHandle.getDirectoryHandle(name);
          const newDir = await destParent.getDirectoryHandle(destName, { create: true });
          for await (const entry of dirHandle.values()) {
            await this._copyEntryRecursive(dirHandle, entry.name, newDir, entry.name);
          }
        }
        async moveOrCopy(args) {
          if (!this.isInitialized) return;
          if (!this._getPerms(args.SRC).read || !this._getPerms(args.DEST).write) return;
          try {
            const srcParts = this._resolvePath(args.SRC);
            const srcName = srcParts.pop();
            let srcDir = this.namespaceHandle;
            for (const p of srcParts) srcDir = await srcDir.getDirectoryHandle(p);
            const destParts = this._resolvePath(args.DEST);
            const destName = destParts.pop();
            let destDir = this.namespaceHandle;
            for (const p of destParts) destDir = await destDir.getDirectoryHandle(p, { create: true });
            await this._copyEntryRecursive(srcDir, srcName, destDir, destName);
            if (args.OP === "move") {
              await srcDir.removeEntry(srcName, { recursive: true });
            }
          } catch (e) {
            this.lastError = e.toString();
          }
        }
        async searchFiles(args) {
          if (!this.isInitialized) return "[]";
          const query = args.QUERY.toLowerCase();
          const results = [];
          const walk = async (handle, path = "") => {
            for await (const entry of handle.values()) {
              const entryPath = path + "/" + entry.name;
              if (entry.name.toLowerCase().includes(query)) {
                if (this._getPerms(entryPath).see) {
                  results.push(entryPath);
                }
              }
              if (entry.kind === "directory") await walk(entry, entryPath);
            }
          };
          await walk(this.namespaceHandle);
          return JSON.stringify(results);
        }
        async exportFsString() {
          if (!this.isInitialized) return "";
          const exportData = {
            version: "next4-v1",
            namespace: this.activeNamespace,
            permissions: Object.fromEntries(this.permissions),
            files: []
          };
          const walk = async (handle, path = "") => {
            for await (const entry of handle.values()) {
              const entryPath = path + "/" + entry.name;
              if (entry.name === ".perms") continue;
              if (entry.kind === "file") {
                const file = await entry.getFile();
                const buffer = await file.arrayBuffer();
                const bytes = new Uint8Array(buffer);
                let binary = "";
                for (let i = 0; i < bytes.byteLength; i++) binary += String.fromCharCode(bytes[i]);
                exportData.files.push({
                  path: entryPath,
                  type: "file",
                  data: btoa(binary)
                });
              } else {
                exportData.files.push({ path: entryPath, type: "dir" });
                await walk(entry, entryPath);
              }
            }
          };
          await walk(this.namespaceHandle);
          return JSON.stringify(exportData);
        }
        async importFsString(args) {
          if (!this.isInitialized || !args.STR) return;
          try {
            const data = JSON.parse(args.STR);
            if (data.version !== "next4-v1") return;
            this.permissions = new Map(Object.entries(data.permissions));
            await this._savePermissions();
            for (const item of data.files) {
              const parts = item.path.split("/").filter(Boolean);
              if (item.type === "dir") {
                let dh = this.namespaceHandle;
                for (const p of parts) dh = await dh.getDirectoryHandle(p, { create: true });
              } else {
                const fileName = parts.pop();
                let dh = this.namespaceHandle;
                for (const p of parts) dh = await dh.getDirectoryHandle(p, { create: true });
                const fh = await dh.getFileHandle(fileName, { create: true });
                const writable = await fh.createWritable();
                const binary = atob(item.data);
                const bytes = new Uint8Array(binary.length);
                for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
                await writable.write(bytes);
                await writable.close();
              }
            }
          } catch (error) {
            console.error("Next4 Import failed:", error);
          }
        }
        async listFiles(args) {
          if (!this.isInitialized) return "[]";
          try {
            const parts = this._resolvePath(args.PATH);
            let dirHandle = this.namespaceHandle;
            for (const part of parts) dirHandle = await dirHandle.getDirectoryHandle(part);
            const results = [];
            for await (const entry of dirHandle.values()) {
              const fullPath = (args.PATH === "/" ? "" : args.PATH) + "/" + entry.name;
              if (this._getPerms(fullPath).see && entry.name !== ".perms") {
                results.push(entry.name + (entry.kind === "directory" ? "/" : ""));
              }
            }
            return JSON.stringify(results);
          } catch (_e) {
            return "[]";
          }
        }
        async exists(args) {
          if (!this.isInitialized || !this._getPerms(args.PATH).see) return false;
          try {
            const parts = this._resolvePath(args.PATH);
            const target = parts.pop();
            let dh = this.namespaceHandle;
            for (const p of parts) dh = await dh.getDirectoryHandle(p);
            try {
              await dh.getFileHandle(target);
              return true;
            } catch (_e) {
              await dh.getDirectoryHandle(target);
              return true;
            }
          } catch (_e) {
            return false;
          }
        }
      };
      

    Scratch.extensions.register(new Next4Extension());
})(Scratch);