@ldgerrits/rogen 1.4.0

package/dist/index.js

@@ -0,0 +1,110 @@
+import fs from "fs";
+import path from "path";
+import chokidar from "chokidar";
+import { printHelp, parseCliArgs } from "./cli.js";
+import { resolveConfigPath, loadConfig, getEnvironment, resolveActiveModes, createFallbackConfig, } from "./config.js";
+import { execute } from "./execute.js";
+import { version } from "./constants.js";
+import { ConsoleLogger } from "./logger.js";
+async function main() {
+    const logger = new ConsoleLogger();
+    const cliArgs = parseCliArgs(process.argv.slice(2), logger);
+    if (cliArgs.help) {
+        printHelp(logger);
+        process.exit(0);
+    }
+    if (cliArgs.version) {
+        logger.info(`rogen ${version}`);
+        process.exit(0);
+    }
+    if (cliArgs.init) {
+        const cwd = process.cwd();
+        const targetPath = path.resolve(cwd, ".rogen.json");
+        if (fs.existsSync(targetPath)) {
+            logger.error(`a .rogen.json file already exists in this directory.`);
+            process.exit(1);
+        }
+        const config = createFallbackConfig(cwd);
+        const isTs = fs.existsSync(path.join(cwd, "tsconfig.json"));
+        const isDarklua = fs.existsSync(path.join(cwd, ".darklua.json")) ||
+            fs.existsSync(path.join(cwd, ".darklua.json5"));
+        if (isTs) {
+            delete config.luau;
+        }
+        else {
+            delete config.ts;
+        }
+        if (!isDarklua) {
+            delete config.darklua;
+        }
+        for (const mode of ["luau", "ts", "darklua"]) {
+            if (config[mode]) {
+                delete config[mode].tags;
+                delete config[mode].globIgnorePaths;
+            }
+        }
+        delete config.globIgnorePaths;
+        delete config.tags;
+        delete config.aliases;
+        delete config.verbatim;
+        delete config.casing;
+        delete config.unwrap;
+        fs.writeFileSync(targetPath, JSON.stringify(config, null, "\t"));
+        logger.success(`Created .rogen.json in the current directory.`);
+        process.exit(0);
+    }
+    const configPath = resolveConfigPath(cliArgs.config, logger);
+    const { config, anchor } = loadConfig(configPath, cliArgs.project);
+    const rawSources = cliArgs.source || config.source;
+    const sourceDirs = Array.isArray(rawSources) ? rawSources : [rawSources];
+    const resolveBase = cliArgs.source ? process.cwd() : anchor;
+    const sourcePaths = sourceDirs.map((s) => {
+        const sourcePath = path.resolve(resolveBase, s);
+        if (!fs.existsSync(sourcePath)) {
+            throw new Error(`Source directory not found: ${sourcePath}`);
+        }
+        return sourcePath;
+    });
+    const env = getEnvironment(anchor, cliArgs.mode);
+    const activeModes = resolveActiveModes(config, cliArgs.mode, env);
+    const success = await execute(sourcePaths, env, activeModes, config.project, config, cliArgs, anchor, logger);
+    if (!success) {
+        process.exit(1);
+    }
+    if (cliArgs.watch) {
+        logger.info(`Watching for file changes in: "${sourceDirs.join(", ")}" (Ctrl+C to stop)`);
+        const watcher = chokidar.watch(sourcePaths, {
+            persistent: true,
+            ignoreInitial: true,
+        });
+        let debounceTimeout;
+        let isBuilding = false;
+        watcher.on("all", (event, filePath) => {
+            logger.trace(`File change detected (${event}): ${filePath}`);
+            clearTimeout(debounceTimeout);
+            debounceTimeout = setTimeout(() => {
+                if (isBuilding)
+                    return;
+                isBuilding = true;
+                try {
+                    execute(sourcePaths, env, activeModes, config.project, config, cliArgs, anchor, logger);
+                }
+                catch (err) {
+                    logger.error(err instanceof Error ? err : String(err));
+                }
+                finally {
+                    isBuilding = false;
+                }
+            }, 100);
+        });
+        watcher.on("error", (error) => logger.error(`${error}`));
+        await new Promise(() => { }); // Keep alive
+    }
+}
+export default function run() {
+    const logger = new ConsoleLogger();
+    main().catch((error) => {
+        logger.error(`${error.message}`);
+        process.exit(1);
+    });
+}

package/dist/logger.js

@@ -0,0 +1,104 @@
+export var LogLevel;
+(function (LogLevel) {
+    LogLevel[LogLevel["Off"] = 0] = "Off";
+    LogLevel[LogLevel["Error"] = 1] = "Error";
+    LogLevel[LogLevel["Warn"] = 2] = "Warn";
+    LogLevel[LogLevel["Success"] = 3] = "Success";
+    LogLevel[LogLevel["Info"] = 4] = "Info";
+    LogLevel[LogLevel["Debug"] = 5] = "Debug";
+    LogLevel[LogLevel["Trace"] = 6] = "Trace";
+})(LogLevel || (LogLevel = {}));
+export class AbstractLogger {
+    level = LogLevel.Info;
+    setLevel(level) {
+        this.level = level;
+    }
+    getLevel() {
+        return this.level;
+    }
+    canLog(level) {
+        return this.level !== LogLevel.Off && this.level >= level;
+    }
+    format(message, args) {
+        let result = message instanceof Error
+            ? message.stack || message.message
+            : message;
+        for (const arg of args) {
+            if (arg instanceof Error) {
+                result += " " + (arg.stack || arg.message);
+            }
+            else if (typeof arg === "object") {
+                try {
+                    result += " " + JSON.stringify(arg);
+                }
+                catch {
+                    result += " [Unserializable Object]";
+                }
+            }
+            else {
+                result += " " + arg;
+            }
+        }
+        return result;
+    }
+}
+export function getTimeStamp(wrapInBrackets = true) {
+    const now = new Date();
+    const h = String(now.getHours()).padStart(2, "0");
+    const m = String(now.getMinutes()).padStart(2, "0");
+    const s = String(now.getSeconds()).padStart(2, "0");
+    const timeStamp = `${h}:${m}:${s}`;
+    return wrapInBrackets ? `[${timeStamp}]` : timeStamp;
+}
+export class ConsoleLogger extends AbstractLogger {
+    colors = {
+        reset: "\x1b[0m",
+        red: "\x1b[31m",
+        green: "\x1b[32m",
+        yellow: "\x1b[33m",
+        gray: "\x1b[90m",
+        cyan: "\x1b[36m",
+    };
+    error(message, ...args) {
+        if (this.canLog(LogLevel.Error)) {
+            console.error(`${this.colors.red}error:${this.colors.reset} ${this.format(message, args)}`);
+        }
+    }
+    warn(message, ...args) {
+        if (this.canLog(LogLevel.Warn)) {
+            console.warn(`${this.colors.yellow}warning:${this.colors.reset} ${this.format(message, args)}`);
+        }
+    }
+    success(message, ...args) {
+        if (this.canLog(LogLevel.Info)) {
+            console.info(`${getTimeStamp()} ${this.colors.green}success:${this.colors.reset} ${this.format(message, args)}`);
+        }
+    }
+    info(message, ...args) {
+        if (this.canLog(LogLevel.Info)) {
+            console.info(this.format(message, args));
+        }
+    }
+    debug(message, ...args) {
+        if (this.canLog(LogLevel.Debug)) {
+            console.debug(`${this.colors.gray}[debug] ${this.format(message, args)}${this.colors.reset}`);
+        }
+    }
+    trace(message, ...args) {
+        if (this.canLog(LogLevel.Trace)) {
+            console.debug(`${this.colors.cyan}[trace] ${this.format(message, args)}${this.colors.reset}`);
+        }
+    }
+}
+export class NullLogger {
+    setLevel(_level) { }
+    getLevel() {
+        return LogLevel.Off;
+    }
+    error(_message, ..._args) { }
+    warn(_message, ..._args) { }
+    success(_message, ..._args) { }
+    info(_message, ..._args) { }
+    debug(_message, ..._args) { }
+    trace(_message, ..._args) { }
+}

package/dist/route.js

@@ -0,0 +1,345 @@
+import path from "path";
+import { serviceAliases, serverContainers, clientContainers, } from "./constants.js";
+import { toPosix } from "./tree.js";
+function resolveFolderRouting(parts, context) {
+    const { routingMaps, directoryMarkers, activeTags } = context;
+    const { lowerCaseMap } = routingMaps;
+    const virtualParts = [];
+    let targetService = "ReplicatedStorage";
+    let lastRouteKeyword = null;
+    let tagKeyword = null;
+    const flags = {
+        structure: false,
+        verbatim: false,
+        unwrap: false,
+    };
+    // Marker routing
+    const rootMarkers = directoryMarkers[""];
+    if (rootMarkers) {
+        if (rootMarkers.includes("structure")) {
+            flags.structure = true;
+        }
+        if (rootMarkers.includes("verbatim")) {
+            flags.verbatim = true;
+        }
+        if (rootMarkers.includes("unwrap")) {
+            flags.unwrap = true;
+        }
+        if (!flags.structure) {
+            const routingMarker = rootMarkers.find((m) => lowerCaseMap[m]);
+            if (routingMarker) {
+                targetService = lowerCaseMap[routingMarker];
+                lastRouteKeyword = routingMarker;
+                if (serviceAliases.has(routingMarker))
+                    tagKeyword = routingMarker;
+            }
+        }
+    }
+    // Folder path routing
+    let currentPath = "";
+    for (const part of parts) {
+        currentPath = currentPath ? `${currentPath}/${part}` : part;
+        let lowerPart = part.toLowerCase();
+        let isInvisible = false;
+        if (lowerPart.startsWith("(") && lowerPart.endsWith(")")) {
+            isInvisible = true;
+            lowerPart = lowerPart.slice(1, -1);
+        }
+        const markers = directoryMarkers
+            ? directoryMarkers[currentPath]
+            : undefined;
+        if (markers) {
+            if (markers.includes("structure")) {
+                flags.structure = true;
+            }
+            if (markers.includes("verbatim")) {
+                flags.verbatim = true;
+            }
+            if (markers.includes("unwrap")) {
+                flags.unwrap = true;
+            }
+        }
+        if (flags.structure) {
+            if (!activeTags.has(lowerPart)) {
+                virtualParts.push(part);
+            }
+            continue;
+        }
+        const matchedService = lowerCaseMap[lowerPart];
+        if (markers) {
+            const routingMarker = markers.find((m) => lowerCaseMap[m]);
+            if (routingMarker) {
+                targetService = lowerCaseMap[routingMarker];
+                lastRouteKeyword = routingMarker;
+                if (serviceAliases.has(routingMarker))
+                    tagKeyword = routingMarker;
+                if (!matchedService &&
+                    !activeTags.has(lowerPart) &&
+                    !isInvisible) {
+                    virtualParts.push(part);
+                }
+                continue;
+            }
+        }
+        if (matchedService) {
+            targetService = matchedService;
+            lastRouteKeyword = lowerPart;
+            if (serviceAliases.has(lowerPart)) {
+                tagKeyword = lowerPart;
+            }
+        }
+        else {
+            if (!activeTags.has(lowerPart) && !isInvisible) {
+                virtualParts.push(part);
+            }
+        }
+    }
+    return {
+        targetService,
+        virtualParts,
+        lastRouteKeyword,
+        tagKeyword,
+        flags,
+    };
+}
+function resolveAffixes(basename, isInit, routingMaps) {
+    const { lowerCaseMap, mergedServices, separatorSuffixRegex, pascalCaseSuffixRegex, separatorPrefixRegex, camelCasePrefixRegex, } = routingMaps;
+    let match = basename.match(separatorSuffixRegex);
+    if (match && match[0].length < basename.length) {
+        const suffix = match[1].toLowerCase();
+        return {
+            mappedService: lowerCaseMap[suffix],
+            matchedLength: match[0].length,
+            exactMatch: match[0],
+            tagKeyword: !isInit && serviceAliases.has(suffix) ? suffix : undefined,
+            isPrefix: false,
+        };
+    }
+    match = basename.match(pascalCaseSuffixRegex);
+    if (match && match[0].length < basename.length) {
+        const suffix = match[1].toLowerCase();
+        return {
+            mappedService: mergedServices[match[1]],
+            matchedLength: match[0].length,
+            exactMatch: match[0],
+            tagKeyword: !isInit && serviceAliases.has(suffix) ? suffix : undefined,
+            isPrefix: false,
+        };
+    }
+    match = basename.match(separatorPrefixRegex);
+    if (match && match[0].length < basename.length) {
+        const prefix = match[1].toLowerCase();
+        return {
+            mappedService: lowerCaseMap[prefix],
+            matchedLength: match[0].length,
+            exactMatch: match[0],
+            tagKeyword: !isInit && serviceAliases.has(prefix) ? prefix : undefined,
+            isPrefix: true,
+        };
+    }
+    match = basename.match(camelCasePrefixRegex);
+    if (match && match[0].length < basename.length) {
+        const prefix = match[1].toLowerCase();
+        return {
+            mappedService: lowerCaseMap[prefix],
+            matchedLength: match[1].length,
+            exactMatch: match[0],
+            tagKeyword: !isInit && serviceAliases.has(prefix) ? prefix : undefined,
+            isPrefix: true,
+        };
+    }
+    return null;
+}
+function getWrapperFolder(targetService, tagKeyword) {
+    if (serverContainers.has(targetService))
+        return "server";
+    if (clientContainers.has(targetService))
+        return "client";
+    if (tagKeyword)
+        return tagKeyword;
+    return "shared";
+}
+export function resolveRoute(relativePath, isInit, context, isSync = false) {
+    const { emitLegacyScripts, isTsProject, build, routingMaps, verbatim, knownTags, activeTags, tagRegexes, directoryMarkers, } = context;
+    const parts = relativePath ? relativePath.split(/[\\/]/) : [];
+    let filename;
+    let rawBasename;
+    if (isSync) {
+        filename = parts.length > 0 ? parts[parts.length - 1] : "";
+        rawBasename = filename;
+    }
+    else {
+        filename = parts.length > 0 ? parts.pop() : "";
+        rawBasename = filename
+            ? path.basename(filename, path.extname(filename))
+            : "";
+    }
+    // Detect and strip the hoisting prefix
+    let isHoisted = false;
+    let cleanBasename = rawBasename;
+    if (cleanBasename.startsWith("^")) {
+        isHoisted = true;
+        cleanBasename = cleanBasename.slice(1);
+    }
+    let dropped = false;
+    // Check folder paths and folder marker files
+    let currentRel = "";
+    for (const part of parts) {
+        currentRel = currentRel ? `${currentRel}/${part}` : part;
+        let lowerPart = part.toLowerCase();
+        // Strip invisible folder syntax for drop checks
+        if (lowerPart.startsWith("(") && lowerPart.endsWith(")")) {
+            lowerPart = lowerPart.slice(1, -1);
+        }
+        // Drop if folder name is an inactive env
+        if (knownTags.has(lowerPart) && !activeTags.has(lowerPart)) {
+            dropped = true;
+            break;
+        }
+        // Drop if folder contains an inactive env marker file
+        const markers = directoryMarkers?.[currentRel];
+        if (markers) {
+            for (const m of markers) {
+                if (knownTags.has(m) && !activeTags.has(m)) {
+                    dropped = true;
+                    break;
+                }
+            }
+        }
+        if (dropped)
+            break;
+    }
+    // Check root directory markers for drops
+    const rootMarkers = directoryMarkers?.[""];
+    if (!dropped && rootMarkers) {
+        for (const m of rootMarkers) {
+            if (knownTags.has(m) && !activeTags.has(m)) {
+                dropped = true;
+                break;
+            }
+        }
+    }
+    // Check file affixes
+    if (!dropped && !isSync && cleanBasename) {
+        const delimiterSplit = cleanBasename.split(/[.\-_+]/);
+        for (const part of delimiterSplit) {
+            const lowerPart = part.toLowerCase();
+            if (knownTags.has(lowerPart) && !activeTags.has(lowerPart)) {
+                dropped = true;
+                break;
+            }
+        }
+    }
+    // Stop processing and flag for removal
+    if (dropped) {
+        return {
+            targetService: "",
+            wrapperFolder: "",
+            virtualParts: [],
+            nodeName: "",
+            projectPath: "",
+            dropped: true,
+            unwrap: false,
+        };
+    }
+    // Strip active environment affixes
+    let basename = cleanBasename;
+    if (!isSync) {
+        for (const regexSet of tagRegexes) {
+            while (regexSet.suffix.test(basename)) {
+                basename = basename.replace(regexSet.suffix, "");
+            }
+            while (regexSet.prefix.test(basename)) {
+                basename = basename.replace(regexSet.prefix, "");
+            }
+            while (regexSet.middle.test(basename)) {
+                basename = basename.replace(regexSet.middle, "");
+            }
+        }
+    }
+    // Folder and marker routing
+    const { targetService: folderTarget, virtualParts, lastRouteKeyword, tagKeyword: folderFlag, flags, } = resolveFolderRouting(parts, context);
+    // Apply hoisting
+    if (isHoisted) {
+        virtualParts.length = 0;
+    }
+    // Affix routing
+    const affix = flags.structure || isSync
+        ? null
+        : resolveAffixes(basename, isInit, routingMaps);
+    // Resolve overrides
+    let targetService = affix?.mappedService ?? folderTarget;
+    const tagKeyword = affix?.tagKeyword ?? folderFlag;
+    // Resolve namespace wrapper folder
+    const wrapperFolder = getWrapperFolder(targetService, tagKeyword);
+    // Determine if the wrapper folder should be skipped
+    const unwrap = context.unwrap || flags.unwrap;
+    // Edge case: Scripts with non-legacy RunContext run incorrectly in StarterPlayer container,
+    // hence they need to be put in ReplicatedStorage.
+    const isStarterPlayerContainer = targetService === "StarterPlayerScripts" ||
+        targetService === "StarterCharacterScripts";
+    if (emitLegacyScripts === false && isStarterPlayerContainer) {
+        targetService = "ReplicatedStorage";
+    }
+    // Node naming and path formatting
+    let nodeName = basename;
+    let projectPath;
+    if (isSync) {
+        projectPath = toPosix(path.join(build, relativePath));
+        if (virtualParts.length > 0) {
+            nodeName = virtualParts.pop();
+        }
+        else {
+            nodeName = lastRouteKeyword
+                ? lastRouteKeyword
+                : filename || "source";
+        }
+    }
+    else if (isInit) {
+        const folderRelativePath = path.dirname(relativePath);
+        projectPath = toPosix(path.join(build, folderRelativePath));
+        if (virtualParts.length > 0) {
+            nodeName = virtualParts.pop();
+        }
+        else {
+            nodeName = lastRouteKeyword ? lastRouteKeyword : "source";
+        }
+    }
+    else {
+        let compiledRelativePath = relativePath;
+        if (isTsProject) {
+            const compiledFilename = filename.replace(/\.tsx?$/i, ".luau");
+            compiledRelativePath = path.join(path.dirname(relativePath), compiledFilename);
+        }
+        projectPath = toPosix(path.join(build, compiledRelativePath));
+        if (affix) {
+            const keepFullNames = verbatim || flags.verbatim;
+            let shouldStrip = !keepFullNames;
+            // Rojo relies on '.server' and '.client' explicitly for script types.
+            // Even if verbatim is true, we must strip these exact dot-prefixes.
+            if (keepFullNames) {
+                const exactMatch = affix.exactMatch.toLowerCase();
+                if (exactMatch === ".server" || exactMatch === ".client") {
+                    shouldStrip = true;
+                }
+            }
+            if (shouldStrip) {
+                if (affix.isPrefix) {
+                    nodeName = basename.slice(affix.matchedLength);
+                }
+                else {
+                    nodeName = basename.slice(0, -affix.matchedLength);
+                }
+            }
+        }
+    }
+    return {
+        targetService,
+        wrapperFolder,
+        virtualParts,
+        nodeName,
+        projectPath,
+        dropped: false,
+        unwrap,
+    };
+}