@irrelon/battlescript 3.1.5 → 3.1.6

package/bin/functionality.ts

@@ -9,15 +9,24 @@ import {
 	fromSourceCodeToMiniAst,
 	miniAstFromBinaryBuffer
 } from "@/services";
+import type {SourceResolverAsync, SourceResolverSync} from "@/types";
 import type {ByteCodeJson} from "@/types/byteCode/ByteCodeJson";
 import {version} from "../package.json";
 import {readFileSync} from "fs";
 import {writeFileSync} from "node:fs";
 
+const sourceResolverAsync: SourceResolverAsync = (filePath: string) => {
+	return readFile(filePath, "utf-8")
+};
+
+const sourceResolverSync: SourceResolverSync = (filePath: string): string => {
+	return readFileSync(filePath, "utf-8")
+};
+
 export async function toAst(inputPath: string, outputPath?: string) {
 	console.log(`[BattleScript ${version}] toAst: ${inputPath}`);
 	try {
-		const sourceCode = await readFile(inputPath, "utf-8");
+		const sourceCode = await sourceResolverAsync(inputPath);
 		const ast = fromSourceCodeToFullAst(sourceCode, {filePath: inputPath, includeMetaData: true});
 
 		if (outputPath) {
@@ -35,8 +44,12 @@ export async function toAst(inputPath: string, outputPath?: string) {
 export function toAstSync(inputPath: string, outputPath?: string) {
 	console.log(`[BattleScript ${version}] toAstSync: ${inputPath}`);
 	try {
-		const sourceCode = readFileSync(inputPath, "utf-8");
-		const ast = fromSourceCodeToFullAst(sourceCode, {filePath: inputPath, includeMetaData: true});
+		const sourceCode = sourceResolverSync(inputPath);
+		const ast = fromSourceCodeToFullAst(sourceCode, {
+			filePath: inputPath,
+			includeMetaData: true,
+			sourceResolver: sourceResolverSync
+		});
 
 		if (outputPath) {
 			writeFileSync(outputPath, JSON.stringify(ast, null, 2));
@@ -53,7 +66,7 @@ export function toAstSync(inputPath: string, outputPath?: string) {
 export async function fromAst(inputPath: string, outputPath: string) {
 	console.log(`[BattleScript ${version}] fromAst: ${inputPath}`);
 	try {
-		const astString = await readFile(inputPath, "utf-8");
+		const astString = await sourceResolverAsync(inputPath);
 		const ast = JSON.parse(astString);
 		const code = fromFullAstToSourceCode(ast);
 		await writeFile(outputPath, code);
@@ -67,7 +80,7 @@ export async function fromAst(inputPath: string, outputPath: string) {
 export async function toMiniAst(inputPath: string, outputPath: string) {
 	console.log(`[BattleScript ${version}] toMiniAst: ${inputPath}`);
 	try {
-		const sourceCode = await readFile(inputPath, "utf-8");
+		const sourceCode = await sourceResolverAsync(inputPath);
 		const ast = fromSourceCodeToMiniAst(sourceCode, {filePath: inputPath, includeMetaData: true});
 
 		await writeFile(outputPath, JSON.stringify(ast));
@@ -82,7 +95,7 @@ export async function toBinary(inputPath: string, outputPath: string) {
 	console.log(`[BattleScript ${version}] toBinary: ${inputPath}`);
 	try {
 		console.log(`[BattleScript ${version}] Reading file contents: ${inputPath}`);
-		const sourceCode = await readFile(inputPath, "utf-8");
+		const sourceCode = await sourceResolverAsync(inputPath);
 
 		console.log(`[BattleScript ${version}] fromSourceCodeToBinary: ${inputPath}`);
 		const binary = fromSourceCodeToBinary(sourceCode, {includeMetaData: true, flatten: true, filePath: inputPath});
@@ -99,7 +112,7 @@ export async function toBinary(inputPath: string, outputPath: string) {
 
 export async function miniAstToBinary(inputPath: string, outputPath: string) {
 	try {
-		const sourceCode = await readFile(inputPath, "utf-8");
+		const sourceCode = await sourceResolverAsync(inputPath);
 		const binary = fromMiniAstToBinary(JSON.parse(sourceCode), {
 			includeMetaData: true,
 			flatten: true,
@@ -128,7 +141,7 @@ export async function fromBinary(inputPath: string, outputPath: string) {
 
 // async function toByteCode(inputPath: string, outputPath: string) {
 // 	try {
-// 		const sourceCode = await readFile(inputPath, "utf-8");
+// 		const sourceCode = await sourceResolverAsync(inputPath);
 // 		const bcodeJson = fromSourceCodeToByteCode(sourceCode, {includeMetaData: true, flatten: true});
 // 		await writeFile(outputPath, JSON.stringify(bcodeJson).replace(/\[\[/g, "[\n[").replace(/]]/g, "]\n]").replace(/],/g, "],\n"));
 // 		console.log(`Compiled to ${outputPath}`);
@@ -140,7 +153,7 @@ export async function fromBinary(inputPath: string, outputPath: string) {
 
 export async function fromByteCode(inputPath: string, outputPath: string) {
 	try {
-		const byteCodeJsonString = await readFile(inputPath, "utf-8");
+		const byteCodeJsonString = await sourceResolverAsync(inputPath);
 		const byteCodeJson: ByteCodeJson = JSON.parse(byteCodeJsonString);
 		const code = disassembleBytecode(byteCodeJson);
 		await writeFile(outputPath, code.join("\n"));

package/bin/index.js

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
-import { readFile, writeFile } from 'fs/promises';
+import { writeFile, readFile } from 'fs/promises';
 import { join, dirname, basename, extname } from 'path';
 import require$$0 from 'assert';
 import require$$0$1 from 'util';
-import { readFileSync } from 'fs';
-import { writeFileSync } from 'node:fs';
+import 'fs';
+import 'node:fs';
 
 var ATNDeserializer = {};
 
@@ -27902,7 +27902,7 @@ function getAllNativeLibraryFunctions(rootNode) {
     ];
 }
 
-var version = "3.1.5";
+var version = "3.1.6";
 var binaryVersion = 7;
 
 const RootNodeLayout = [{
@@ -27942,7 +27942,12 @@ const rootToAstNode = (instance, ctx) => {
         // Check we can locate the file
         console.log(`[BattleScript ${version}] Processing import compilation unit: `, importNode.source.value);
         const filePath = join(dirname(instance._filePath), importNode.source.value);
-        const importedAst = toAstSync(filePath);
+        const importedSourceCode = instance.resolveSourceCode(filePath);
+        const importedAst = fromSourceCodeToFullAst(importedSourceCode, {
+            filePath,
+            includeMetaData: true,
+            sourceResolver: instance._sourceResolver
+        });
         return importedAst.body;
     }).concat(standardLibraryDeclarations).filter((astNode) => {
         // TODO: We should move this to just before we complete the AST generation
@@ -28187,7 +28192,7 @@ function getMetaData(ctx, extra) {
     };
 }
 class BattleScriptToAST extends AbstractParseTreeVisitorExports.AbstractParseTreeVisitor {
-    constructor(filePath, sourceCode) {
+    constructor(filePath, sourceCode, sourceResolver) {
         super();
         this._options = {
             includeMetaData: true
@@ -28205,6 +28210,16 @@ class BattleScriptToAST extends AbstractParseTreeVisitorExports.AbstractParseTre
                 return;
             this._sourceCode = newSourceCode;
         };
+        this.resolveSourceCode = (filePath) => {
+            if (this._sourceResolver) {
+                const resolved = this._sourceResolver(filePath);
+                if (resolved !== undefined) {
+                    return resolved;
+                }
+                throw new Error(`Source resolver could not resolve source code for file: ${filePath}`);
+            }
+            throw new Error(`Could not resolve source code for file: ${filePath}. No source resolver provided.`);
+        };
         this.extractInlineComment = (ctx) => {
             if (!ctx)
                 return;
@@ -28434,6 +28449,7 @@ class BattleScriptToAST extends AbstractParseTreeVisitorExports.AbstractParseTre
         };
         this._filePath = filePath;
         this._sourceCode = sourceCode;
+        this._sourceResolver = sourceResolver;
     }
     visit(node, options) {
         if (options) {
@@ -38796,7 +38812,7 @@ function fromSourceCodeToFullAst(inputText, options) {
     const parser = getParser(inputText);
     const tree = parser.root();
     console.log(`[BattleScript ${version}] Transforming source code -> AST...`);
-    const transformer = new BattleScriptToAST(options?.filePath || "-", inputText);
+    const transformer = new BattleScriptToAST(options?.filePath || "-", inputText, options?.sourceResolver);
     transformer.filePath(options?.filePath);
     transformer.sourceCode(inputText);
     return transformer.visit(tree, options);
@@ -38913,10 +38929,13 @@ function disassembleBytecode([stringTable, bytecode]) {
     return output;
 }
 
+const sourceResolverAsync = (filePath) => {
+    return readFile(filePath, "utf-8");
+};
 async function toAst(inputPath, outputPath) {
     console.log(`[BattleScript ${version}] toAst: ${inputPath}`);
     try {
-        const sourceCode = await readFile(inputPath, "utf-8");
+        const sourceCode = await sourceResolverAsync(inputPath);
         const ast = fromSourceCodeToFullAst(sourceCode, { filePath: inputPath, includeMetaData: true });
         if (outputPath) {
             await writeFile(outputPath, JSON.stringify(ast, null, 2));
@@ -38931,25 +38950,10 @@ async function toAst(inputPath, outputPath) {
         process.exit(1);
     }
 }
-function toAstSync(inputPath, outputPath) {
-    console.log(`[BattleScript ${version}] toAstSync: ${inputPath}`);
-    try {
-        const sourceCode = readFileSync(inputPath, "utf-8");
-        const ast = fromSourceCodeToFullAst(sourceCode, { filePath: inputPath, includeMetaData: true });
-        if (outputPath) ;
-        else {
-            return ast;
-        }
-    }
-    catch (error) {
-        console.error(`[BattleScript ${version}] Error:`, error.stack);
-        process.exit(1);
-    }
-}
 async function fromAst(inputPath, outputPath) {
     console.log(`[BattleScript ${version}] fromAst: ${inputPath}`);
     try {
-        const astString = await readFile(inputPath, "utf-8");
+        const astString = await sourceResolverAsync(inputPath);
         const ast = JSON.parse(astString);
         const code = fromFullAstToSourceCode(ast);
         await writeFile(outputPath, code);
@@ -38963,7 +38967,7 @@ async function fromAst(inputPath, outputPath) {
 async function toMiniAst(inputPath, outputPath) {
     console.log(`[BattleScript ${version}] toMiniAst: ${inputPath}`);
     try {
-        const sourceCode = await readFile(inputPath, "utf-8");
+        const sourceCode = await sourceResolverAsync(inputPath);
         const ast = fromSourceCodeToMiniAst(sourceCode, { filePath: inputPath, includeMetaData: true });
         await writeFile(outputPath, JSON.stringify(ast));
         console.log(`[BattleScript ${version}] Compiled to ${outputPath}`);
@@ -38977,7 +38981,7 @@ async function toBinary(inputPath, outputPath) {
     console.log(`[BattleScript ${version}] toBinary: ${inputPath}`);
     try {
         console.log(`[BattleScript ${version}] Reading file contents: ${inputPath}`);
-        const sourceCode = await readFile(inputPath, "utf-8");
+        const sourceCode = await sourceResolverAsync(inputPath);
         console.log(`[BattleScript ${version}] fromSourceCodeToBinary: ${inputPath}`);
         const binary = fromSourceCodeToBinary(sourceCode, { includeMetaData: true, flatten: true, filePath: inputPath });
         console.log(`[BattleScript ${version}] Writing file contents: ${outputPath}`);
@@ -38991,7 +38995,7 @@ async function toBinary(inputPath, outputPath) {
 }
 async function miniAstToBinary(inputPath, outputPath) {
     try {
-        const sourceCode = await readFile(inputPath, "utf-8");
+        const sourceCode = await sourceResolverAsync(inputPath);
         const binary = fromMiniAstToBinary(JSON.parse(sourceCode), {
             includeMetaData: true,
             flatten: true,
@@ -39019,7 +39023,7 @@ async function fromBinary(inputPath, outputPath) {
 }
 // async function toByteCode(inputPath: string, outputPath: string) {
 // 	try {
-// 		const sourceCode = await readFile(inputPath, "utf-8");
+// 		const sourceCode = await sourceResolverAsync(inputPath);
 // 		const bcodeJson = fromSourceCodeToByteCode(sourceCode, {includeMetaData: true, flatten: true});
 // 		await writeFile(outputPath, JSON.stringify(bcodeJson).replace(/\[\[/g, "[\n[").replace(/]]/g, "]\n]").replace(/],/g, "],\n"));
 // 		console.log(`Compiled to ${outputPath}`);
@@ -39030,7 +39034,7 @@ async function fromBinary(inputPath, outputPath) {
 // }
 async function fromByteCode(inputPath, outputPath) {
     try {
-        const byteCodeJsonString = await readFile(inputPath, "utf-8");
+        const byteCodeJsonString = await sourceResolverAsync(inputPath);
         const byteCodeJson = JSON.parse(byteCodeJsonString);
         const code = disassembleBytecode(byteCodeJson);
         await writeFile(outputPath, code.join("\n"));