@jackctaylor/roblox-ts 3.0.0-projectrefs.0

package/out/Project/transformers/builtin/transformPaths.js

@@ -0,0 +1,129 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = transformer;
+const path_1 = __importDefault(require("path"));
+const typescript_1 = __importDefault(require("typescript"));
+const url_1 = __importDefault(require("url"));
+const getImplicitExtensions = (options) => {
+    let res = [".ts", ".d.ts"];
+    let { allowJs, jsx, resolveJsonModule: allowJson } = options;
+    const allowJsx = !!jsx && jsx !== typescript_1.default.JsxEmit.None;
+    allowJs && res.push(".js");
+    allowJsx && res.push(".tsx");
+    allowJs && allowJsx && res.push(".jsx");
+    allowJson && res.push(".json");
+    return res;
+};
+const isURL = (s) => !!s && (!!url_1.default.parse(s).host || !!url_1.default.parse(s).hostname);
+const isBaseDir = (base, dir) => { var _a; return ((_a = path_1.default.relative(base, dir)) === null || _a === void 0 ? void 0 : _a[0]) !== "."; };
+const isRequire = (node) => typescript_1.default.isCallExpression(node) &&
+    typescript_1.default.isIdentifier(node.expression) &&
+    node.expression.text === "require" &&
+    typescript_1.default.isStringLiteral(node.arguments[0]) &&
+    node.arguments.length === 1;
+const isAsyncImport = (node) => typescript_1.default.isCallExpression(node) &&
+    node.expression.kind === typescript_1.default.SyntaxKind.ImportKeyword &&
+    typescript_1.default.isStringLiteral(node.arguments[0]) &&
+    node.arguments.length === 1;
+function transformer(program, config) {
+    const { useRootDirs } = config;
+    const compilerOptions = program.getCompilerOptions();
+    const implicitExtensions = getImplicitExtensions(compilerOptions);
+    return (context) => (sourceFile) => {
+        var _a;
+        if (typescript_1.default.isBundle(sourceFile))
+            return sourceFile;
+        const factory = context.factory;
+        const { fileName } = sourceFile;
+        const fileDir = typescript_1.default.normalizePath(path_1.default.dirname(fileName));
+        if (!compilerOptions.baseUrl && !compilerOptions.paths)
+            return sourceFile;
+        let rootDirs = (_a = compilerOptions.rootDirs) === null || _a === void 0 ? void 0 : _a.filter(path_1.default.isAbsolute);
+        return typescript_1.default.visitEachChild(sourceFile, visit, context);
+        function update(original, moduleName, updaterFn) {
+            let p;
+            const { resolvedModule, failedLookupLocations } = typescript_1.default.resolveModuleName(moduleName, fileName, compilerOptions, typescript_1.default.sys);
+            if (!resolvedModule) {
+                const maybeURL = failedLookupLocations[0];
+                if (!isURL(maybeURL))
+                    return original;
+                p = maybeURL;
+            }
+            else if (resolvedModule.isExternalLibraryImport)
+                return original;
+            else {
+                const { extension, resolvedFileName } = resolvedModule;
+                let filePath = fileDir;
+                let modulePath = path_1.default.dirname(resolvedFileName);
+                if (useRootDirs && rootDirs) {
+                    let fileRootDir = "";
+                    let moduleRootDir = "";
+                    for (const rootDir of rootDirs) {
+                        if (isBaseDir(rootDir, resolvedFileName) && rootDir.length > moduleRootDir.length)
+                            moduleRootDir = rootDir;
+                        if (isBaseDir(rootDir, fileName) && rootDir.length > fileRootDir.length)
+                            fileRootDir = rootDir;
+                    }
+                    if (fileRootDir && moduleRootDir) {
+                        filePath = path_1.default.relative(fileRootDir, filePath);
+                        modulePath = path_1.default.relative(moduleRootDir, modulePath);
+                    }
+                }
+                p = typescript_1.default.normalizePath(path_1.default.join(path_1.default.relative(filePath, modulePath), path_1.default.basename(resolvedFileName)));
+                if (extension && implicitExtensions.includes(extension))
+                    p = p.slice(0, -extension.length);
+                if (!p)
+                    return original;
+                p = p[0] === "." ? p : `./${p}`;
+            }
+            const newStringLiteral = factory.createStringLiteral(p);
+            return updaterFn(newStringLiteral);
+        }
+        function visit(node) {
+            if (isRequire(node) || isAsyncImport(node))
+                return update(node, node.arguments[0].text, p => {
+                    const res = factory.updateCallExpression(node, node.expression, node.typeArguments, [p]);
+                    const textNode = node.arguments[0];
+                    const commentRanges = typescript_1.default.getLeadingCommentRanges(textNode.getFullText(), 0) || [];
+                    for (const range of commentRanges) {
+                        const { kind, pos, end, hasTrailingNewLine } = range;
+                        const caption = textNode
+                            .getFullText()
+                            .substr(pos, end)
+                            .replace(kind === typescript_1.default.SyntaxKind.MultiLineCommentTrivia
+                            ?
+                                /^\/\*(.+)\*\/.*/s
+                            : /^\/\/(.+)/s, "$1");
+                        typescript_1.default.addSyntheticLeadingComment(p, kind, caption, hasTrailingNewLine);
+                    }
+                    return res;
+                });
+            if (typescript_1.default.isExternalModuleReference(node) && typescript_1.default.isStringLiteral(node.expression))
+                return update(node, node.expression.text, p => factory.updateExternalModuleReference(node, p));
+            if ((typescript_1.default.isImportDeclaration(node) || typescript_1.default.isExportDeclaration(node)) &&
+                node.moduleSpecifier &&
+                typescript_1.default.isStringLiteral(node.moduleSpecifier))
+                return update(node, node.moduleSpecifier.text, p => {
+                    const newNode = factory.cloneNode(node.moduleSpecifier);
+                    typescript_1.default.setSourceMapRange(newNode, typescript_1.default.getSourceMapRange(node));
+                    typescript_1.default.setTextRange(newNode, node.moduleSpecifier);
+                    newNode.text = p.text;
+                    return Object.assign(node, { moduleSpecifier: newNode });
+                });
+            if (typescript_1.default.isImportTypeNode(node)) {
+                const argument = node.argument;
+                if (!typescript_1.default.isStringLiteral(argument.literal))
+                    return node;
+                const { text } = argument.literal;
+                return !text
+                    ? node
+                    : update(node, text, p => factory.updateImportTypeNode(node, factory.updateLiteralTypeNode(argument, p), node.attributes, node.qualifier, node.typeArguments, node.isTypeOf));
+            }
+            return typescript_1.default.visitEachChild(node, visit, context);
+        }
+    };
+}
+//# sourceMappingURL=transformPaths.js.map

package/out/Project/transformers/builtin/transformTypeReferenceDirectives.d.ts

@@ -0,0 +1,2 @@
+import ts from "typescript";
+export declare function transformTypeReferenceDirectives(): (sourceFile: ts.SourceFile | ts.Bundle) => ts.SourceFile | ts.Bundle;

package/out/Project/transformers/builtin/transformTypeReferenceDirectives.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformTypeReferenceDirectives = transformTypeReferenceDirectives;
+const typescript_1 = __importDefault(require("typescript"));
+const SCOPE = "@rbxts/";
+const PACKAGE = "types";
+function transformTypeReferenceDirectives() {
+    return (sourceFile) => {
+        if (typescript_1.default.isSourceFile(sourceFile)) {
+            for (const typeReferenceDirective of sourceFile.typeReferenceDirectives) {
+                if (typeReferenceDirective.fileName === PACKAGE) {
+                    typeReferenceDirective.fileName = SCOPE + PACKAGE;
+                    typeReferenceDirective.end += SCOPE.length;
+                }
+            }
+        }
+        return sourceFile;
+    };
+}
+//# sourceMappingURL=transformTypeReferenceDirectives.js.map

package/out/Project/transformers/createTransformerList.d.ts

@@ -0,0 +1,4 @@
+import { TransformerPluginConfig } from "../../Shared/types";
+import ts from "typescript";
+export declare function flattenIntoTransformers(transformers: ts.CustomTransformers): Array<ts.TransformerFactory<ts.SourceFile | ts.Bundle>>;
+export declare function createTransformerList(program: ts.Program, configs: Array<TransformerPluginConfig>, baseDir: string): ts.CustomTransformers;

package/out/Project/transformers/createTransformerList.js

@@ -0,0 +1,87 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.flattenIntoTransformers = flattenIntoTransformers;
+exports.createTransformerList = createTransformerList;
+const resolve_1 = __importDefault(require("resolve"));
+const diagnostics_1 = require("../../Shared/diagnostics");
+const DiagnosticService_1 = require("../../TSTransformer/classes/DiagnosticService");
+const typescript_1 = __importDefault(require("typescript"));
+function getTransformerFromFactory(factory, config, program) {
+    const { after, afterDeclarations, type, ...manualConfig } = config;
+    let transformer;
+    switch (type) {
+        case undefined:
+        case "program":
+            transformer = factory(program, manualConfig, { ts: typescript_1.default });
+            break;
+        case "checker":
+            transformer = factory(program.getTypeChecker(), manualConfig);
+            break;
+        case "compilerOptions":
+            transformer = factory(program.getCompilerOptions(), manualConfig);
+            break;
+        case "config":
+            transformer = factory(manualConfig);
+            break;
+        case "raw":
+            transformer = (ctx) => factory(ctx, program, manualConfig);
+            break;
+        default:
+            return undefined;
+    }
+    if (typeof transformer === "function") {
+        if (after) {
+            return { after: transformer };
+        }
+        else if (afterDeclarations) {
+            return { afterDeclarations: transformer };
+        }
+        return { before: transformer };
+    }
+    return transformer;
+}
+function flattenIntoTransformers(transformers) {
+    const result = [];
+    result.push(...transformers.after, ...transformers.before, ...transformers.afterDeclarations);
+    return result;
+}
+function createTransformerList(program, configs, baseDir) {
+    var _a, _b, _c, _d;
+    const transforms = {
+        before: [],
+        after: [],
+        afterDeclarations: [],
+    };
+    for (const config of configs) {
+        if (!config.transform)
+            continue;
+        try {
+            const modulePath = resolve_1.default.sync(config.transform, { basedir: baseDir });
+            const commonjsModule = require(modulePath);
+            const factoryModule = typeof commonjsModule === "function" ? { default: commonjsModule } : commonjsModule;
+            const factory = factoryModule[(_a = config.import) !== null && _a !== void 0 ? _a : "default"];
+            if (!factory || typeof factory !== "function")
+                throw new Error("factory not a function");
+            const transformer = getTransformerFromFactory(factory, config, program);
+            if (transformer) {
+                if (transformer.afterDeclarations) {
+                    (_b = transforms.afterDeclarations) === null || _b === void 0 ? void 0 : _b.push(transformer.afterDeclarations);
+                }
+                if (transformer.after) {
+                    (_c = transforms.after) === null || _c === void 0 ? void 0 : _c.push(transformer.after);
+                }
+                if (transformer.before) {
+                    (_d = transforms.before) === null || _d === void 0 ? void 0 : _d.push(transformer.before);
+                }
+            }
+        }
+        catch (err) {
+            DiagnosticService_1.DiagnosticService.addDiagnostic(diagnostics_1.warnings.transformerNotFound(config.transform, err));
+        }
+    }
+    return transforms;
+}
+//# sourceMappingURL=createTransformerList.js.map

package/out/Project/transformers/createTransformerWatcher.d.ts

@@ -0,0 +1,3 @@
+import { TransformerWatcher } from "../../Shared/types";
+import ts from "typescript";
+export declare function createTransformerWatcher(program: ts.Program): TransformerWatcher;

package/out/Project/transformers/createTransformerWatcher.js

@@ -0,0 +1,59 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTransformerWatcher = createTransformerWatcher;
+const typescript_1 = __importDefault(require("typescript"));
+function createServiceHost(program) {
+    const rootFileNames = program.getRootFileNames().map(x => x);
+    const files = new Map();
+    rootFileNames.forEach(fileName => {
+        files.set(fileName, 0);
+    });
+    const overriddenText = new Map();
+    function updateFile(fileName, text) {
+        var _a;
+        overriddenText.set(fileName, text);
+        const currentVersion = (_a = files.get(fileName)) !== null && _a !== void 0 ? _a : 0;
+        files.set(fileName, currentVersion + 1);
+    }
+    const serviceHost = {
+        getScriptFileNames: () => [...files.keys()].filter(typescript_1.default.sys.fileExists),
+        getCurrentDirectory: () => process.cwd(),
+        getCompilationSettings: () => program.getCompilerOptions(),
+        getDefaultLibFileName: options => typescript_1.default.getDefaultLibFilePath(options),
+        fileExists: typescript_1.default.sys.fileExists,
+        readDirectory: typescript_1.default.sys.readDirectory,
+        directoryExists: typescript_1.default.sys.directoryExists,
+        getDirectories: typescript_1.default.sys.getDirectories,
+        getScriptVersion,
+        getScriptSnapshot,
+        readFile,
+        getProjectReferences: () => program.getProjectReferences(),
+    };
+    function getScriptVersion(fileName) {
+        var _a;
+        const version = (_a = files.get(fileName)) === null || _a === void 0 ? void 0 : _a.toString();
+        return version !== null && version !== void 0 ? version : "0";
+    }
+    function getScriptSnapshot(fileName) {
+        const content = readFile(fileName);
+        if (content === undefined)
+            return;
+        return typescript_1.default.ScriptSnapshot.fromString(content);
+    }
+    function readFile(fileName, encoding) {
+        const content = overriddenText.get(fileName);
+        if (content !== undefined)
+            return content;
+        return typescript_1.default.sys.readFile(fileName, encoding);
+    }
+    return { serviceHost, updateFile };
+}
+function createTransformerWatcher(program) {
+    const { serviceHost, updateFile } = createServiceHost(program);
+    const service = typescript_1.default.createLanguageService(serviceHost, typescript_1.default.createDocumentRegistry());
+    return { service, updateFile };
+}
+//# sourceMappingURL=createTransformerWatcher.js.map

package/out/Project/transformers/getPluginConfigs.d.ts

@@ -0,0 +1,2 @@
+import { TransformerPluginConfig } from "../../Shared/types";
+export declare function getPluginConfigs(tsConfigPath: string): TransformerPluginConfig[];

package/out/Project/transformers/getPluginConfigs.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPluginConfigs = getPluginConfigs;
+const path_1 = __importDefault(require("path"));
+const ProjectError_1 = require("../../Shared/errors/ProjectError");
+const typescript_1 = __importDefault(require("typescript"));
+function getPluginConfigs(tsConfigPath) {
+    var _a;
+    const configFile = typescript_1.default.readConfigFile(tsConfigPath, typescript_1.default.sys.readFile);
+    if (configFile.error) {
+        throw new ProjectError_1.ProjectError(configFile.error.messageText.toString());
+    }
+    const pluginConfigs = new Array();
+    const config = configFile.config;
+    const plugins = (_a = config.compilerOptions) === null || _a === void 0 ? void 0 : _a.plugins;
+    if (plugins && Array.isArray(plugins)) {
+        for (const pluginConfig of plugins) {
+            if (pluginConfig.transform && typeof pluginConfig.transform === "string") {
+                pluginConfigs.push(pluginConfig);
+            }
+        }
+    }
+    if (config.extends) {
+        const extendedPath = require.resolve(config.extends, {
+            paths: [path_1.default.dirname(tsConfigPath)],
+        });
+        pluginConfigs.push(...getPluginConfigs(extendedPath));
+    }
+    return pluginConfigs;
+}
+//# sourceMappingURL=getPluginConfigs.js.map

package/out/Project/util/createReadBuildProgramHost.d.ts

@@ -0,0 +1,5 @@
+export declare function createReadBuildProgramHost(): {
+    getCurrentDirectory: () => string;
+    readFile: (path: string, encoding?: string) => string | undefined;
+    useCaseSensitiveFileNames: () => boolean;
+};

package/out/Project/util/createReadBuildProgramHost.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createReadBuildProgramHost = createReadBuildProgramHost;
+const typescript_1 = __importDefault(require("typescript"));
+function createReadBuildProgramHost() {
+    return {
+        getCurrentDirectory: typescript_1.default.sys.getCurrentDirectory,
+        readFile: typescript_1.default.sys.readFile,
+        useCaseSensitiveFileNames: () => typescript_1.default.sys.useCaseSensitiveFileNames,
+    };
+}
+//# sourceMappingURL=createReadBuildProgramHost.js.map

package/out/Project/util/getCustomPreEmitDiagnostics.d.ts

@@ -0,0 +1,4 @@
+import { ProjectData } from "../../Shared/types";
+import ts from "typescript";
+export type PreEmitChecker = (data: ProjectData, sourceFile: ts.SourceFile) => Array<ts.Diagnostic>;
+export declare function getCustomPreEmitDiagnostics(data: ProjectData, sourceFile: ts.SourceFile): ts.Diagnostic[];

package/out/Project/util/getCustomPreEmitDiagnostics.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCustomPreEmitDiagnostics = getCustomPreEmitDiagnostics;
+const fileUsesCommentDirectives_1 = require("../preEmitDiagnostics/fileUsesCommentDirectives");
+const PRE_EMIT_DIAGNOSTICS = [fileUsesCommentDirectives_1.fileUsesCommentDirectives];
+function getCustomPreEmitDiagnostics(data, sourceFile) {
+    const diagnostics = new Array();
+    for (const check of PRE_EMIT_DIAGNOSTICS) {
+        diagnostics.push(...check(data, sourceFile));
+    }
+    return diagnostics;
+}
+//# sourceMappingURL=getCustomPreEmitDiagnostics.js.map

package/out/Project/util/isCompilableFile.d.ts

@@ -0,0 +1 @@
+export declare function isCompilableFile(fsPath: string): boolean;

package/out/Project/util/isCompilableFile.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.isCompilableFile = isCompilableFile;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const constants_1 = require("../../Shared/constants");
+function isCompilableFile(fsPath) {
+    if (fs_extra_1.default.statSync(fsPath).isDirectory()) {
+        return false;
+    }
+    if (fsPath.endsWith(constants_1.DTS_EXT)) {
+        return false;
+    }
+    return fsPath.endsWith(constants_1.TS_EXT) || fsPath.endsWith(constants_1.TSX_EXT);
+}
+//# sourceMappingURL=isCompilableFile.js.map

package/out/Project/util/walkDirectorySync.d.ts

@@ -0,0 +1 @@
+export declare function walkDirectorySync(dir: string, callback: (fsPath: string) => void): void;

package/out/Project/util/walkDirectorySync.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.walkDirectorySync = walkDirectorySync;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+function walkDirectorySync(dir, callback) {
+    const queue = [dir];
+    for (let i = 0; i < queue.length; i++) {
+        const currentDir = queue[i];
+        for (const child of fs_extra_1.default.readdirSync(currentDir)) {
+            const fsPath = path_1.default.join(currentDir, child);
+            callback(fsPath);
+            if (fs_extra_1.default.statSync(fsPath).isDirectory()) {
+                queue.push(fsPath);
+            }
+        }
+    }
+}
+//# sourceMappingURL=walkDirectorySync.js.map

package/out/Shared/classes/Lazy.d.ts

@@ -0,0 +1,8 @@
+export declare class Lazy<T> {
+    private readonly getValue;
+    private isInitialized;
+    private value;
+    constructor(getValue: () => T);
+    get(): T;
+    set(value: T): void;
+}

package/out/Shared/classes/Lazy.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Lazy = void 0;
+class Lazy {
+    constructor(getValue) {
+        this.getValue = getValue;
+        this.isInitialized = false;
+    }
+    get() {
+        if (!this.isInitialized) {
+            this.isInitialized = true;
+            this.value = this.getValue();
+        }
+        return this.value;
+    }
+    set(value) {
+        this.isInitialized = true;
+        this.value = value;
+    }
+}
+exports.Lazy = Lazy;
+//# sourceMappingURL=Lazy.js.map

package/out/Shared/classes/LogService.d.ts

@@ -0,0 +1,9 @@
+export declare class LogService {
+    static verbose: boolean;
+    private static partial;
+    static write(message: string): void;
+    static writeLine(...messages: Array<unknown>): void;
+    static writeLineIfVerbose(...messages: Array<unknown>): void;
+    static warn(message: string): void;
+    static fatal(message: string): never;
+}

package/out/Shared/classes/LogService.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogService = void 0;
+const kleur_1 = __importDefault(require("kleur"));
+class LogService {
+    static write(message) {
+        this.partial = !message.endsWith("\n");
+        process.stdout.write(message);
+    }
+    static writeLine(...messages) {
+        if (this.partial) {
+            this.write("\n");
+        }
+        for (const message of messages) {
+            this.write(message + "\n");
+        }
+    }
+    static writeLineIfVerbose(...messages) {
+        if (this.verbose) {
+            this.writeLine(...messages);
+        }
+    }
+    static warn(message) {
+        this.writeLine(`${kleur_1.default.yellow("Compiler Warning:")} ${message}`);
+    }
+    static fatal(message) {
+        this.writeLine(message);
+        process.exit(1);
+    }
+}
+exports.LogService = LogService;
+LogService.verbose = false;
+LogService.partial = false;
+//# sourceMappingURL=LogService.js.map

package/out/Shared/constants.d.ts

@@ -0,0 +1,23 @@
+import { ProjectOptions } from "./types";
+export declare const PACKAGE_ROOT: string;
+export declare const INCLUDE_PATH: string;
+export declare const COMPILER_VERSION: string;
+export declare const NODE_MODULES = "node_modules";
+export declare const RBXTS_SCOPE = "@rbxts";
+export declare const TS_EXT = ".ts";
+export declare const TSX_EXT = ".tsx";
+export declare const D_EXT = ".d";
+export declare const DTS_EXT: string;
+export declare const INDEX_NAME = "index";
+export declare const INIT_NAME = "init";
+export declare const SERVER_SUBEXT = ".server";
+export declare const CLIENT_SUBEXT = ".client";
+export declare const MODULE_SUBEXT = "";
+export declare const FILENAME_WARNINGS: Map<string, string>;
+export declare const PARENT_FIELD = "Parent";
+export declare enum ProjectType {
+    Game = "game",
+    Model = "model",
+    Package = "package"
+}
+export declare const DEFAULT_PROJECT_OPTIONS: ProjectOptions;

package/out/Shared/constants.js

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_PROJECT_OPTIONS = exports.ProjectType = exports.PARENT_FIELD = exports.FILENAME_WARNINGS = exports.MODULE_SUBEXT = exports.CLIENT_SUBEXT = exports.SERVER_SUBEXT = exports.INIT_NAME = exports.INDEX_NAME = exports.DTS_EXT = exports.D_EXT = exports.TSX_EXT = exports.TS_EXT = exports.RBXTS_SCOPE = exports.NODE_MODULES = exports.COMPILER_VERSION = exports.INCLUDE_PATH = exports.PACKAGE_ROOT = void 0;
+const path_1 = __importDefault(require("path"));
+exports.PACKAGE_ROOT = path_1.default.join(__dirname, "..", "..");
+exports.INCLUDE_PATH = path_1.default.join(exports.PACKAGE_ROOT, "include");
+exports.COMPILER_VERSION = require("../../package.json").version;
+exports.NODE_MODULES = "node_modules";
+exports.RBXTS_SCOPE = "@rbxts";
+exports.TS_EXT = ".ts";
+exports.TSX_EXT = ".tsx";
+exports.D_EXT = ".d";
+exports.DTS_EXT = exports.D_EXT + exports.TS_EXT;
+exports.INDEX_NAME = "index";
+exports.INIT_NAME = "init";
+exports.SERVER_SUBEXT = ".server";
+exports.CLIENT_SUBEXT = ".client";
+exports.MODULE_SUBEXT = "";
+exports.FILENAME_WARNINGS = new Map();
+for (const scriptType of [exports.SERVER_SUBEXT, exports.CLIENT_SUBEXT, exports.MODULE_SUBEXT]) {
+    for (const fileType of [exports.TS_EXT, exports.TSX_EXT, exports.DTS_EXT]) {
+        exports.FILENAME_WARNINGS.set(exports.INIT_NAME + scriptType + fileType, exports.INDEX_NAME + scriptType + fileType);
+    }
+}
+exports.PARENT_FIELD = "Parent";
+var ProjectType;
+(function (ProjectType) {
+    ProjectType["Game"] = "game";
+    ProjectType["Model"] = "model";
+    ProjectType["Package"] = "package";
+})(ProjectType || (exports.ProjectType = ProjectType = {}));
+exports.DEFAULT_PROJECT_OPTIONS = {
+    includePath: "",
+    rojo: undefined,
+    type: undefined,
+    watch: false,
+    usePolling: false,
+    verbose: false,
+    noInclude: false,
+    logTruthyChanges: false,
+    writeOnlyChanged: false,
+    writeTransformedFiles: false,
+    optimizedLoops: true,
+    allowCommentDirectives: false,
+    luau: true,
+};
+//# sourceMappingURL=constants.js.map