s2ts/dist/cli.js

A tool to automatically compile counter-strike TS files (.vts files)

#!/usr/bin/env node
"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.processFileData = exports.s2tsVersion = void 0;
const chokidar_1 = __importDefault(require("chokidar"));
const fs_1 = require("fs");
const path_1 = __importDefault(require("path"));
const version_1 = require("./compiler/version");
const compile_1 = require("./compiler/compile");
const transpile_1 = require("./compiler/transpile");
const rollup_1 = require("./compiler/rollup");
const log_1 = require("./log");
const publicMethods_1 = require("./compiler/publicMethods");
exports.s2tsVersion = "0.5.3";
const sourcePathPart = "/content/csgo_addons";
const targetPathPart = "/game/csgo_addons";
const start = (specifiedPath) => {
    const projectDir = standardisePath(specifiedPath ?? process.cwd());
    const watchDir = standardisePath(path_1.default.join(projectDir, "./scripts"));
    if (!watchDir.includes(sourcePathPart)) {
        log_1.logger.error(`The current path '${watchDir}' was expected to contain '${sourcePathPart}' but it did not. Check if you are running in the correct folder.`);
        return;
    }
    if (!(0, fs_1.existsSync)(watchDir)) {
        (0, fs_1.mkdirSync)(watchDir);
    }
    chokidar_1.default
        .watch(watchDir, { persistent: true })
        .on("add", filePath => processFileAtPath({ project: projectDir, file: filePath }))
        .on("change", filePath => processFileAtPath({ project: projectDir, file: filePath }))
        .on("error", error => log_1.logger.error(`Watcher error: ${error}`));
    log_1.logger.info(`Watching for file changes in ${watchDir}`);
};
const processFileAtPath = async (pathFor) => {
    if (!pathFor.file.endsWith(".vts") && !pathFor.file.endsWith(".ts"))
        return;
    const standardFilePath = standardisePath(pathFor.file);
    try {
        const compiledBuffer = await (0, exports.processFileData)(pathFor.project, {
            name: path_1.default.basename(standardFilePath),
            path: standardFilePath,
            content: (0, fs_1.readFileSync)(standardFilePath).toString("utf-8")
        });
        if (!compiledBuffer)
            return;
        const outputFilePath = standardFilePath.replace(".vts", ".vts_c").replace(".ts", ".vts_c").replace(sourcePathPart, targetPathPart);
        (0, fs_1.mkdirSync)(path_1.default.dirname(outputFilePath), { recursive: true });
        (0, fs_1.writeFileSync)(outputFilePath, new Uint8Array(compiledBuffer));
        log_1.logger.info(`Compiled: ${path_1.default.basename(outputFilePath)}`);
    }
    catch (error) {
        log_1.logger.error(`Unhandled error in s2ts: ${error}`);
    }
};
const processFileData = async (pathForProject, file) => {
    const publicMethodsFromSource = (0, publicMethods_1.extractPublicMethods)(file.content);
    const transpiledResult = (0, transpile_1.transpileFromTypeScript)(file);
    if (!transpiledResult.success)
        return;
    const bundledData = await (0, rollup_1.bundleImports)(pathForProject, { ...file, content: transpiledResult.output });
    const bundledCode = bundledData.code;
    const publicMethodNamesFromSource = publicMethodsFromSource.map(method => method.methodName);
    const publicMethodsFromBundle = [];
    for (const moduleId in bundledData.modules) {
        if (moduleId == file.name || moduleId == file.path)
            continue;
        const standartModulePath = standardisePath(moduleId);
        const moduleContent = (0, fs_1.readFileSync)(standartModulePath).toString("utf-8");
        const modulePublicMethods = (0, publicMethods_1.extractPublicMethods)(moduleContent);
        publicMethodsFromBundle.push(...modulePublicMethods.filter(method => !publicMethodNamesFromSource.includes(method.methodName)));
    }
    const publicMethods = [...publicMethodsFromSource, ...publicMethodsFromBundle];
    const bundledCodeWithVersion = (0, version_1.addS2tsVersion)(bundledCode);
    return (0, compile_1.compileToVtsc)(bundledCodeWithVersion, publicMethods);
};
exports.processFileData = processFileData;
const standardisePath = (fullPath) => fullPath.replace(/[\\/]+/g, "/");
const command = process.argv[2];
const argument = process.argv[3];
switch (command) {
    case "dev":
    case "start":
        start(argument);
        break;
    default:
        console.log(`Unknown command: ${command}. Did you mean 'start'?`);
        break;
}