@ldgerrits/rogen 1.4.0

package/LICENSE.md

@@ -0,0 +1,7 @@
+Copyright © 2026 Loek Gerrits
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,33 @@
+<div>&nbsp;</div>
+
+<div align="center">
+	<img src="docs/public/icon.png" alt="Rogen" width="100" />
+</div>
+
+<div align="center">
+    <a href="https://rogen-playfully.vercel.app"><strong>Documentation</strong></a>
+</div>
+
+---
+
+Bring feature-based architecture to Roblox.
+Build self-contained systems with client, server, and shared code in one place.
+Rogen routes every file to the correct Roblox service automatically.
+
+## Features
+
+- **Feature Folders:** Store related client, server and shared scripts inside a single folder.
+- **Auto-Routing:** Route files to Roblox services automatically using Rojo or Argon.
+- **Multi-Place Support:** Merge multiple source directories to share core systems across different places.
+- **Environment Tags:** Filter test files and inject mock files at build time using tags.
+- **Custom Pathing:** Control the final output structure using invisible folders and marker files.
+- **Modern Tooling:** Support Luau, roblox-ts, and Darklua pipelines out of the box.
+
+## Contributing
+
+Pull requests are welcome!
+Read the [contribution guidelines](CONTRIBUTING.md) to set up your local environment, run tests, and submit code changes.
+
+## License
+
+See the [licence](LICENSE.md) for details.

package/dist/build.js

@@ -0,0 +1,228 @@
+import { promises as fsp } from "fs";
+import path from "path";
+import picomatch from "picomatch";
+import { applyCasing, getOrCreateNode, pruneObject, sortObject, findMissingPaths, toPosix, collapseFolders, isInitFile, isValidSource, findExposedDataFiles, } from "./tree.js";
+import { resolveRoute, } from "./route.js";
+import { serviceParents, generateRoutingMaps, defaultConfig, } from "./constants.js";
+const SYSTEM_MARKERS = {
+    structure: true,
+    verbatim: true,
+    unwrap: true,
+};
+function buildSubPath(sourceRel) {
+    const segments = sourceRel.split(/[\\/]/).filter(Boolean);
+    let rootIndex = 0;
+    while (rootIndex < segments.length &&
+        (segments[rootIndex] === ".." || segments[rootIndex] === ".")) {
+        rootIndex++;
+    }
+    if (rootIndex + 1 >= segments.length) {
+        return "";
+    }
+    return segments.slice(rootIndex + 1).join("/");
+}
+async function listTree(dir) {
+    const listings = new Map();
+    async function scan(currentDir) {
+        try {
+            const entries = await fsp.readdir(currentDir, {
+                withFileTypes: true,
+            });
+            listings.set(currentDir, entries);
+            const hasInit = entries.some((e) => e.isFile() && isInitFile(e.name));
+            const hasSync = entries.some((e) => e.isFile() && e.name === ".sync");
+            if (hasInit || hasSync)
+                return;
+            const subdirs = entries
+                .filter((e) => e.isDirectory())
+                .map((e) => path.join(currentDir, e.name));
+            await Promise.all(subdirs.map(scan));
+        }
+        catch (error) {
+            if (error instanceof Error &&
+                "code" in error &&
+                error.code === "ENOENT")
+                return;
+            throw error;
+        }
+    }
+    await scan(dir);
+    return listings;
+}
+function compileTagRegexes(activeEnvs) {
+    return Array.from(activeEnvs).map((env) => ({
+        suffix: new RegExp(`[\\.\\-_\\+]${env}$`, "i"),
+        prefix: new RegExp(`^${env}[\\.\\-_\\+]`, "i"),
+        middle: new RegExp(`[\\.\\-_\\+]${env}(?=[\\.\\-_\\+])`, "i"),
+    }));
+}
+function buildDirectoryMarkers(sourcePath, listings, routingMaps, knownFlags) {
+    const directoryMarkers = {};
+    for (const [dir, entries] of listings.entries()) {
+        const markers = [];
+        for (const entry of entries) {
+            if (entry.isFile() && entry.name.startsWith(".")) {
+                const possibleMarker = entry.name.slice(1).toLowerCase();
+                if (possibleMarker in SYSTEM_MARKERS ||
+                    routingMaps.lowerCaseMap[possibleMarker] ||
+                    knownFlags.has(possibleMarker)) {
+                    markers.push(possibleMarker);
+                }
+            }
+        }
+        if (markers.length > 0) {
+            let relDir = path.relative(sourcePath, dir);
+            relDir = relDir.split(path.sep).join("/");
+            directoryMarkers[relDir] = markers;
+        }
+    }
+    return directoryMarkers;
+}
+function walkSource(dir, sourcePath, listings, callback) {
+    const entries = listings.get(dir);
+    if (!entries)
+        return;
+    // Rojo expects a specific structure for folders with an init.luau file that we cannot deviate from.
+    // Because of this, we must return early if an initialization file has been found.
+    const syncFile = entries.find((e) => e.isFile() && e.name === ".sync");
+    if (syncFile) {
+        callback(dir, false, true);
+        return;
+    }
+    const initFile = entries.find((e) => e.isFile() && isInitFile(e.name));
+    if (initFile) {
+        callback(path.join(dir, initFile.name), true, false);
+        return;
+    }
+    for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            walkSource(fullPath, sourcePath, listings, callback);
+        }
+        else if (isValidSource(entry.name)) {
+            callback(fullPath, false, false);
+        }
+    }
+}
+export async function build(targetConfig, baseProjectTree, config, env, sourcePaths, cliArgs, anchor) {
+    const modeCopy = { ...targetConfig };
+    if (cliArgs.output) {
+        modeCopy.output = path.resolve(process.cwd(), cliArgs.output);
+    }
+    else {
+        modeCopy.output = path.resolve(anchor, targetConfig.output);
+    }
+    if (cliArgs.build) {
+        modeCopy.build = cliArgs.build;
+    }
+    const rojoTree = structuredClone(baseProjectTree);
+    const mergedTags = { ...(config.tags || {}), ...(modeCopy.tags || {}) };
+    const knownTags = new Set(Object.keys(config.tags || {}).map((t) => t.toLowerCase()));
+    const activeTags = new Set(Object.keys(mergedTags)
+        .filter((t) => mergedTags[t])
+        .map((t) => t.toLowerCase()));
+    const cliTags = (cliArgs.tag || []).map((t) => t.toLowerCase());
+    for (const tag of cliTags) {
+        activeTags.add(tag);
+    }
+    for (const tag of activeTags) {
+        if (!knownTags.has(tag)) {
+            throw new Error(`active tag "${tag}" is not declared in the root "tags" object.`);
+        }
+    }
+    const tagRegexes = compileTagRegexes(activeTags);
+    const context = {
+        source: config.source || structuredClone(defaultConfig.source),
+        ...modeCopy,
+        isTsProject: env.isTsProject || (cliArgs.mode?.includes("ts") ?? false),
+        emitLegacyScripts: rojoTree.emitLegacyScripts ?? true,
+        name: rojoTree.name,
+        routingMaps: generateRoutingMaps(config.aliases || {}),
+        verbatim: config.verbatim ?? defaultConfig.verbatim,
+        unwrap: config.unwrap ?? defaultConfig.unwrap,
+        directoryMarkers: {},
+        knownTags,
+        activeTags,
+        tagRegexes,
+    };
+    const combinedGlobIgnorePaths = Array.from(new Set([
+        ...(config.globIgnorePaths || []),
+        ...(modeCopy.globIgnorePaths || []),
+    ]));
+    const isIgnored = combinedGlobIgnorePaths.length > 0
+        ? picomatch(combinedGlobIgnorePaths)
+        : () => false;
+    const nodeOrigins = new WeakMap();
+    const collisions = [];
+    let fileCount = 0;
+    for (const sourcePath of sourcePaths) {
+        const relativePath = path.relative(anchor, sourcePath);
+        const subPath = buildSubPath(relativePath);
+        const listings = await listTree(sourcePath);
+        const directoryMarkers = buildDirectoryMarkers(sourcePath, listings, context.routingMaps, knownTags);
+        const newContext = {
+            ...context,
+            build: path.join(context.build, subPath),
+            directoryMarkers,
+        };
+        walkSource(sourcePath, sourcePath, listings, (filepath, isInit, isSync) => {
+            const relativePath = path.relative(sourcePath, filepath);
+            if (relativePath && isIgnored(toPosix(relativePath)))
+                return;
+            const { targetService, wrapperFolder, virtualParts, nodeName, projectPath, dropped, unwrap, } = resolveRoute(relativePath, isInit, newContext, isSync);
+            if (dropped)
+                return;
+            fileCount++;
+            let current = rojoTree.tree;
+            if (serviceParents[targetService]) {
+                current = getOrCreateNode(current, serviceParents[targetService]);
+            }
+            current = getOrCreateNode(current, targetService);
+            if (!unwrap) {
+                current = getOrCreateNode(current, applyCasing(wrapperFolder, config.casing), "Folder");
+            }
+            for (const part of virtualParts) {
+                current = getOrCreateNode(current, part, "Folder");
+            }
+            const existingNodeRaw = current[nodeName];
+            if (existingNodeRaw && existingNodeRaw.$path) {
+                const origin = nodeOrigins.get(existingNodeRaw);
+                if (origin && origin.sourcePath === sourcePath) {
+                    collisions.push(`Name collision: "${origin.filepath}" and "${relativePath}" both map to the node "${nodeName}".`);
+                }
+            }
+            const existingNode = existingNodeRaw || {};
+            const newNode = {
+                ...existingNode,
+                $path: projectPath,
+            };
+            if (newNode.$className === "Folder") {
+                delete newNode.$className;
+            }
+            current[nodeName] = newNode;
+            nodeOrigins.set(newNode, {
+                sourcePath,
+                filepath: relativePath,
+            });
+        });
+    }
+    const outputDir = path.dirname(modeCopy.output);
+    const removed = [];
+    const prunedTree = pruneObject(rojoTree.tree, context.build, outputDir, removed);
+    collapseFolders(prunedTree, context.build, outputDir);
+    rojoTree.tree = prunedTree;
+    const sortedTree = sortObject(rojoTree);
+    const missingPaths = findMissingPaths(sortedTree.tree, context.build, outputDir);
+    const exposedDataFiles = findExposedDataFiles(sortedTree.tree);
+    return {
+        output: modeCopy.output,
+        tree: sortedTree,
+        missingPaths,
+        removed,
+        collisions,
+        exposedDataFiles,
+        name: context.name,
+        buildDir: context.build,
+        fileCount,
+    };
+}