@jackctaylor/roblox-ts 3.0.0-projectrefs.0

package/out/Project/classes/VirtualFileSystem.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VirtualFileSystem = exports.PATH_SEP = void 0;
+exports.pathJoin = pathJoin;
+const assert_1 = require("../../Shared/util/assert");
+const getOrSetDefault_1 = require("../../Shared/util/getOrSetDefault");
+exports.PATH_SEP = "/";
+function pathJoin(...parts) {
+    let result = parts[0];
+    for (let i = 1; i < parts.length; i++) {
+        if (!result.endsWith(exports.PATH_SEP)) {
+            result += exports.PATH_SEP;
+        }
+        result += parts[i];
+    }
+    return result;
+}
+class VirtualFileSystem {
+    constructor() {
+        this.root = {
+            name: "",
+            children: new Map(),
+        };
+    }
+    getPathParts(filePath) {
+        return filePath.split(exports.PATH_SEP).filter(v => v.length > 0);
+    }
+    writeFile(filePath, content) {
+        const pathParts = this.getPathParts(filePath);
+        const fileName = pathParts.pop();
+        let currentDir = this.root;
+        for (const name of pathParts) {
+            const child = (0, getOrSetDefault_1.getOrSetDefault)(currentDir.children, name, () => ({
+                name,
+                children: new Map(),
+            }));
+            (0, assert_1.assert)("children" in child);
+            currentDir = child;
+        }
+        currentDir.children.set(fileName, {
+            name: fileName,
+            content,
+        });
+    }
+    get(itemPath) {
+        const pathParts = this.getPathParts(itemPath);
+        const fileName = pathParts.pop();
+        let currentDir = this.root;
+        for (const name of pathParts) {
+            const child = currentDir.children.get(name);
+            if (!child)
+                return undefined;
+            if (!("children" in child))
+                return undefined;
+            currentDir = child;
+        }
+        return currentDir.children.get(fileName);
+    }
+    readFile(filePath) {
+        const item = this.get(filePath);
+        if (item && "content" in item) {
+            return item.content;
+        }
+    }
+    fileExists(filePath) {
+        const item = this.get(filePath);
+        return item !== undefined && "content" in item;
+    }
+    directoryExists(dirPath) {
+        const item = this.get(dirPath);
+        return item !== undefined && "children" in item;
+    }
+    getDirectories(dirPath) {
+        const result = new Array();
+        const item = this.get(dirPath);
+        if (item && "children" in item) {
+            for (const [name, child] of item.children) {
+                if ("children" in child) {
+                    result.push(pathJoin(dirPath, name));
+                }
+            }
+        }
+        return result;
+    }
+    getFilePaths() {
+        const filePaths = new Array();
+        const search = (dir, partialPath = "") => {
+            for (const [name, child] of dir.children) {
+                if ("children" in child) {
+                    search(child, `${partialPath}/${name}`);
+                }
+                else {
+                    filePaths.push(`${partialPath}/${name}`);
+                }
+            }
+        };
+        search(this.root);
+        return filePaths;
+    }
+}
+exports.VirtualFileSystem = VirtualFileSystem;
+//# sourceMappingURL=VirtualFileSystem.js.map

package/out/Project/classes/VirtualProject.d.ts

@@ -0,0 +1,15 @@
+import { VirtualFileSystem } from "./VirtualFileSystem";
+export declare class VirtualProject {
+    private readonly data;
+    readonly vfs: VirtualFileSystem;
+    private readonly compilerOptions;
+    private readonly rojoResolver;
+    private readonly pkgRojoResolvers;
+    private readonly compilerHost;
+    private program;
+    private typeChecker;
+    private nodeModulesPathMapping;
+    constructor();
+    compileSource(source: string): string;
+    setMapping(typings: string, main: string): void;
+}

package/out/Project/classes/VirtualProject.js

@@ -0,0 +1,121 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VirtualProject = void 0;
+const luau_ast_1 = require("@roblox-ts/luau-ast");
+const path_translator_1 = require("@roblox-ts/path-translator");
+const rojo_resolver_1 = require("@roblox-ts/rojo-resolver");
+const VirtualFileSystem_1 = require("./VirtualFileSystem");
+const validateCompilerOptions_1 = require("../functions/validateCompilerOptions");
+const getCustomPreEmitDiagnostics_1 = require("../util/getCustomPreEmitDiagnostics");
+const constants_1 = require("../../Shared/constants");
+const DiagnosticError_1 = require("../../Shared/errors/DiagnosticError");
+const assert_1 = require("../../Shared/util/assert");
+const hasErrors_1 = require("../../Shared/util/hasErrors");
+const TSTransformer_1 = require("../../TSTransformer");
+const DiagnosticService_1 = require("../../TSTransformer/classes/DiagnosticService");
+const createTransformServices_1 = require("../../TSTransformer/util/createTransformServices");
+const typescript_1 = __importDefault(require("typescript"));
+const PROJECT_DIR = VirtualFileSystem_1.PATH_SEP;
+const ROOT_DIR = (0, VirtualFileSystem_1.pathJoin)(PROJECT_DIR, "src");
+const OUT_DIR = (0, VirtualFileSystem_1.pathJoin)(PROJECT_DIR, "out");
+const PLAYGROUND_PATH = (0, VirtualFileSystem_1.pathJoin)(ROOT_DIR, "playground.tsx");
+const NODE_MODULES_PATH = (0, VirtualFileSystem_1.pathJoin)(PROJECT_DIR, constants_1.NODE_MODULES);
+const RBXTS_SCOPE_PATH = (0, VirtualFileSystem_1.pathJoin)(NODE_MODULES_PATH, constants_1.RBXTS_SCOPE);
+const INCLUDE_PATH = (0, VirtualFileSystem_1.pathJoin)(PROJECT_DIR, "include");
+class VirtualProject {
+    constructor() {
+        this.nodeModulesPathMapping = new Map();
+        this.data = {
+            isPackage: false,
+            nodeModulesPath: NODE_MODULES_PATH,
+            projectOptions: Object.assign({}, constants_1.DEFAULT_PROJECT_OPTIONS, {
+                rojo: "",
+                type: constants_1.ProjectType.Model,
+                optimizedLoops: true,
+            }),
+            projectPath: PROJECT_DIR,
+            rojoConfigPath: undefined,
+            tsConfigPath: "",
+            referencedProjects: [],
+        };
+        this.compilerOptions = {
+            allowSyntheticDefaultImports: true,
+            downlevelIteration: true,
+            noLib: true,
+            strict: true,
+            target: typescript_1.default.ScriptTarget.ESNext,
+            module: typescript_1.default.ModuleKind.CommonJS,
+            moduleResolution: typescript_1.default.ModuleResolutionKind.Node10,
+            moduleDetection: typescript_1.default.ModuleDetectionKind.Force,
+            typeRoots: [RBXTS_SCOPE_PATH],
+            resolveJsonModule: true,
+            experimentalDecorators: true,
+            rootDir: ROOT_DIR,
+            outDir: OUT_DIR,
+            jsx: typescript_1.default.JsxEmit.React,
+            jsxFactory: "React.createElement",
+            jsxFragmentFactory: "React.Fragment",
+        };
+        (0, validateCompilerOptions_1.validateCompilerOptions)(this.compilerOptions, this.data.projectPath);
+        this.vfs = new VirtualFileSystem_1.VirtualFileSystem();
+        const system = {
+            getExecutingFilePath: () => __filename,
+            getCurrentDirectory: () => "/",
+        };
+        this.compilerHost = typescript_1.default.createCompilerHostWorker(this.compilerOptions, undefined, system);
+        this.compilerHost.readFile = filePath => this.vfs.readFile(filePath);
+        this.compilerHost.fileExists = filePath => this.vfs.fileExists(filePath);
+        this.compilerHost.directoryExists = dirPath => this.vfs.directoryExists(dirPath);
+        this.compilerHost.getDirectories = dirPath => this.vfs.getDirectories(dirPath);
+        this.compilerHost.useCaseSensitiveFileNames = () => true;
+        this.compilerHost.getCurrentDirectory = () => VirtualFileSystem_1.PATH_SEP;
+        this.rojoResolver = rojo_resolver_1.RojoResolver.fromTree(PROJECT_DIR, {
+            $path: OUT_DIR,
+            include: {
+                $path: INCLUDE_PATH,
+                node_modules: {
+                    $className: "Folder",
+                    "@rbxts": {
+                        $path: RBXTS_SCOPE_PATH,
+                    },
+                },
+            },
+        });
+        this.pkgRojoResolvers = this.compilerOptions.typeRoots.map(rojo_resolver_1.RojoResolver.synthetic);
+    }
+    compileSource(source) {
+        this.vfs.writeFile(PLAYGROUND_PATH, source);
+        const rootNames = this.vfs
+            .getFilePaths()
+            .filter(v => v.endsWith(typescript_1.default.Extension.Ts) || v.endsWith(typescript_1.default.Extension.Tsx) || v.endsWith(typescript_1.default.Extension.Dts));
+        this.program = typescript_1.default.createProgram(rootNames, this.compilerOptions, this.compilerHost, this.program);
+        this.typeChecker = this.program.getTypeChecker();
+        const services = (0, createTransformServices_1.createTransformServices)(this.typeChecker);
+        const pathTranslator = new path_translator_1.PathTranslator(ROOT_DIR, OUT_DIR, undefined, false, this.data.projectOptions.luau);
+        const sourceFile = this.program.getSourceFile(PLAYGROUND_PATH);
+        (0, assert_1.assert)(sourceFile);
+        const diagnostics = new Array();
+        diagnostics.push(...typescript_1.default.getPreEmitDiagnostics(this.program, sourceFile));
+        diagnostics.push(...(0, getCustomPreEmitDiagnostics_1.getCustomPreEmitDiagnostics)(this.data, sourceFile));
+        if ((0, hasErrors_1.hasErrors)(diagnostics))
+            throw new DiagnosticError_1.DiagnosticError(diagnostics);
+        const multiTransformState = new TSTransformer_1.MultiTransformState();
+        const runtimeLibRbxPath = undefined;
+        const projectType = this.data.projectOptions.type;
+        const transformState = new TSTransformer_1.TransformState(this.program, this.data, services, pathTranslator, multiTransformState, this.compilerOptions, this.rojoResolver, this.pkgRojoResolvers, this.nodeModulesPathMapping, runtimeLibRbxPath, this.typeChecker, projectType, () => pathTranslator, sourceFile);
+        const luaAST = (0, TSTransformer_1.transformSourceFile)(transformState, sourceFile);
+        diagnostics.push(...DiagnosticService_1.DiagnosticService.flush());
+        if ((0, hasErrors_1.hasErrors)(diagnostics))
+            throw new DiagnosticError_1.DiagnosticError(diagnostics);
+        const luaSource = (0, luau_ast_1.renderAST)(luaAST);
+        return luaSource;
+    }
+    setMapping(typings, main) {
+        this.nodeModulesPathMapping.set(typings, main);
+    }
+}
+exports.VirtualProject = VirtualProject;
+//# sourceMappingURL=VirtualProject.js.map

package/out/Project/functions/buildProject.d.ts

@@ -0,0 +1,18 @@
+import { PathTranslator } from "@roblox-ts/path-translator";
+import { ProjectData, ProjectOptions, ReferencedProjectInfo } from "../../Shared/types";
+import ts from "typescript";
+export interface BuildProjectOptions {
+    tsConfigPath: string;
+    projectOptions: ProjectOptions;
+    isRootProject: boolean;
+    referencedProjects?: Array<ReferencedProjectInfo>;
+    rootProjectRojoConfigPath?: string;
+    rootProjectIncludePath?: string;
+}
+export interface BuildProjectResult {
+    emitResult: ts.EmitResult;
+    data: ProjectData;
+    pathTranslator: PathTranslator;
+    program: ts.EmitAndSemanticDiagnosticsBuilderProgram;
+}
+export declare function buildProject(options: BuildProjectOptions): BuildProjectResult;

package/out/Project/functions/buildProject.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildProject = buildProject;
+const cleanup_1 = require("./cleanup");
+const compileFiles_1 = require("./compileFiles");
+const copyFiles_1 = require("./copyFiles");
+const copyInclude_1 = require("./copyInclude");
+const createPathTranslator_1 = require("./createPathTranslator");
+const createProjectData_1 = require("./createProjectData");
+const createProjectProgram_1 = require("./createProjectProgram");
+const getChangedSourceFiles_1 = require("./getChangedSourceFiles");
+const getRootDirs_1 = require("../../Shared/util/getRootDirs");
+function buildProject(options) {
+    const { tsConfigPath, projectOptions, isRootProject, referencedProjects, rootProjectRojoConfigPath, rootProjectIncludePath, } = options;
+    const effectiveProjectOptions = { ...projectOptions };
+    if (!isRootProject) {
+        effectiveProjectOptions.noInclude = true;
+        if (rootProjectRojoConfigPath) {
+            effectiveProjectOptions.rojo = rootProjectRojoConfigPath;
+        }
+    }
+    const data = (0, createProjectData_1.createProjectData)(tsConfigPath, effectiveProjectOptions);
+    if (referencedProjects && referencedProjects.length > 0) {
+        data.referencedProjects = referencedProjects;
+        data.isCompositeProject = true;
+    }
+    if (!isRootProject) {
+        data.isReferencedProject = true;
+        if (rootProjectIncludePath) {
+            data.rootProjectIncludePath = rootProjectIncludePath;
+        }
+    }
+    const program = (0, createProjectProgram_1.createProjectProgram)(data);
+    const pathTranslator = (0, createPathTranslator_1.createPathTranslator)(program, data);
+    if (isRootProject) {
+        (0, cleanup_1.cleanup)(pathTranslator);
+        (0, copyInclude_1.copyInclude)(data);
+    }
+    (0, copyFiles_1.copyFiles)(data, pathTranslator, new Set((0, getRootDirs_1.getRootDirs)(program.getCompilerOptions())));
+    const emitResult = (0, compileFiles_1.compileFiles)(program.getProgram(), data, pathTranslator, (0, getChangedSourceFiles_1.getChangedSourceFiles)(program));
+    return {
+        emitResult,
+        data,
+        pathTranslator,
+        program,
+    };
+}
+//# sourceMappingURL=buildProject.js.map

package/out/Project/functions/buildProjectReferences.d.ts

@@ -0,0 +1,3 @@
+import { ProjectOptions } from "../../Shared/types";
+import ts from "typescript";
+export declare function buildProjectReferences(tsConfigPath: string, projectOptions: ProjectOptions, diagnosticReporter: ts.DiagnosticReporter): number;

package/out/Project/functions/buildProjectReferences.js

@@ -0,0 +1,78 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildProjectReferences = buildProjectReferences;
+const path_1 = __importDefault(require("path"));
+const compileProject_1 = require("./compileProject");
+const createProjectData_1 = require("./createProjectData");
+const LogService_1 = require("../../Shared/classes/LogService");
+const hasErrors_1 = require("../../Shared/util/hasErrors");
+const typescript_1 = __importDefault(require("typescript"));
+function buildProjectReferences(tsConfigPath, projectOptions, diagnosticReporter) {
+    const allDiagnostics = [];
+    const rootConfigPath = path_1.default.normalize(tsConfigPath);
+    const rootData = (0, createProjectData_1.createProjectData)(tsConfigPath, projectOptions);
+    const rootRojoConfigPath = rootData.rojoConfigPath;
+    const rootIncludePath = rootData.projectOptions.includePath;
+    const referencedProjects = [];
+    const host = typescript_1.default.createSolutionBuilderHost(typescript_1.default.sys, typescript_1.default.createEmitAndSemanticDiagnosticsBuilderProgram);
+    const builder = typescript_1.default.createSolutionBuilder(host, [tsConfigPath], {});
+    const projectsToCompile = [];
+    let project = builder.getNextInvalidatedProject();
+    while (project) {
+        if (project.kind === typescript_1.default.InvalidatedProjectKind.Build) {
+            const program = project.getProgram();
+            if (program) {
+                const configPath = path_1.default.normalize(project.project);
+                if (configPath !== rootConfigPath) {
+                    const resolvedRefs = program.getResolvedProjectReferences();
+                    if (resolvedRefs) {
+                        (0, compileProject_1.collectReferencedProjects)(resolvedRefs, referencedProjects, rootConfigPath, projectOptions.luau);
+                    }
+                }
+                projectsToCompile.push({ configPath, program });
+            }
+            project.emit(undefined, undefined, undefined, true);
+        }
+        project.done();
+        project = builder.getNextInvalidatedProject();
+    }
+    if (projectsToCompile.length > 0) {
+        const rootProject = projectsToCompile.find(p => p.configPath === rootConfigPath);
+        if (rootProject) {
+            const resolvedRefs = rootProject.program.getResolvedProjectReferences();
+            if (resolvedRefs) {
+                (0, compileProject_1.collectReferencedProjects)(resolvedRefs, referencedProjects, rootConfigPath, projectOptions.luau);
+            }
+        }
+    }
+    if (referencedProjects.length > 0) {
+        LogService_1.LogService.writeLineIfVerbose(`Found ${referencedProjects.length} referenced project(s)`);
+    }
+    for (const { configPath, program } of projectsToCompile) {
+        const emitResult = (0, compileProject_1.compileProject)({
+            program,
+            configPath,
+            projectOptions,
+            rootConfigPath,
+            rootRojoConfigPath,
+            rootIncludePath,
+            referencedProjects,
+            isInitialCompile: true,
+        });
+        allDiagnostics.push(...emitResult.diagnostics);
+        if ((0, hasErrors_1.hasErrors)(emitResult.diagnostics)) {
+            for (const diagnostic of allDiagnostics) {
+                diagnosticReporter(diagnostic);
+            }
+            return 1;
+        }
+    }
+    for (const diagnostic of allDiagnostics) {
+        diagnosticReporter(diagnostic);
+    }
+    return (0, hasErrors_1.hasErrors)(allDiagnostics) ? 1 : 0;
+}
+//# sourceMappingURL=buildProjectReferences.js.map

package/out/Project/functions/buildSolution.d.ts

@@ -0,0 +1,10 @@
+import { BuildProjectResult } from "./buildProject";
+import { ProjectOptions } from "../../Shared/types";
+import ts from "typescript";
+export interface BuildSolutionResult {
+    success: boolean;
+    diagnostics: Array<ts.Diagnostic>;
+    projectResults: Array<BuildProjectResult>;
+}
+export declare function buildSolution(rootTsConfigPath: string, projectOptions: ProjectOptions): BuildSolutionResult;
+export declare function shouldUseSolutionBuild(tsConfigPath: string): boolean;

package/out/Project/functions/buildSolution.js

@@ -0,0 +1,97 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildSolution = buildSolution;
+exports.shouldUseSolutionBuild = shouldUseSolutionBuild;
+const rojo_resolver_1 = require("@roblox-ts/rojo-resolver");
+const path_1 = __importDefault(require("path"));
+const buildProject_1 = require("./buildProject");
+const createProjectData_1 = require("./createProjectData");
+const getProjectReferences_1 = require("./getProjectReferences");
+const LogService_1 = require("../../Shared/classes/LogService");
+const ProjectError_1 = require("../../Shared/errors/ProjectError");
+const hasErrors_1 = require("../../Shared/util/hasErrors");
+const typescript_1 = __importDefault(require("typescript"));
+function buildSolution(rootTsConfigPath, projectOptions) {
+    const allDiagnostics = [];
+    const projectResults = [];
+    const rootConfig = (0, getProjectReferences_1.getRootProjectConfig)(rootTsConfigPath);
+    if (!rootConfig) {
+        throw new ProjectError_1.ProjectError(`Failed to parse root tsconfig: ${rootTsConfigPath}`);
+    }
+    const rootProjectPath = path_1.default.dirname(rootTsConfigPath);
+    const referencedProjects = (0, getProjectReferences_1.getProjectReferences)(rootTsConfigPath, projectOptions.luau);
+    if (referencedProjects.length > 0) {
+        LogService_1.LogService.writeLineIfVerbose(`Found ${referencedProjects.length} referenced project(s)`);
+    }
+    const rootData = (0, createProjectData_1.createProjectData)(rootTsConfigPath, projectOptions);
+    const rootRojoConfigPath = rootData.rojoConfigPath;
+    if (projectOptions.rojo) {
+        const rojoConfigPath = path_1.default.resolve(rootProjectPath, projectOptions.rojo);
+        if (typescript_1.default.sys.fileExists(rojoConfigPath)) {
+            const rojoResolver = rojo_resolver_1.RojoResolver.fromPath(rojoConfigPath);
+            const validationDiagnostics = validateReferencedProjectsWithRojo(rojoResolver, referencedProjects, rootProjectPath);
+            if (validationDiagnostics.length > 0) {
+                allDiagnostics.push(...validationDiagnostics);
+                return { success: false, diagnostics: allDiagnostics, projectResults };
+            }
+        }
+    }
+    for (const refProject of referencedProjects) {
+        const relativePath = path_1.default.relative(rootProjectPath, refProject.tsConfigPath);
+        LogService_1.LogService.writeLineIfVerbose(`Building referenced project: ${relativePath}`);
+        const result = (0, buildProject_1.buildProject)({
+            tsConfigPath: refProject.tsConfigPath,
+            projectOptions,
+            isRootProject: false,
+            referencedProjects,
+            rootProjectRojoConfigPath: rootRojoConfigPath,
+            rootProjectIncludePath: rootData.projectOptions.includePath,
+        });
+        projectResults.push(result);
+        allDiagnostics.push(...result.emitResult.diagnostics);
+        if ((0, hasErrors_1.hasErrors)(result.emitResult.diagnostics)) {
+            LogService_1.LogService.writeLineIfVerbose(`Build failed for: ${relativePath}`);
+            return { success: false, diagnostics: allDiagnostics, projectResults };
+        }
+    }
+    LogService_1.LogService.writeLineIfVerbose(`Building root project: ${rootTsConfigPath}`);
+    const rootResult = (0, buildProject_1.buildProject)({
+        tsConfigPath: rootTsConfigPath,
+        projectOptions,
+        isRootProject: true,
+        referencedProjects,
+    });
+    projectResults.push(rootResult);
+    allDiagnostics.push(...rootResult.emitResult.diagnostics);
+    const success = !(0, hasErrors_1.hasErrors)(allDiagnostics);
+    return { success, diagnostics: allDiagnostics, projectResults };
+}
+function validateReferencedProjectsWithRojo(rojoResolver, referencedProjects, rootProjectPath) {
+    const diagnostics = [];
+    for (const project of referencedProjects) {
+        const testPath = path_1.default.join(project.outDir, "init.lua");
+        const rbxPath = rojoResolver.getRbxPathFromFilePath(testPath);
+        if (!rbxPath) {
+            const relativeTsConfig = path_1.default.relative(rootProjectPath, project.tsConfigPath);
+            const relativeOutDir = path_1.default.relative(rootProjectPath, project.outDir);
+            diagnostics.push({
+                category: typescript_1.default.DiagnosticCategory.Error,
+                code: 0,
+                file: undefined,
+                start: undefined,
+                length: undefined,
+                messageText: `Referenced project "${relativeTsConfig}" outputs to "${relativeOutDir}" ` +
+                    `which is not covered by the Rojo configuration.\n` +
+                    `Ensure all referenced project outDir paths are within the scope of your Rojo project file.`,
+            });
+        }
+    }
+    return diagnostics;
+}
+function shouldUseSolutionBuild(tsConfigPath) {
+    return (0, getProjectReferences_1.hasProjectReferences)(tsConfigPath);
+}
+//# sourceMappingURL=buildSolution.js.map

package/out/Project/functions/checkFileName.d.ts

@@ -0,0 +1 @@
+export declare function checkFileName(filePath: string): void;

package/out/Project/functions/checkFileName.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkFileName = checkFileName;
+const path_1 = __importDefault(require("path"));
+const constants_1 = require("../../Shared/constants");
+const diagnostics_1 = require("../../Shared/diagnostics");
+const DiagnosticService_1 = require("../../TSTransformer/classes/DiagnosticService");
+function checkFileName(filePath) {
+    const baseName = path_1.default.basename(filePath);
+    const nameWarning = constants_1.FILENAME_WARNINGS.get(baseName);
+    if (nameWarning) {
+        DiagnosticService_1.DiagnosticService.addDiagnostic(diagnostics_1.errors.incorrectFileName(baseName, nameWarning, filePath));
+    }
+}
+//# sourceMappingURL=checkFileName.js.map

package/out/Project/functions/checkRojoConfig.d.ts

@@ -0,0 +1,4 @@
+import { PathTranslator } from "@roblox-ts/path-translator";
+import { RojoResolver } from "@roblox-ts/rojo-resolver";
+import { ProjectData } from "..";
+export declare function checkRojoConfig(data: ProjectData, rojoResolver: RojoResolver, rootDirs: ReadonlyArray<string>, pathTranslator: PathTranslator): void;

package/out/Project/functions/checkRojoConfig.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkRojoConfig = checkRojoConfig;
+const path_1 = __importDefault(require("path"));
+const diagnostics_1 = require("../../Shared/diagnostics");
+const isPathDescendantOf_1 = require("../../Shared/util/isPathDescendantOf");
+const DiagnosticService_1 = require("../../TSTransformer/classes/DiagnosticService");
+function checkRojoConfig(data, rojoResolver, rootDirs, pathTranslator) {
+    if (data.rojoConfigPath !== undefined) {
+        for (const partition of rojoResolver.getPartitions()) {
+            for (const rootDir of rootDirs) {
+                if ((0, isPathDescendantOf_1.isPathDescendantOf)(partition.fsPath, rootDir)) {
+                    const rojoConfigDir = path_1.default.dirname(data.rojoConfigPath);
+                    const outPath = pathTranslator.getOutputPath(partition.fsPath);
+                    const inputPath = path_1.default.relative(rojoConfigDir, partition.fsPath);
+                    const suggestedPath = path_1.default.relative(rojoConfigDir, outPath);
+                    DiagnosticService_1.DiagnosticService.addDiagnostic(diagnostics_1.errors.rojoPathInSrc(inputPath, suggestedPath));
+                }
+            }
+        }
+    }
+}
+//# sourceMappingURL=checkRojoConfig.js.map

package/out/Project/functions/cleanup.d.ts

@@ -0,0 +1,2 @@
+import { PathTranslator } from "@roblox-ts/path-translator";
+export declare function cleanup(pathTranslator: PathTranslator): void;

package/out/Project/functions/cleanup.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cleanup = cleanup;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const tryRemoveOutput_1 = require("./tryRemoveOutput");
+function cleanupDirRecursively(pathTranslator, dir) {
+    if (fs_extra_1.default.pathExistsSync(dir)) {
+        for (const name of fs_extra_1.default.readdirSync(dir)) {
+            const itemPath = path_1.default.join(dir, name);
+            if (fs_extra_1.default.statSync(itemPath).isDirectory()) {
+                if (name === ".git") {
+                    continue;
+                }
+                cleanupDirRecursively(pathTranslator, itemPath);
+            }
+            (0, tryRemoveOutput_1.tryRemoveOutput)(pathTranslator, itemPath);
+        }
+    }
+}
+function cleanup(pathTranslator) {
+    const outDir = pathTranslator.outDir;
+    if (fs_extra_1.default.pathExistsSync(outDir)) {
+        cleanupDirRecursively(pathTranslator, outDir);
+    }
+}
+//# sourceMappingURL=cleanup.js.map

package/out/Project/functions/compileFiles.d.ts

@@ -0,0 +1,4 @@
+import { PathTranslator } from "@roblox-ts/path-translator";
+import { GetProjectPathTranslator, ProjectData } from "../../Shared/types";
+import ts from "typescript";
+export declare function compileFiles(program: ts.Program, data: ProjectData, pathTranslator: PathTranslator, getProjectPathTranslator: GetProjectPathTranslator, sourceFiles: Array<ts.SourceFile>): ts.EmitResult;