@jackctaylor/roblox-ts 3.0.0-projectrefs.0

package/out/Project/functions/compileFiles.js

@@ -0,0 +1,160 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compileFiles = compileFiles;
+const luau_ast_1 = require("@roblox-ts/luau-ast");
+const rojo_resolver_1 = require("@roblox-ts/rojo-resolver");
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const checkFileName_1 = require("./checkFileName");
+const checkRojoConfig_1 = require("./checkRojoConfig");
+const createNodeModulesPathMapping_1 = require("./createNodeModulesPathMapping");
+const transformPaths_1 = __importDefault(require("../transformers/builtin/transformPaths"));
+const transformTypeReferenceDirectives_1 = require("../transformers/builtin/transformTypeReferenceDirectives");
+const createTransformerList_1 = require("../transformers/createTransformerList");
+const createTransformerWatcher_1 = require("../transformers/createTransformerWatcher");
+const getPluginConfigs_1 = require("../transformers/getPluginConfigs");
+const getCustomPreEmitDiagnostics_1 = require("../util/getCustomPreEmitDiagnostics");
+const LogService_1 = require("../../Shared/classes/LogService");
+const constants_1 = require("../../Shared/constants");
+const assert_1 = require("../../Shared/util/assert");
+const benchmark_1 = require("../../Shared/util/benchmark");
+const createTextDiagnostic_1 = require("../../Shared/util/createTextDiagnostic");
+const getRootDirs_1 = require("../../Shared/util/getRootDirs");
+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"));
+function inferProjectType(data, rojoResolver) {
+    if (data.isPackage) {
+        return constants_1.ProjectType.Package;
+    }
+    else if (rojoResolver.isGame) {
+        return constants_1.ProjectType.Game;
+    }
+    else {
+        return constants_1.ProjectType.Model;
+    }
+}
+function emitResultFailure(messageText) {
+    return {
+        emitSkipped: true,
+        diagnostics: [(0, createTextDiagnostic_1.createTextDiagnostic)(messageText)],
+    };
+}
+function compileFiles(program, data, pathTranslator, getProjectPathTranslator, sourceFiles) {
+    var _a;
+    const compilerOptions = program.getCompilerOptions();
+    const multiTransformState = new TSTransformer_1.MultiTransformState();
+    const outDir = compilerOptions.outDir;
+    const rojoResolver = data.rojoConfigPath
+        ? rojo_resolver_1.RojoResolver.fromPath(data.rojoConfigPath)
+        : rojo_resolver_1.RojoResolver.synthetic(outDir);
+    for (const warning of rojoResolver.getWarnings()) {
+        LogService_1.LogService.warn(warning);
+    }
+    (0, checkRojoConfig_1.checkRojoConfig)(data, rojoResolver, (0, getRootDirs_1.getRootDirs)(compilerOptions), pathTranslator);
+    for (const sourceFile of program.getSourceFiles()) {
+        if (!path_1.default.normalize(sourceFile.fileName).startsWith(data.nodeModulesPath)) {
+            (0, checkFileName_1.checkFileName)(sourceFile.fileName);
+        }
+    }
+    const pkgRojoResolvers = compilerOptions.typeRoots.map(rojo_resolver_1.RojoResolver.synthetic);
+    const nodeModulesPathMapping = (0, createNodeModulesPathMapping_1.createNodeModulesPathMapping)(compilerOptions.typeRoots);
+    const projectType = (_a = data.projectOptions.type) !== null && _a !== void 0 ? _a : inferProjectType(data, rojoResolver);
+    if (projectType !== constants_1.ProjectType.Package && data.rojoConfigPath === undefined) {
+        return emitResultFailure("Non-package projects must have a Rojo project file!");
+    }
+    let runtimeLibRbxPath;
+    if (projectType !== constants_1.ProjectType.Package) {
+        runtimeLibRbxPath = rojoResolver.getRbxPathFromFilePath(path_1.default.join(data.projectOptions.includePath, "RuntimeLib.lua"));
+        if (!runtimeLibRbxPath) {
+            return emitResultFailure("Rojo project contained no data for include folder!");
+        }
+        else if (rojoResolver.getNetworkType(runtimeLibRbxPath) !== rojo_resolver_1.NetworkType.Unknown) {
+            return emitResultFailure("Runtime library cannot be in a server-only or client-only container!");
+        }
+        else if (rojoResolver.isIsolated(runtimeLibRbxPath)) {
+            return emitResultFailure("Runtime library cannot be in an isolated container!");
+        }
+    }
+    if (DiagnosticService_1.DiagnosticService.hasErrors())
+        return { emitSkipped: true, diagnostics: DiagnosticService_1.DiagnosticService.flush() };
+    LogService_1.LogService.writeLineIfVerbose(`compiling as ${projectType}..`);
+    const fileWriteQueue = new Array();
+    const progressMaxLength = `${sourceFiles.length}/${sourceFiles.length}`.length;
+    let proxyProgram = program;
+    if (compilerOptions.plugins && compilerOptions.plugins.length > 0) {
+        (0, benchmark_1.benchmarkIfVerbose)(`running transformers..`, () => {
+            var _a;
+            const pluginConfigs = (0, getPluginConfigs_1.getPluginConfigs)(data.tsConfigPath);
+            const transformerList = (0, createTransformerList_1.createTransformerList)(program, pluginConfigs, data.projectPath);
+            const transformers = (0, createTransformerList_1.flattenIntoTransformers)(transformerList);
+            if (transformers.length > 0) {
+                const { service, updateFile } = ((_a = data.transformerWatcher) !== null && _a !== void 0 ? _a : (data.transformerWatcher = (0, createTransformerWatcher_1.createTransformerWatcher)(program)));
+                const transformResult = typescript_1.default.transformNodes(undefined, undefined, typescript_1.default.factory, compilerOptions, sourceFiles, transformers, false);
+                if (transformResult.diagnostics)
+                    DiagnosticService_1.DiagnosticService.addDiagnostics(transformResult.diagnostics);
+                for (const sourceFile of transformResult.transformed) {
+                    if (typescript_1.default.isSourceFile(sourceFile)) {
+                        const source = typescript_1.default.createPrinter().printFile(sourceFile);
+                        updateFile(sourceFile.fileName, source);
+                        if (data.projectOptions.writeTransformedFiles) {
+                            const outPath = pathTranslator.getOutputTransformedPath(sourceFile.fileName);
+                            fs_extra_1.default.outputFileSync(outPath, source);
+                        }
+                    }
+                }
+                proxyProgram = service.getProgram();
+            }
+        });
+    }
+    if (DiagnosticService_1.DiagnosticService.hasErrors())
+        return { emitSkipped: true, diagnostics: DiagnosticService_1.DiagnosticService.flush() };
+    const typeChecker = proxyProgram.getTypeChecker();
+    const services = (0, createTransformServices_1.createTransformServices)(typeChecker);
+    for (let i = 0; i < sourceFiles.length; i++) {
+        const sourceFile = proxyProgram.getSourceFile(sourceFiles[i].fileName);
+        (0, assert_1.assert)(sourceFile);
+        const progress = `${i + 1}/${sourceFiles.length}`.padStart(progressMaxLength);
+        (0, benchmark_1.benchmarkIfVerbose)(`${progress} compile ${path_1.default.relative(process.cwd(), sourceFile.fileName)}`, () => {
+            DiagnosticService_1.DiagnosticService.addDiagnostics(typescript_1.default.getPreEmitDiagnostics(proxyProgram, sourceFile));
+            DiagnosticService_1.DiagnosticService.addDiagnostics((0, getCustomPreEmitDiagnostics_1.getCustomPreEmitDiagnostics)(data, sourceFile));
+            if (DiagnosticService_1.DiagnosticService.hasErrors())
+                return;
+            const transformState = new TSTransformer_1.TransformState(proxyProgram, data, services, pathTranslator, multiTransformState, compilerOptions, rojoResolver, pkgRojoResolvers, nodeModulesPathMapping, runtimeLibRbxPath, typeChecker, projectType, getProjectPathTranslator, sourceFile);
+            const luauAST = (0, TSTransformer_1.transformSourceFile)(transformState, sourceFile);
+            if (DiagnosticService_1.DiagnosticService.hasErrors())
+                return;
+            const source = (0, luau_ast_1.renderAST)(luauAST);
+            fileWriteQueue.push({ sourceFile, source });
+        });
+    }
+    if (DiagnosticService_1.DiagnosticService.hasErrors())
+        return { emitSkipped: true, diagnostics: DiagnosticService_1.DiagnosticService.flush() };
+    const emittedFiles = new Array();
+    if (fileWriteQueue.length > 0) {
+        (0, benchmark_1.benchmarkIfVerbose)("writing compiled files", () => {
+            const afterDeclarations = compilerOptions.declaration
+                ? [transformTypeReferenceDirectives_1.transformTypeReferenceDirectives, (0, transformPaths_1.default)(program, {})]
+                : undefined;
+            for (const { sourceFile, source } of fileWriteQueue) {
+                const outPath = pathTranslator.getOutputPath(sourceFile.fileName);
+                if (!data.projectOptions.writeOnlyChanged ||
+                    !fs_extra_1.default.pathExistsSync(outPath) ||
+                    fs_extra_1.default.readFileSync(outPath).toString() !== source) {
+                    fs_extra_1.default.outputFileSync(outPath, source);
+                    emittedFiles.push(outPath);
+                }
+                if (compilerOptions.declaration) {
+                    proxyProgram.emit(sourceFile, typescript_1.default.sys.writeFile, undefined, true, { afterDeclarations });
+                }
+            }
+        });
+    }
+    program.emitBuildInfo();
+    return { emittedFiles, emitSkipped: false, diagnostics: DiagnosticService_1.DiagnosticService.flush() };
+}
+//# sourceMappingURL=compileFiles.js.map

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

@@ -0,0 +1,14 @@
+import { ProjectOptions, ReferencedProjectInfo } from "../../Shared/types";
+import ts from "typescript";
+export interface CompileProjectOptions {
+    program: ts.Program;
+    configPath: string;
+    projectOptions: ProjectOptions;
+    rootConfigPath: string;
+    rootRojoConfigPath: string | undefined;
+    rootIncludePath: string;
+    referencedProjects: Array<ReferencedProjectInfo>;
+    isInitialCompile: boolean;
+}
+export declare function compileProject(opts: CompileProjectOptions): ts.EmitResult;
+export declare function collectReferencedProjects(refs: readonly (ts.ResolvedProjectReference | undefined)[], results: Array<ReferencedProjectInfo>, rootConfigPath: string, luau: boolean, visited?: Set<string>): void;

package/out/Project/functions/compileProject.js

@@ -0,0 +1,71 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compileProject = compileProject;
+exports.collectReferencedProjects = collectReferencedProjects;
+const path_translator_1 = require("@roblox-ts/path-translator");
+const path_1 = __importDefault(require("path"));
+const cleanup_1 = require("./cleanup");
+const compileFiles_1 = require("./compileFiles");
+const copyFiles_1 = require("./copyFiles");
+const copyInclude_1 = require("./copyInclude");
+const createProjectData_1 = require("./createProjectData");
+const LogService_1 = require("../../Shared/classes/LogService");
+const getRootDirs_1 = require("../../Shared/util/getRootDirs");
+function compileProject(opts) {
+    const { program, configPath, projectOptions, rootConfigPath, rootRojoConfigPath, rootIncludePath, referencedProjects, isInitialCompile, } = opts;
+    const options = program.getCompilerOptions();
+    const normalizedConfigPath = path_1.default.normalize(configPath);
+    const isRoot = normalizedConfigPath === path_1.default.normalize(rootConfigPath);
+    LogService_1.LogService.writeLineIfVerbose(`Building: ${path_1.default.relative(process.cwd(), configPath)}`);
+    const currentProjectOptions = isRoot
+        ? projectOptions
+        : { ...projectOptions, noInclude: true, rojo: rootRojoConfigPath };
+    const data = (0, createProjectData_1.createProjectData)(configPath, currentProjectOptions);
+    data.referencedProjects = referencedProjects;
+    if (!isRoot) {
+        data.rootProjectIncludePath = rootIncludePath;
+    }
+    const configDir = path_1.default.dirname(configPath);
+    const rootDir = options.rootDir ? path_1.default.resolve(configDir, options.rootDir) : configDir;
+    const outDir = options.outDir ? path_1.default.resolve(configDir, options.outDir) : configDir;
+    const pathTranslator = new path_translator_1.PathTranslator(rootDir, outDir, undefined, options.declaration === true, projectOptions.luau);
+    if (isRoot && isInitialCompile) {
+        (0, cleanup_1.cleanup)(pathTranslator);
+        (0, copyInclude_1.copyInclude)(data);
+    }
+    (0, copyFiles_1.copyFiles)(data, pathTranslator, new Set((0, getRootDirs_1.getRootDirs)(options)));
+    const sourceFiles = program
+        .getSourceFiles()
+        .filter(sf => !sf.isDeclarationFile &&
+        !sf.fileName.includes("node_modules") &&
+        path_1.default.normalize(sf.fileName).startsWith(rootDir));
+    return (0, compileFiles_1.compileFiles)(program, data, pathTranslator, sourceFiles);
+}
+function collectReferencedProjects(refs, results, rootConfigPath, luau, visited = new Set()) {
+    for (const ref of refs) {
+        if (!ref)
+            continue;
+        const configPath = path_1.default.normalize(ref.sourceFile.fileName);
+        if (visited.has(configPath) || configPath === path_1.default.normalize(rootConfigPath))
+            continue;
+        visited.add(configPath);
+        if (ref.references) {
+            collectReferencedProjects(ref.references, results, rootConfigPath, luau, visited);
+        }
+        const options = ref.commandLine.options;
+        const configDir = path_1.default.dirname(configPath);
+        const rootDir = options.rootDir ? path_1.default.resolve(configDir, options.rootDir) : configDir;
+        const outDir = options.outDir ? path_1.default.resolve(configDir, options.outDir) : configDir;
+        results.push({
+            tsConfigPath: configPath,
+            rootDir,
+            outDir,
+            pathTranslator: new path_translator_1.PathTranslator(rootDir, outDir, undefined, true, luau),
+            fileNames: ref.commandLine.fileNames,
+        });
+    }
+}
+//# sourceMappingURL=compileProject.js.map

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

@@ -0,0 +1,3 @@
+import { PathTranslator } from "@roblox-ts/path-translator";
+import { ProjectData } from "../../Shared/types";
+export declare function copyFiles(data: ProjectData, pathTranslator: PathTranslator, sources: Set<string>): void;

package/out/Project/functions/copyFiles.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.copyFiles = copyFiles;
+const copyItem_1 = require("./copyItem");
+const benchmark_1 = require("../../Shared/util/benchmark");
+function copyFiles(data, pathTranslator, sources) {
+    (0, benchmark_1.benchmarkIfVerbose)("copy non-compiled files", () => {
+        for (const source of sources) {
+            (0, copyItem_1.copyItem)(data, pathTranslator, source);
+        }
+    });
+}
+//# sourceMappingURL=copyFiles.js.map

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

@@ -0,0 +1,2 @@
+import { ProjectData } from "../../Shared/types";
+export declare function copyInclude(data: ProjectData): void;

package/out/Project/functions/copyInclude.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.copyInclude = copyInclude;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const constants_1 = require("../../Shared/constants");
+const benchmark_1 = require("../../Shared/util/benchmark");
+function copyInclude(data) {
+    if (!data.projectOptions.noInclude &&
+        data.projectOptions.type !== constants_1.ProjectType.Package &&
+        !(data.projectOptions.type === undefined && data.isPackage)) {
+        (0, benchmark_1.benchmarkIfVerbose)("copy include files", () => fs_extra_1.default.copySync(constants_1.INCLUDE_PATH, data.projectOptions.includePath, { dereference: true }));
+    }
+}
+//# sourceMappingURL=copyInclude.js.map

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

@@ -0,0 +1,3 @@
+import { PathTranslator } from "@roblox-ts/path-translator";
+import { ProjectData } from "..";
+export declare function copyItem(data: ProjectData, pathTranslator: PathTranslator, item: string): void;

package/out/Project/functions/copyItem.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.copyItem = copyItem;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const isCompilableFile_1 = require("../util/isCompilableFile");
+const constants_1 = require("../../Shared/constants");
+function copyItem(data, pathTranslator, item) {
+    fs_extra_1.default.copySync(item, pathTranslator.getOutputPath(item), {
+        filter: (src, dest) => {
+            if (data.projectOptions.writeOnlyChanged &&
+                fs_extra_1.default.pathExistsSync(dest) &&
+                !fs_extra_1.default.lstatSync(src).isDirectory() &&
+                fs_extra_1.default.readFileSync(src).toString() === fs_extra_1.default.readFileSync(dest).toString()) {
+                return false;
+            }
+            if (src.endsWith(constants_1.DTS_EXT)) {
+                return pathTranslator.declaration;
+            }
+            return !(0, isCompilableFile_1.isCompilableFile)(src);
+        },
+        dereference: true,
+    });
+}
+//# sourceMappingURL=copyItem.js.map

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

@@ -0,0 +1 @@
+export declare function createNodeModulesPathMapping(typeRoots: Array<string>): Map<string, string>;

package/out/Project/functions/createNodeModulesPathMapping.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNodeModulesPathMapping = createNodeModulesPathMapping;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const getCanonicalFileName_1 = require("../../Shared/util/getCanonicalFileName");
+const realPathExistsSync_1 = require("../../Shared/util/realPathExistsSync");
+function createNodeModulesPathMapping(typeRoots) {
+    var _a, _b;
+    const nodeModulesPathMapping = new Map();
+    for (const scopePath of typeRoots) {
+        if (fs_extra_1.default.pathExistsSync(scopePath)) {
+            for (const pkgName of fs_extra_1.default.readdirSync(scopePath)) {
+                const pkgPath = path_1.default.join(scopePath, pkgName);
+                const pkgJsonPath = (0, realPathExistsSync_1.realPathExistsSync)(path_1.default.join(pkgPath, "package.json"));
+                if (pkgJsonPath !== undefined) {
+                    const pkgJson = fs_extra_1.default.readJsonSync(pkgJsonPath);
+                    const typesPath = (_b = (_a = pkgJson.types) !== null && _a !== void 0 ? _a : pkgJson.typings) !== null && _b !== void 0 ? _b : "index.d.ts";
+                    if (pkgJson.main) {
+                        nodeModulesPathMapping.set((0, getCanonicalFileName_1.getCanonicalFileName)(path_1.default.resolve(pkgPath, typesPath)), path_1.default.resolve(pkgPath, pkgJson.main));
+                    }
+                }
+            }
+        }
+    }
+    return nodeModulesPathMapping;
+}
+//# sourceMappingURL=createNodeModulesPathMapping.js.map

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

@@ -0,0 +1,4 @@
+import { PathTranslator } from "@roblox-ts/path-translator";
+import { ProjectData } from "../../Shared/types";
+import ts from "typescript";
+export declare function createPathTranslator(compilerOptions: ts.CompilerOptions, data: ProjectData): PathTranslator;

package/out/Project/functions/createPathTranslator.js

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPathTranslator = createPathTranslator;
+const path_translator_1 = require("@roblox-ts/path-translator");
+const path_1 = __importDefault(require("path"));
+const findAncestorDir_1 = require("../../Shared/util/findAncestorDir");
+const getRootDirs_1 = require("../../Shared/util/getRootDirs");
+const typescript_1 = __importDefault(require("typescript"));
+function createPathTranslator(compilerOptions, data) {
+    const rootDir = (0, findAncestorDir_1.findAncestorDir)((0, getRootDirs_1.getRootDirs)(compilerOptions));
+    const outDir = compilerOptions.outDir;
+    let buildInfoPath = typescript_1.default.getTsBuildInfoEmitOutputFilePath(compilerOptions);
+    if (buildInfoPath !== undefined) {
+        buildInfoPath = path_1.default.normalize(buildInfoPath);
+    }
+    const declaration = compilerOptions.declaration === true;
+    return new path_translator_1.PathTranslator(rootDir, outDir, buildInfoPath, declaration, data.projectOptions.luau);
+}
+//# sourceMappingURL=createPathTranslator.js.map

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

@@ -0,0 +1,3 @@
+import { ProjectData } from "..";
+import ts from "typescript";
+export declare function createProgramFactory(data: ProjectData, options: ts.CompilerOptions, projectReferences?: ReadonlyArray<ts.ProjectReference>): ts.CreateProgram<ts.EmitAndSemanticDiagnosticsBuilderProgram>;

package/out/Project/functions/createProgramFactory.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createProgramFactory = createProgramFactory;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const createReadBuildProgramHost_1 = require("../util/createReadBuildProgramHost");
+const constants_1 = require("../../Shared/constants");
+const assert_1 = require("../../Shared/util/assert");
+const typescript_1 = __importDefault(require("typescript"));
+function createCompilerHost(data, compilerOptions) {
+    var _a;
+    const host = typescript_1.default.createIncrementalCompilerHost(compilerOptions);
+    let contentsToHash = "";
+    contentsToHash += `version=${constants_1.COMPILER_VERSION},`;
+    contentsToHash += `type=${String(data.projectOptions.type)},`;
+    contentsToHash += `isPackage=${String(data.isPackage)},`;
+    contentsToHash += `plugins=${JSON.stringify((_a = compilerOptions.plugins) !== null && _a !== void 0 ? _a : [])},`;
+    if (data.rojoConfigPath && fs_extra_1.default.existsSync(data.rojoConfigPath)) {
+        contentsToHash += fs_extra_1.default.readFileSync(data.rojoConfigPath).toString();
+    }
+    (0, assert_1.assert)(host.createHash);
+    const origCreateHash = host.createHash;
+    host.createHash = (data) => origCreateHash(contentsToHash + data);
+    return host;
+}
+function createProgramFactory(data, options, projectReferences) {
+    return (rootNames, compilerOptions = options, host = createCompilerHost(data, options), oldProgram = typescript_1.default.readBuilderProgram(options, (0, createReadBuildProgramHost_1.createReadBuildProgramHost)()), configFileParsingDiagnostics, refs = projectReferences) => typescript_1.default.createEmitAndSemanticDiagnosticsBuilderProgram(rootNames, compilerOptions, host, oldProgram, configFileParsingDiagnostics, refs);
+}
+//# sourceMappingURL=createProgramFactory.js.map

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

@@ -0,0 +1,2 @@
+import { ProjectData, ProjectOptions } from "../../Shared/types";
+export declare function createProjectData(tsConfigPath: string, projectOptions: ProjectOptions): ProjectData;

package/out/Project/functions/createProjectData.js

@@ -0,0 +1,102 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createProjectData = createProjectData;
+const rojo_resolver_1 = require("@roblox-ts/rojo-resolver");
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const LogService_1 = require("../../Shared/classes/LogService");
+const constants_1 = require("../../Shared/constants");
+const ProjectError_1 = require("../../Shared/errors/ProjectError");
+const typescript_1 = __importDefault(require("typescript"));
+const PACKAGE_REGEX = /^@[a-z0-9-]*\//;
+function createProjectData(tsConfigPath, projectOptions) {
+    var _a;
+    const projectPath = path_1.default.dirname(tsConfigPath);
+    const pkgJsonPath = typescript_1.default.findPackageJson(projectPath, typescript_1.default.sys);
+    if (!pkgJsonPath) {
+        throw new ProjectError_1.ProjectError("Unable to find package.json");
+    }
+    let isPackage = false;
+    try {
+        const pkgJson = JSON.parse(fs_extra_1.default.readFileSync(pkgJsonPath).toString());
+        isPackage = PACKAGE_REGEX.test((_a = pkgJson.name) !== null && _a !== void 0 ? _a : "");
+    }
+    catch {
+    }
+    projectOptions.includePath = path_1.default.resolve(projectOptions.includePath || path_1.default.join(projectPath, "include"));
+    const nodeModulesPath = path_1.default.join(path_1.default.dirname(pkgJsonPath), constants_1.NODE_MODULES);
+    let rojoConfigPath;
+    if (projectOptions.rojo) {
+        rojoConfigPath = path_1.default.resolve(projectOptions.rojo);
+    }
+    else {
+        const { path, warnings } = rojo_resolver_1.RojoResolver.findRojoConfigFilePath(projectPath);
+        rojoConfigPath = path;
+        for (const warning of warnings) {
+            LogService_1.LogService.warn(warning);
+        }
+    }
+    return {
+        tsConfigPath,
+        isPackage,
+        nodeModulesPath,
+        projectOptions,
+        projectPath,
+        rojoConfigPath,
+        referencedProjects: collectProjectReferences(tsConfigPath, new Set(), projectOptions.luau),
+    };
+}
+function collectProjectReferences(tsConfigPath, visited, luau) {
+    const normalizedPath = path_1.default.normalize(tsConfigPath);
+    if (visited.has(normalizedPath)) {
+        return [];
+    }
+    visited.add(normalizedPath);
+    const parsed = parseProjectConfig(tsConfigPath);
+    if (!parsed) {
+        return [];
+    }
+    const results = [];
+    for (const ref of parsed.references) {
+        const refConfigPath = resolveReferencePath(tsConfigPath, ref.path);
+        const refParsed = parseProjectConfig(refConfigPath);
+        if (!refParsed) {
+            continue;
+        }
+        results.push(...collectProjectReferences(refConfigPath, visited, luau), {
+            tsConfigPath: refConfigPath,
+            rootDir: refParsed.rootDir,
+            outDir: refParsed.outDir,
+        });
+    }
+    return results;
+}
+function parseProjectConfig(tsConfigPath) {
+    var _a, _b, _c;
+    const configFile = typescript_1.default.readConfigFile(tsConfigPath, typescript_1.default.sys.readFile);
+    if (configFile.error) {
+        return undefined;
+    }
+    const configDir = path_1.default.dirname(tsConfigPath);
+    const parsedConfig = typescript_1.default.parseJsonConfigFileContent(configFile.config, typescript_1.default.sys, configDir);
+    const rootDir = (_a = parsedConfig.options.rootDir) !== null && _a !== void 0 ? _a : configDir;
+    const outDir = (_b = parsedConfig.options.outDir) !== null && _b !== void 0 ? _b : configDir;
+    return {
+        tsConfigPath,
+        rootDir: path_1.default.resolve(configDir, rootDir),
+        outDir: path_1.default.resolve(configDir, outDir),
+        references: (_c = parsedConfig.projectReferences) !== null && _c !== void 0 ? _c : [],
+    };
+}
+function resolveReferencePath(fromConfigPath, refPath) {
+    const configDir = path_1.default.dirname(fromConfigPath);
+    const resolvedPath = path_1.default.resolve(configDir, refPath);
+    if (typescript_1.default.sys.directoryExists(resolvedPath)) {
+        return path_1.default.join(resolvedPath, "tsconfig.json");
+    }
+    return resolvedPath;
+}
+//# sourceMappingURL=createProjectData.js.map

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

@@ -0,0 +1,3 @@
+import { ProjectData } from "../../Shared/types";
+import ts from "typescript";
+export declare function createProjectProgram(data: ProjectData, host?: ts.CompilerHost): ts.EmitAndSemanticDiagnosticsBuilderProgram;

package/out/Project/functions/createProjectProgram.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createProjectProgram = createProjectProgram;
+const createProgramFactory_1 = require("./createProgramFactory");
+const getParsedCommandLine_1 = require("./getParsedCommandLine");
+function createProjectProgram(data, host) {
+    const { fileNames, options, projectReferences } = (0, getParsedCommandLine_1.getParsedCommandLine)(data);
+    const createProgram = (0, createProgramFactory_1.createProgramFactory)(data, options, projectReferences);
+    return createProgram(fileNames, options, host);
+}
+//# sourceMappingURL=createProjectProgram.js.map

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

@@ -0,0 +1,2 @@
+import ts from "typescript";
+export declare function getChangedFilePaths(program: ts.BuilderProgram, pathHints?: Array<string>): Set<string>;

package/out/Project/functions/getChangedFilePaths.js

@@ -0,0 +1,47 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getChangedFilePaths = getChangedFilePaths;
+const getCanonicalFileName_1 = require("../../Shared/util/getCanonicalFileName");
+const getOrSetDefault_1 = require("../../Shared/util/getOrSetDefault");
+const typescript_1 = __importDefault(require("typescript"));
+function getChangedFilePaths(program, pathHints) {
+    var _a, _b, _c;
+    const compilerOptions = program.getCompilerOptions();
+    const buildState = program.getState();
+    const reversedReferencedMap = new Map();
+    const referencedMap = buildState.referencedMap;
+    if (referencedMap) {
+        for (const filePath of typescript_1.default.arrayFrom(referencedMap.keys())) {
+            (_a = referencedMap.getValues(filePath)) === null || _a === void 0 ? void 0 : _a.forEach((_, refFilePath) => {
+                (0, getOrSetDefault_1.getOrSetDefault)(reversedReferencedMap, refFilePath, () => new Set()).add(filePath);
+            });
+        }
+    }
+    const changedFilesSet = new Set();
+    const search = (filePath) => {
+        var _a;
+        changedFilesSet.add(filePath);
+        (_a = reversedReferencedMap.get(filePath)) === null || _a === void 0 ? void 0 : _a.forEach(refFilePath => {
+            if (!changedFilesSet.has(refFilePath)) {
+                changedFilesSet.add(refFilePath);
+                if (compilerOptions.assumeChangesOnlyAffectDirectDependencies !== true) {
+                    search(refFilePath);
+                }
+            }
+        });
+    };
+    if (pathHints) {
+        for (const hint of pathHints) {
+            search((0, getCanonicalFileName_1.getCanonicalFileName)(hint));
+        }
+    }
+    else {
+        (_b = buildState.changedFilesSet) === null || _b === void 0 ? void 0 : _b.forEach((_, fileName) => search(fileName));
+        (_c = buildState.changedFilesSet) === null || _c === void 0 ? void 0 : _c.clear();
+    }
+    return changedFilesSet;
+}
+//# sourceMappingURL=getChangedFilePaths.js.map

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

@@ -0,0 +1,2 @@
+import ts from "typescript";
+export declare function getChangedSourceFiles(program: ts.BuilderProgram, pathHints?: Array<string>): ts.SourceFile[];

package/out/Project/functions/getChangedSourceFiles.js

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getChangedSourceFiles = getChangedSourceFiles;
+const getChangedFilePaths_1 = require("./getChangedFilePaths");
+const typescript_1 = __importDefault(require("typescript"));
+function getChangedSourceFiles(program, pathHints) {
+    const sourceFiles = new Array();
+    for (const fileName of (0, getChangedFilePaths_1.getChangedFilePaths)(program, pathHints)) {
+        const sourceFile = program.getSourceFile(fileName);
+        if (sourceFile && !sourceFile.isDeclarationFile && !typescript_1.default.isJsonSourceFile(sourceFile)) {
+            sourceFiles.push(sourceFile);
+        }
+    }
+    return sourceFiles;
+}
+//# sourceMappingURL=getChangedSourceFiles.js.map

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

@@ -0,0 +1,3 @@
+import { ProjectData } from "..";
+import ts from "typescript";
+export declare function getParsedCommandLine(data: ProjectData): ts.ParsedCommandLine;