@artel/artc 0.6.25191

package/build/chunk-BQHCAH6D.js

@@ -0,0 +1,588 @@
+import {
+  Compiler
+} from "./chunk-QRBDQKYM.js";
+import {
+  ArtelVersion,
+  Cached,
+  Debug,
+  Diagnostic,
+  DiagnosticData,
+  DirectoryEntry,
+  PerformanceMeasurement,
+  Query,
+  Uri,
+  __async,
+  performanceMeasurementStageNames,
+  performanceMeasurementStages
+} from "./chunk-O2JKESUU.js";
+
+// source/executor/FileSystemUri.ts
+import { platform } from "os";
+import { normalize, sep } from "path";
+var FileSystemUri = class {
+  static pathToUri(path) {
+    path = normalize(path);
+    if (path.startsWith(sep)) {
+      path = path.substring(sep.length);
+    }
+    if (path.endsWith(sep)) {
+      path = path.substring(0, path.length - sep.length);
+    }
+    return new Uri("file", path.split(sep));
+  }
+  static toPath(uri) {
+    if (platform() === "win32") {
+      return uri.segments.join(sep);
+    }
+    return `${sep}${uri.segments.join(sep)}`;
+  }
+};
+
+// source/executor/PhysicalFileSystem.ts
+import { existsSync } from "fs";
+import { lstat, mkdir, readFile, readdir, rm, writeFile } from "fs/promises";
+import { dirname, join } from "path";
+var PhysicalFileSystem = class {
+  readDirectory(uri) {
+    return __async(this, null, function* () {
+      const path = FileSystemUri.toPath(uri);
+      let names;
+      try {
+        names = yield readdir(path);
+      } catch {
+        names = [];
+      }
+      const readEntriesPromises = names.map((name) => __async(this, null, function* () {
+        const childPath = join(path, name);
+        const stats = yield this.tryLstat(childPath);
+        if (stats !== void 0 && (stats.isDirectory() || stats.isFile())) {
+          return new DirectoryEntry(FileSystemUri.pathToUri(childPath), stats.isFile());
+        } else {
+          return void 0;
+        }
+      }));
+      const result = Query.from(yield Promise.all(readEntriesPromises)).mapAndFilter((e) => e).toArray();
+      return result;
+    });
+  }
+  readFile(uri) {
+    return __async(this, null, function* () {
+      const path = FileSystemUri.toPath(uri);
+      let text;
+      try {
+        text = yield readFile(path, "utf8");
+      } catch {
+      }
+      return text;
+    });
+  }
+  readEntry(uri) {
+    return __async(this, null, function* () {
+      const path = FileSystemUri.toPath(uri);
+      const stats = yield this.tryLstat(path);
+      let result;
+      if (stats !== void 0 && (stats.isFile() || stats.isDirectory())) {
+        result = new DirectoryEntry(uri, stats.isFile());
+      }
+      return result;
+    });
+  }
+  clearDirectory(uri) {
+    return __async(this, null, function* () {
+      const path = FileSystemUri.toPath(uri);
+      yield rm(path, { recursive: true, force: true });
+    });
+  }
+  writeFile(uri, content) {
+    return __async(this, null, function* () {
+      const path = FileSystemUri.toPath(uri);
+      const directoryPath = dirname(path);
+      if (!existsSync(directoryPath)) {
+        yield mkdir(directoryPath, { recursive: true });
+      }
+      yield writeFile(path, content, "utf8");
+    });
+  }
+  tryLstat(path) {
+    return __async(this, null, function* () {
+      try {
+        return yield lstat(path);
+      } catch {
+        return void 0;
+      }
+    });
+  }
+};
+
+// source/executor/PhysicalTypeScriptLibrariesProvider.ts
+import { lstatSync, readFileSync } from "fs";
+import { platform as platform2 } from "os";
+var PhysicalTypeScriptLibrariesProvider = class {
+  constructor(standardLibraryUri) {
+    this._isCaseSensitive = new Cached();
+    this._standardLibraryUri = standardLibraryUri;
+  }
+  getStandardLibraryUri() {
+    return this._standardLibraryUri;
+  }
+  readFileSync(uri) {
+    const path = FileSystemUri.toPath(uri);
+    let text;
+    try {
+      text = readFileSync(path, "utf8");
+    } catch {
+    }
+    return text;
+  }
+  fileExistsSync(uri) {
+    const path = FileSystemUri.toPath(uri);
+    let stats;
+    try {
+      stats = lstatSync(path);
+    } catch {
+    }
+    const result = stats?.isFile() === true;
+    return result;
+  }
+  directoryExistsSync(uri) {
+    const path = FileSystemUri.toPath(uri);
+    let stats;
+    try {
+      stats = lstatSync(path);
+    } catch {
+    }
+    const result = stats?.isDirectory() === true;
+    return result;
+  }
+  isCaseSensitive() {
+    return this._isCaseSensitive.getOrInsertWith(() => {
+      const platformName = platform2();
+      if (platformName === "win32") {
+        return false;
+      }
+      return true;
+    });
+  }
+};
+
+// source/executor/NodeCompiler.ts
+import { relative } from "path";
+import process2 from "process";
+
+// source/diagnostic/DiagnosticFormatter.ts
+var DiagnosticFormatter = class {
+  static format(diagnostic, options) {
+    let result;
+    if (diagnostic.location !== void 0) {
+      const sourceFile = diagnostic.location.file;
+      const uri = options?.convertUri?.(sourceFile.uri) ?? sourceFile.uri.toString();
+      const position = sourceFile.getPositionAt(diagnostic.location.range.start);
+      result = `${uri}:${position.line + 1}:${position.character + 1} - ${diagnostic.data.message}`;
+    } else {
+      result = diagnostic.data.message;
+    }
+    return result;
+  }
+};
+
+// source/executor/NodeCompiler.ts
+var NodeCompiler = class {
+  static get fileSystem() {
+    return this._fileSystem ??= new PhysicalFileSystem();
+  }
+  static findStandardTypeScriptLibrary(nodeModulesSearchPaths, defaultTsLibraryPath) {
+    return __async(this, null, function* () {
+      const nodeModulesSearchUris = nodeModulesSearchPaths.map((p) => FileSystemUri.pathToUri(p));
+      for (const baseUri of nodeModulesSearchUris) {
+        let currentUri = baseUri;
+        const relativeSegments = ["node_modules", "typescript", "lib"];
+        while (currentUri !== void 0) {
+          const libDirectoryUri = currentUri.append(relativeSegments);
+          if ((yield this.fileSystem.readEntry(libDirectoryUri))?.isFile === false) {
+            return libDirectoryUri;
+          }
+          currentUri = currentUri.parentUri();
+        }
+      }
+      if (defaultTsLibraryPath !== void 0) {
+        return FileSystemUri.pathToUri(defaultTsLibraryPath);
+      }
+      return void 0;
+    });
+  }
+  static createTypeScriptLibrariesProvider(nodeModulesSearchPaths, defaultTsLibraryPath, diagnostics) {
+    return __async(this, null, function* () {
+      const standardLibraryUri = yield this.findStandardTypeScriptLibrary(nodeModulesSearchPaths, defaultTsLibraryPath);
+      if (standardLibraryUri === void 0) {
+        const diagnostic = new Diagnostic(DiagnosticData.withCode(
+          137 /* CanNotFindTsLibDirectoryBaseSearchPaths0 */,
+          [nodeModulesSearchPaths.map((p) => `'${p}'`).join(", ")]
+        ), void 0);
+        diagnostics?.addDiagnostic(diagnostic);
+        return void 0;
+      }
+      return new PhysicalTypeScriptLibrariesProvider(standardLibraryUri);
+    });
+  }
+  static loadCompilation(projectPath, tsLibrariesProvider, diagnostics, workspacePath, standardPackagesPath, cancellationToken) {
+    return __async(this, null, function* () {
+      const projectUri = FileSystemUri.pathToUri(projectPath);
+      const workspaceUri = workspacePath !== void 0 ? FileSystemUri.pathToUri(workspacePath) : void 0;
+      const standardPackagesUri = standardPackagesPath !== void 0 ? FileSystemUri.pathToUri(standardPackagesPath) : void 0;
+      return yield Compiler.loadCompilation(
+        projectUri,
+        this.fileSystem,
+        tsLibrariesProvider,
+        diagnostics,
+        workspaceUri,
+        standardPackagesUri,
+        cancellationToken
+      );
+    });
+  }
+  static createAnalyzer(compilation, tsLibrariesProvider, diagnostics, cancellationToken) {
+    return __async(this, null, function* () {
+      return yield Compiler.createAnalyzer(compilation, tsLibrariesProvider, diagnostics, cancellationToken);
+    });
+  }
+  static analyze(analyzer, diagnostics, cancellationToken) {
+    return __async(this, null, function* () {
+      return yield Compiler.analyze(analyzer, diagnostics, cancellationToken);
+    });
+  }
+  static emit(analyzer, outputPath, diagnostics, emitOptions, cancellationToken) {
+    return __async(this, null, function* () {
+      const outputUri = FileSystemUri.pathToUri(outputPath);
+      const launchUri = yield Compiler.emit(
+        analyzer,
+        outputUri,
+        this.fileSystem,
+        diagnostics,
+        emitOptions,
+        cancellationToken
+      );
+      if (launchUri === void 0) {
+        return void 0;
+      }
+      const launchPath = FileSystemUri.toPath(launchUri);
+      return launchPath;
+    });
+  }
+  static compile(task) {
+    return __async(this, null, function* () {
+      const typeScriptLibrariesProvider = yield this.createTypeScriptLibrariesProvider(
+        task.nodeModulesWithTypeScriptSearchPaths,
+        task.defaultTsLibraryPath,
+        task.diagnostics
+      );
+      if (typeScriptLibrariesProvider === void 0) {
+        return void 0;
+      }
+      const compilation = yield this.loadCompilation(
+        task.projectPath,
+        typeScriptLibrariesProvider,
+        task.diagnostics,
+        task.workspacePath,
+        task.standardPackagesPath,
+        task.cancellationToken
+      );
+      if (compilation === void 0) {
+        return void 0;
+      }
+      const analyzer = yield this.createAnalyzer(
+        compilation,
+        typeScriptLibrariesProvider,
+        task.diagnostics,
+        task.cancellationToken
+      );
+      if (analyzer === void 0) {
+        return void 0;
+      }
+      const analyzed = yield this.analyze(analyzer, task.diagnostics, task.cancellationToken);
+      if (!analyzed) {
+        return void 0;
+      }
+      const launchPath = yield this.emit(
+        analyzer,
+        task.outputPath,
+        task.diagnostics,
+        task.emitOptions,
+        task.cancellationToken
+      );
+      return launchPath;
+    });
+  }
+};
+var PrintingDiagnosticAcceptor = class {
+  constructor(basePath) {
+    this._formatter = new NodeDiagnosticFormatter(basePath);
+  }
+  addDiagnostic(diagnostic) {
+    if (diagnostic.data.kind === 0 /* Error */ || diagnostic.data.kind === 1 /* Warning */) {
+      const diagnosticText = this._formatter.format(diagnostic);
+      console.log(diagnosticText);
+    }
+  }
+};
+var NodeDiagnosticFormatter = class {
+  constructor(basePath) {
+    basePath ??= process2.cwd();
+    this._formatDiagnosticOptions = {
+      convertUri(uri) {
+        if (uri.scheme === "file") {
+          const path = FileSystemUri.toPath(uri);
+          const relativePath = relative(basePath, path);
+          return relativePath;
+        } else {
+          return uri.toString();
+        }
+      }
+    };
+  }
+  format(diagnostic) {
+    return DiagnosticFormatter.format(diagnostic, this._formatDiagnosticOptions);
+  }
+};
+
+// source/executor/CommandLineCompiler.ts
+import { spawn } from "child_process";
+import { resolve } from "path";
+import { fileURLToPath, pathToFileURL } from "url";
+var CommandLineCompiler = class {
+  static {
+    this.successExitCode = 0;
+  }
+  static {
+    this.errorExitCode = 1;
+  }
+  static run(args) {
+    return __async(this, null, function* () {
+      const parsedArguments = ArgumentsParser.parseArguments(args);
+      if (parsedArguments.command === void 0) {
+        this.displayUsageMessage(parsedArguments);
+        return this.errorExitCode;
+      }
+      if (parsedArguments.command === 5 /* Help */) {
+        this.displayUsageMessage(parsedArguments);
+        return this.errorExitCode;
+      }
+      if (parsedArguments.command === 4 /* Version */) {
+        console.log(ArtelVersion);
+        return this.successExitCode;
+      }
+      if (parsedArguments.projectPath === void 0 || parsedArguments.outputPath === void 0) {
+        this.displayUsageMessage(parsedArguments);
+        return this.successExitCode;
+      }
+      if (parsedArguments.measurePerformance) {
+        PerformanceMeasurement.isEnabled = true;
+      }
+      try {
+        const diagnostics = new PrintingDiagnosticAcceptor();
+        const compilerTask = {
+          nodeModulesWithTypeScriptSearchPaths: [
+            parsedArguments.projectPath,
+            fileURLToPath(new URL("..", import.meta.url))
+          ],
+          projectPath: parsedArguments.projectPath,
+          outputPath: parsedArguments.outputPath,
+          workspacePath: parsedArguments.workspacePath,
+          standardPackagesPath: parsedArguments.standardPackagesPath,
+          diagnostics,
+          defaultTsLibraryPath: parsedArguments.defaultTsLibraryPath,
+          emitOptions: {
+            sourceMap: {
+              mode: "linked" /* Linked */,
+              includeSourcesContent: true,
+              justApplicationCode: false
+            }
+          }
+        };
+        const launchPath = yield NodeCompiler.compile(compilerTask);
+        if (launchPath === void 0) {
+          return this.errorExitCode;
+        }
+        if (parsedArguments.command === 3 /* Launch */) {
+          const launchUrl = pathToFileURL(launchPath).toString();
+          yield import(launchUrl);
+        } else if (parsedArguments.command === 2 /* Execute */) {
+          yield this.execute(launchPath, parsedArguments.outputPath);
+        }
+      } catch (e) {
+        console.log(`\u041E\u0448\u0438\u0431\u043A\u0430.
+${e}
+${e.stack}`);
+        return this.errorExitCode;
+      }
+      if (parsedArguments.measurePerformance) {
+        this.displayPerformanceMeasurementResults();
+      }
+      return this.successExitCode;
+    });
+  }
+  static displayUsageMessage(args) {
+    console.log(`
+\u0410\u0440\u0442\u0435\u043B\u044C*Artel ${ArtelVersion} @ ${args.projectPath ?? process.cwd()}
+`);
+    console.log("\n\u0418\u0441\u043F\u043E\u043B\u044C\u0437\u043E\u0432\u0430\u043D\u0438\u0435:");
+    console.log("\u0430\u0440\u0442\u0435\u043B\u044C \u0437\u0430\u043F\u0443\u0441\u043A <\u043F\u0430\u043F\u043A\u0430 \u043F\u0440\u043E\u0433\u0440\u0430\u043C\u043C\u044B> <\u0441\u0431\u043E\u0440\u043E\u0447\u043D\u0430\u044F \u043F\u0430\u043F\u043A\u0430>");
+    console.log("\u0430\u0440\u0442\u0435\u043B\u044C \u0441\u043E\u0431\u0440\u0430\u0442\u044C <\u043F\u0430\u043F\u043A\u0430 \u043F\u0440\u043E\u0433\u0440\u0430\u043C\u043C\u044B> <\u0441\u0431\u043E\u0440\u043E\u0447\u043D\u0430\u044F \u043F\u0430\u043F\u043A\u0430>");
+    console.log("\u0430\u0440\u0442\u0435\u043B\u044C \u043D\u0430\u0441\u0442\u0440\u043E\u0438\u0442\u044C");
+    console.log("\nUsage:");
+    console.log("artel launch <program folder> <build folder>");
+    console.log("artel build <program folder> <build folder>");
+    console.log("artel setup");
+  }
+  static displayPerformanceMeasurementResults() {
+    for (const stage of performanceMeasurementStages) {
+      const duration = PerformanceMeasurement.getDurationMs(stage);
+      console.log(`${performanceMeasurementStageNames[stage]}: ${duration.toFixed(2)}ms`);
+    }
+  }
+  static execute(launchPath, cwdPath) {
+    return __async(this, null, function* () {
+      return new Promise((resolve2, reject) => {
+        const program = spawn(`"${process.execPath}"`, [launchPath], {
+          stdio: [process.stdin, process.stdout, process.stderr],
+          cwd: cwdPath,
+          shell: true,
+          env: process.env
+        });
+        program.once("exit", (code) => resolve2(code ?? 0));
+        program.once("error", reject);
+      });
+    });
+  }
+};
+var ArgumentsParser = class {
+  static parseArguments(args) {
+    const result = {
+      command: void 0,
+      projectPath: void 0,
+      outputPath: void 0,
+      measurePerformance: false,
+      defaultTsLibraryPath: void 0,
+      workspacePath: void 0,
+      standardPackagesPath: void 0
+    };
+    const index = this.parseMainCommand(0, args, result);
+    this.parseNamedArguments(index, args, result);
+    return result;
+  }
+  static parseMainCommand(index, args, result) {
+    if (index < args.length && !args[index].startsWith("-")) {
+      result.command = this.getCommandKind(args[index]);
+      index++;
+      if (result.command !== void 0) {
+        switch (result.command) {
+          case 0 /* Setup */:
+          case 1 /* Build */:
+          case 2 /* Execute */:
+          case 3 /* Launch */: {
+            const cwd = process.cwd();
+            const projectPath = this.tryParseStringArgument(index, args);
+            if (projectPath !== void 0) {
+              result.projectPath = resolve(cwd, projectPath);
+              index++;
+              const outputPath = this.tryParseStringArgument(index, args);
+              if (outputPath !== void 0) {
+                result.outputPath = resolve(cwd, outputPath);
+                index++;
+              }
+            }
+            break;
+          }
+          case 4 /* Version */:
+          case 5 /* Help */:
+            break;
+          default:
+            Debug.never(result.command);
+        }
+      }
+    }
+    return index;
+  }
+  static getCommandKind(name) {
+    switch (name) {
+      case "\u043D\u0430\u0441\u0442\u0440\u043E\u0438\u0442\u044C":
+      case "setup":
+        return 0 /* Setup */;
+      case "\u0441\u043E\u0431\u0440\u0430\u0442\u044C":
+      case "build":
+        return 1 /* Build */;
+      case "\u0432\u044B\u043F\u043E\u043B\u043D\u0438\u0442\u044C":
+      case "execute":
+        return 2 /* Execute */;
+      case "\u0437\u0430\u043F\u0443\u0441\u043A":
+      case "launch":
+        return 3 /* Launch */;
+      case "\u0432\u0435\u0440\u0441\u0438\u044F":
+      case "version":
+        return 4 /* Version */;
+      case "\u0441\u043F\u0440\u0430\u0432\u043A\u0430":
+      case "help":
+        return 5 /* Help */;
+      default:
+        return void 0;
+    }
+  }
+  static parseNamedArguments(index, args, result) {
+    const cwd = process.cwd();
+    for (; index < args.length; index++) {
+      const argumentName = args[index];
+      if (!argumentName.startsWith("-")) {
+        continue;
+      }
+      switch (argumentName) {
+        case "--\u0441\u0442\u0430\u043D\u0434\u0430\u0440\u0442\u043D\u0430\u044F-\u0431\u0438\u0431\u043B\u0438\u043E\u0442\u0435\u043A\u0430-type-script":
+        case "--standard-type-script-library": {
+          const path = this.tryParseStringArgument(index + 1, args);
+          if (path !== void 0) {
+            result.defaultTsLibraryPath = resolve(cwd, path);
+            index++;
+          }
+          break;
+        }
+        case "--\u0437\u0430\u043C\u0435\u0440\u0438\u0442\u044C-\u043F\u0440\u043E\u0438\u0437\u0432\u043E\u0434\u0438\u0442\u0435\u043B\u044C\u043D\u043E\u0441\u0442\u044C":
+        case "--measure-performance": {
+          result.measurePerformance = true;
+          break;
+        }
+        case "--workspace":
+        case "--\u0440\u0430\u0431\u043E\u0447\u0430\u044F-\u043E\u0431\u043B\u0430\u0441\u0442\u044C": {
+          const path = this.tryParseStringArgument(index + 1, args);
+          if (path !== void 0) {
+            result.workspacePath = resolve(cwd, path);
+            index++;
+          }
+          break;
+        }
+        case "--standard-packages":
+        case "--\u0441\u0442\u0430\u043D\u0434\u0430\u0440\u0442\u043D\u044B\u0435-\u043F\u0430\u043A\u0435\u0442\u044B": {
+          const path = this.tryParseStringArgument(index + 1, args);
+          if (path !== void 0) {
+            result.standardPackagesPath = resolve(cwd, path);
+            index++;
+          }
+          break;
+        }
+      }
+    }
+  }
+  static tryParseStringArgument(index, args) {
+    if (index < args.length && !args[index].startsWith("-")) {
+      return args[index];
+    }
+    return void 0;
+  }
+};
+
+export {
+  FileSystemUri,
+  PhysicalFileSystem,
+  PhysicalTypeScriptLibrariesProvider,
+  NodeCompiler,
+  PrintingDiagnosticAcceptor,
+  NodeDiagnosticFormatter,
+  CommandLineCompiler
+};