overpy 9.4.21

package/cli.js

@@ -0,0 +1,207 @@
+#!/usr/bin/env node
+"use strict";
+var import_promises = require("node:fs/promises");
+var import_node_path = require("node:path");
+function loadOverpy() {
+  try {
+    return require("./overpy_standalone");
+  } catch {
+    try {
+      return require("./overpy");
+    } catch {
+      throw new Error("Unable to load OverPy runtime module. Expected './overpy_standalone' or './overpy'.");
+    }
+  }
+}
+function printHelp() {
+  const helpText = `OverPy CLI
+
+Usage:
+  overpy <command> [inputPath] [options]
+
+Commands:
+  compile      Compile OverPy code to Workshop code
+  decompile    Decompile Workshop code to OverPy code
+
+Options:
+  -i, --input <path>           Input file path
+  -o, --output <path>          Output file path
+  -l, --language <lang>        Workshop language (default: en-US)
+  --root <path>                Root path for compile imports
+  --main-file <name>           Main file name for compile
+  --ignore-variable-index      Omit variable indexes in decompile output
+  --ignore-subroutine-index    Omit subroutine indexes in decompile output
+  -h, --help                   Show help
+  -V, --version                Show package version
+
+Examples:
+  overpy compile -i script.opy -o script.txt
+  cat script.opy | overpy compile > script.txt
+  overpy decompile -i workshop.txt -o script.opy
+  cat workshop.txt | overpy decompile --ignore-variable-index > script.opy
+`;
+  process.stdout.write(helpText);
+}
+function getVersion() {
+  const pkg = require("../package.json");
+  return pkg.version;
+}
+function isOption(value) {
+  return value.startsWith("-");
+}
+function consumeValue(args, index, optionName) {
+  const value = args[index + 1];
+  if (!value || isOption(value)) {
+    throw new Error(`Missing value for ${optionName}`);
+  }
+  return value;
+}
+function parseArgs(argv) {
+  const parsed = {
+    command: null,
+    help: false,
+    version: false,
+    language: "en-US",
+    ignoreVariableIndex: false,
+    ignoreSubroutineIndex: false
+  };
+  const args = [...argv];
+  if (args.length === 0) {
+    parsed.help = true;
+    return parsed;
+  }
+  for (const flag of args) {
+    if (flag === "-h" || flag === "--help") {
+      parsed.help = true;
+    }
+    if (flag === "-V" || flag === "--version") {
+      parsed.version = true;
+    }
+  }
+  if (parsed.help || parsed.version) {
+    return parsed;
+  }
+  const command = args.shift();
+  if (command !== "compile" && command !== "decompile") {
+    throw new Error(`Unknown command '${command}'. Expected 'compile' or 'decompile'.`);
+  }
+  parsed.command = command;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "-i" || arg === "--input") {
+      parsed.inputPath = consumeValue(args, i, arg);
+      i++;
+    } else if (arg === "-o" || arg === "--output") {
+      parsed.outputPath = consumeValue(args, i, arg);
+      i++;
+    } else if (arg === "-l" || arg === "--language") {
+      parsed.language = consumeValue(args, i, arg);
+      i++;
+    } else if (arg === "--root") {
+      parsed.rootPath = consumeValue(args, i, arg);
+      i++;
+    } else if (arg === "--main-file") {
+      parsed.mainFileName = consumeValue(args, i, arg);
+      i++;
+    } else if (arg === "--ignore-variable-index") {
+      parsed.ignoreVariableIndex = true;
+    } else if (arg === "--ignore-subroutine-index") {
+      parsed.ignoreSubroutineIndex = true;
+    } else if (!isOption(arg) && !parsed.inputPath) {
+      parsed.inputPath = arg;
+    } else if (!isOption(arg) && parsed.inputPath) {
+      throw new Error(`Unexpected extra positional argument '${arg}'.`);
+    } else {
+      throw new Error(`Unknown option '${arg}'.`);
+    }
+  }
+  return parsed;
+}
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+  }
+  return Buffer.concat(chunks).toString("utf8");
+}
+async function loadInput(inputPath) {
+  if (inputPath) {
+    const absolute = (0, import_node_path.resolve)(inputPath);
+    const content = await (0, import_promises.readFile)(absolute, "utf8");
+    return { content, absolutePath: absolute, fromFile: true };
+  }
+  if (!process.stdin.isTTY) {
+    const content = await readStdin();
+    return { content, absolutePath: "", fromFile: false };
+  }
+  return { content: "", absolutePath: "", fromFile: false };
+}
+function formatError(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}
+function formatWarning(warning) {
+  if (warning && typeof warning === "object" && "message" in warning) {
+    return String(warning.message);
+  }
+  return String(warning);
+}
+async function writeOutput(content, outputPath) {
+  if (outputPath) {
+    await (0, import_promises.writeFile)((0, import_node_path.resolve)(outputPath), content, "utf8");
+    return;
+  }
+  process.stdout.write(content);
+}
+async function run() {
+  const overpy = loadOverpy();
+  const parsed = parseArgs(process.argv.slice(2));
+  if (parsed.version) {
+    process.stdout.write(`${getVersion()}
+`);
+    return 0;
+  }
+  if (parsed.help || !parsed.command) {
+    printHelp();
+    return 0;
+  }
+  const input = await loadInput(parsed.inputPath);
+  if (!input.content) {
+    process.stderr.write("No input provided. Use --input/-i, positional inputPath, or pipe via stdin.\n\n");
+    printHelp();
+    return 2;
+  }
+  await overpy.readyPromise;
+  if (parsed.command === "compile") {
+    const rootPath = parsed.rootPath ?? (input.fromFile ? (0, import_node_path.dirname)(input.absolutePath) : process.cwd());
+    const mainFileName = parsed.mainFileName ?? (input.fromFile ? (0, import_node_path.basename)(input.absolutePath) : "stdin.opy");
+    const result = await overpy.compile(
+      input.content,
+      parsed.language,
+      rootPath,
+      mainFileName
+    );
+    for (const warning of result.encounteredWarnings) {
+      process.stderr.write(`Warning: ${formatWarning(warning)}
+`);
+    }
+    await writeOutput(result.result, parsed.outputPath);
+    return 0;
+  }
+  const decompiled = overpy.decompileAllRules(input.content, parsed.language, {
+    ignoreVariableIndex: parsed.ignoreVariableIndex,
+    ignoreSubroutineIndex: parsed.ignoreSubroutineIndex
+  });
+  await writeOutput(decompiled, parsed.outputPath);
+  return 0;
+}
+run().then((exitCode) => {
+  process.exitCode = exitCode;
+}).catch((error) => {
+  process.stderr.write(`Error: ${formatError(error)}
+`);
+  process.exitCode = 1;
+});
+//# sourceMappingURL=overpy_cli.js.map

package/overpy.d.ts

@@ -0,0 +1,73 @@
+declare namespace overpy {
+    type UnknownRecord = Record<string, unknown>;
+
+    interface CompileResult {
+        result: string;
+        macros: unknown[];
+        astMacros: UnknownRecord;
+        astConstants: UnknownRecord;
+        globalVariables: unknown[];
+        playerVariables: unknown[];
+        subroutines: unknown[];
+        encounteredWarnings: unknown[];
+        hiddenWarnings: string[];
+        enumMembers: UnknownRecord;
+        nbElements: number;
+        activatedExtensions: string[];
+        spentExtensionPoints: number;
+        availableExtensionPoints: number;
+        translationLanguages: string[];
+        translatedStrings: unknown[];
+    }
+
+    function compile(
+        content: string,
+        language?: string,
+        rootPath?: string,
+        mainFileName?: string
+    ): Promise<CompileResult>;
+
+    function decompileAllRules(
+        content: string,
+        language?: string,
+        options?: {
+            ignoreVariableIndex?: boolean;
+            ignoreSubroutineIndex?: boolean;
+        }
+    ): string;
+
+    function decompileActions(content: string): unknown[];
+    function decompileConditions(content: string): unknown[];
+    function astToOpy(content: unknown): string;
+    function resetGlobalVariables(language?: string): void;
+    function typeToString(type: unknown): string;
+    function computeCustomGameSettingsSchema(): unknown;
+
+    const readyPromise: Promise<void>;
+    const actionKw: UnknownRecord;
+    const valueFuncKw: UnknownRecord;
+    const constantValues: UnknownRecord;
+    const annotations: UnknownRecord;
+    const eventKw: UnknownRecord;
+    const eventTeamKw: UnknownRecord;
+    const eventSlotKw: UnknownRecord;
+    const eventPlayerKw: UnknownRecord;
+    const ruleKw: UnknownRecord;
+    const stringKw: UnknownRecord;
+    const heroKw: UnknownRecord;
+    const mapKw: UnknownRecord;
+    const opyFuncs: UnknownRecord;
+    const opyMemberFuncs: UnknownRecord;
+    const opyKeywords: UnknownRecord;
+    const opyConstants: UnknownRecord;
+    const opyModules: UnknownRecord;
+    const opyMacros: UnknownRecord;
+    const currentLanguage: string;
+    const macros: unknown[];
+    const preprocessingDirectives: UnknownRecord;
+    const opyStringEntities: UnknownRecord;
+    const customGameSettingsSchema: UnknownRecord;
+    const overpyTemplate: string;
+}
+
+export = overpy;