storm-lua-minify 0.1.0 → 0.1.1

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) Mathias Bynens, 2024 Nona Takahara
+Copyright (c) 2024 Nona Takahara, Mathias Bynens
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -3,3 +3,13 @@
 このプログラムは [mathiasbynens/luamin](https://github.com/mathiasbynens/luamin) をベースにした Stormworks: Build and Rescue 向けのLua minifierです。
 
 Stormworks: Build and Rescue 以外の用途にも使用可能です。
+
+# 使い方
+
+```
+npm i storm-lua-minify
+
+npx storm-lua-minify script.lua
+```
+
+- `-m`オプションを付加すると、モジュールの挙動をLuaの実際の挙動に近づけます

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "storm-lua-minify",
   "description": "A Lua minifier also outputs source map",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "dependencies": {
     "commander": "^12.1.0",
     "luamin": "^1.0.4",

package/src/ast2lua.ts

@@ -4,6 +4,7 @@
 /* eslint-disable @typescript-eslint/no-unnecessary-condition */
 import Parser, { Comment } from "luaparse";
 import { SourceNode } from "source-map";
+import { Minifier, MinifierMode } from "./minifier";
 
 export type Chunk = Parser.Chunk & {
   globals?: (Parser.Base<"Identifer"> & {
@@ -100,9 +101,6 @@ const IDENTIFIER_PARTS = [
   "_",
 ];
 
-const identifierMap = new Map<string, string>();
-const identifiersInUse = new Set<string>();
-
 function wrapArray<T>(obj: T | T[]): T[] {
   if (Array.isArray(obj)) {
     return obj;
@@ -262,31 +260,33 @@ function insertSeparator(
   return isNeedSeparator(a.toString(), b.toString()) ? separator : undefined;
 }
 
-export class Minifier {
+export class MinifyFile {
   private fileName: string;
   private ast: Chunk;
-  private requireHelper: (fileName: string) => SourceNode | undefined;
+  private minifier: Minifier;
+  private mode: MinifierMode;
 
   constructor(
     fileName: string,
     ast: Chunk,
-    requireHelper: (fileName: string) => SourceNode | undefined
+    minifier: Minifier,
+    mode: MinifierMode
   ) {
     this.fileName = fileName;
     this.ast = ast;
-    this.requireHelper = requireHelper;
-    ast.globals?.map((v) => identifiersInUse.add(v.name));
+    this.minifier = minifier;
+    this.mode = mode;
   }
 
-  parse() {
+  parse(noComment: boolean) {
     const body = this.formatStatementList(this.ast.body);
-    /*if (this.ast.comments) {
+    if (!noComment && this.ast.comments) {
       const comments = this.ast.comments as Comment[];
       comments.reverse().filter(v => v.raw.includes("--#") || v.raw.includes("[[#")).forEach(comment => {
-        body.prepend(this.sourceNodeHelper(comment, comment.raw));
+        body.prepend([this.sourceNodeHelper(comment, comment.raw), "\n"]);
       })
       return body;
-    } else*/ {
+    } else {
       return body;
     }
   }
@@ -605,15 +605,28 @@ export class Minifier {
       return result;
     } else if (expression.type == "CallExpression") {
       // requireの展開モードは2種類: SLモード-その場に読み込み, FLモード-require相当の関数で呼び出し
+      const callExpr = this.formatBase(expression.base).toString();
       if (
-        this.formatBase(expression.base).toString() == "require" &&
+        (callExpr === "require" || callExpr === "dofile") &&
         expression?.arguments[0].type === "StringLiteral"
       ) {
-        const res = this.requireHelper(
-          expression.arguments[0].raw.replaceAll('"', "")
-        );
-        if (res != undefined) {
-          return res;
+        const moduleName = expression.arguments[0].raw
+          .replaceAll('"', "")
+          .replaceAll("'", "");
+
+        const res = this.minifier.parseModule(moduleName);
+        
+        if (this.mode.moduleLikeLua) {
+          if (callExpr === "dofile") {
+            return (
+              res || this.sourceNodeHelper(undefined, "")
+            );
+          }
+          // requireならスキップ
+        } else {
+          return (
+            res || this.sourceNodeHelper(undefined, "")
+          );
         }
       }
       const args = expression.arguments
@@ -759,7 +772,7 @@ export class Minifier {
       return this.sourceNodeHelper(nameItem, "self", "self");
     }
 
-    const defined = identifierMap.get(nameItem.name);
+    const defined = this.minifier.identifierMap.get(nameItem.name);
     if (defined) {
       return this.sourceNodeHelper(nameItem, defined, nameItem.name); // 第3引数は要調査
     }
@@ -778,20 +791,20 @@ export class Minifier {
           generateZeroes(length - (position + 1));
         if (
           isKeyword(this.currentIdentifier) ||
-          identifiersInUse.has(this.currentIdentifier)
+          this.minifier.identifiersInUse.has(this.currentIdentifier)
         ) {
           return this.generateIdentifier(nameItem, nested);
         }
-        identifierMap.set(nameItem.name, this.currentIdentifier);
+        this.minifier.identifierMap.set(nameItem.name, this.currentIdentifier);
         return this.generateIdentifier(nameItem, nested);
       }
       --position;
     }
     this.currentIdentifier = "a" + generateZeroes(length);
-    if (identifiersInUse.has(this.currentIdentifier)) {
+    if (this.minifier.identifiersInUse.has(this.currentIdentifier)) {
       return this.generateIdentifier(nameItem, nested);
     }
-    identifierMap.set(nameItem.name, this.currentIdentifier);
+    this.minifier.identifierMap.set(nameItem.name, this.currentIdentifier);
     return this.generateIdentifier(nameItem, nested);
 
     //    return this.sourceNodeHelper(nameItem, nameItem.name, nested ? nameItem.name : undefined);

package/src/cli.ts

@@ -3,12 +3,18 @@
 import fs from "fs";
 import path from "path";
 import { Command } from "commander";
-import Parser, { Options } from "luaparse";
-import { Chunk, Minifier } from "./ast2lua";
+import { Options } from "luaparse";
+import { Minifier, MinifierMode } from "./minifier";
 
 const program = new Command();
 
-program.version("0.1.0").description("A Lua minifier also outputs source map");
+program
+  .version("0.1.1")
+  .description("A Lua minifier also outputs source map")
+  .option(
+    "-m, --module-like-lua",
+    "require・dofileの動作を実際のLuaに近づけます"
+  );
 
 program.parse(process.argv);
 
@@ -21,61 +27,29 @@ const luaparseSetting: Partial<Options> = {
   scope: true,
 };
 
+const mode: MinifierMode = program.opts();
+
 luaFiles.forEach((fileName) => {
-  const includes = new Map<string, string>();
   const parsedFileName = path.parse(fileName);
 
-  function requireHelper(recursiveFilePath: string) {
-    const resolvePath = path.relative(
-      parsedFileName.dir,
-      path.join(
-        parsedFileName.dir,
-        recursiveFilePath.replaceAll(".", path.sep) + ".lua"
-      )
-    );
-    const fullResolvePath = path.join(parsedFileName.dir, resolvePath);
-
-    if (!includes.has(resolvePath) && fs.existsSync(fullResolvePath)) {
-      const code = fs.readFileSync(fullResolvePath).toString();
-      const ast = Parser.parse(code, luaparseSetting) as Chunk;
-      if ("globals" in ast) {
-        includes.set(resolvePath, code);
-        return new Minifier(resolvePath, ast, requireHelper).parse();
-      }
-      includes.set(resolvePath, "");
-      return undefined;
-    }
-  }
-
   if (fs.existsSync(fileName)) {
-    const code = fs.readFileSync(fileName).toString();
-    const ast = Parser.parse(code, luaparseSetting) as Chunk;
-    if ("globals" in ast) {
-      includes.set(parsedFileName.base, code);
-      const map = new Minifier(parsedFileName.base, ast, requireHelper).parse();
-
-      includes.forEach((v, k) => {
-        console.log(k);
-        map.setSourceContent(k, v);
-      });
-
-      const minFileName = path.format({
-        dir: parsedFileName.dir,
-        name: parsedFileName.name + ".min",
-        ext: ".lua",
-      });
-      const mapFileName = path.format({
-        dir: parsedFileName.dir,
-        name: parsedFileName.name,
-        ext: parsedFileName.ext + ".map",
-      });
-      map.add("\n--[[\n//# sourceMappingURL=" + mapFileName + "\n]]");
-
-      const sourceAndMap = map.toStringWithSourceMap();
-
-      fs.writeFileSync(minFileName, sourceAndMap.code);
-      fs.writeFileSync(mapFileName, JSON.stringify(sourceAndMap.map));
-    }
+    const map = new Minifier(fileName, luaparseSetting, mode).parse();
+    const minFileName = path.format({
+      dir: parsedFileName.dir,
+      name: parsedFileName.name + ".min",
+      ext: ".lua",
+    });
+    const mapFileName = path.format({
+      dir: parsedFileName.dir,
+      name: parsedFileName.name,
+      ext: parsedFileName.ext + ".map",
+    });
+    map.add("\n--[[\n//# sourceMappingURL=" + mapFileName + "\n]]");
+
+    const sourceAndMap = map.toStringWithSourceMap();
+
+    fs.writeFileSync(minFileName, sourceAndMap.code);
+    fs.writeFileSync(mapFileName, JSON.stringify(sourceAndMap.map));
   } else {
     console.error("No such file: " + fileName);
   }

package/src/minifier.ts

@@ -0,0 +1,114 @@
+import Parser, { Comment, Options } from "luaparse";
+import path from "path";
+import fs from "fs";
+import { SourceNode } from "source-map";
+import { Chunk, MinifyFile } from "./ast2lua";
+
+export interface MinifierMode {
+  moduleLikeLua: boolean;
+}
+
+export class Minifier {
+  readonly identifierMap: Map<string, string>;
+  readonly identifiersInUse: Set<string>;
+  readonly moduleSourceText: Map<string, string>;
+  readonly moduleSourceNode: Map<string, SourceNode>;
+  readonly moduleAST: Map<string, Chunk>;
+  readonly dir: string;
+  readonly entryModule: string;
+  readonly mode: MinifierMode;
+  readonly luaParseSettings: Partial<Options>;
+
+  constructor(
+    entryFilePath: string,
+    luaParseSettings: Partial<Options>,
+    mode: MinifierMode
+  ) {
+    this.identifierMap = new Map<string, string>();
+    this.identifiersInUse = new Set<string>();
+    this.moduleSourceText = new Map<string, string>();
+    this.moduleSourceNode = new Map<string, SourceNode>();
+    this.moduleAST = new Map<string, Chunk>();
+    this.luaParseSettings = luaParseSettings;
+    this.mode = mode;
+    const pn = path.parse(entryFilePath);
+    this.dir = pn.dir;
+    this.entryModule = pn.name;
+  }
+
+  parse() {
+    const sn = this.parseModule(this.entryModule);
+
+    if (this.mode.moduleLikeLua) {
+      // require関数を作成し、流し込む
+      /*
+      function require(m,r)
+        package=package or {loaded={}}
+        if package.loaded[m] then return package.loaded[m] end
+        if m=="<MODULE_NAME>" then r=(function()[[MODULE]]end)() end
+        package.loaded[m]=package.loaded[m] or r or true;return package.loaded[m]
+      end
+      */
+      sn.prepend("package.loaded[m]=package.loaded[m]or r or true;return package.loaded[m]end\n");
+      this.moduleSourceNode.forEach((v, k) => {
+        if (k !== this.entryModule) {
+            sn.prepend(["if m==\"", k, "\"then r=(function() ", v ," end)()end\n"]);
+        }
+      });
+      sn.prepend("function require(m,r)package=package or{loaded={}};if package.loaded[m]then return package.loaded[m]end\n");
+    }
+
+    // コメントの流し込み
+    const comments = this.moduleAST.get(this.entryModule)?.comments as
+      | Comment[]
+      | undefined;
+    if (comments) {
+      comments
+        .reverse()
+        .filter((v) => v.raw.includes("--#") || v.raw.includes("[[#"))
+        .forEach((comment) => {
+          sn.prepend([
+            new SourceNode(
+              comment.loc?.start.line || null,
+              comment.loc?.start.column || null,
+              this.entryModule, // 本当に自分のファイル名でよいかは要検討
+              comment.raw
+            )
+          ,"\n"]);
+        });
+    }
+
+    return sn;
+  }
+
+  parseModule(moduleName: string): SourceNode {
+    const resolvePath = moduleName.replaceAll(".", path.sep) + ".lua";
+    const fullResolvePath = path.join(this.dir, resolvePath);
+
+    if (this.moduleSourceNode.has(moduleName)) {
+      const res = this.moduleSourceNode.get(moduleName);
+      if (res) {
+        return res;
+      }
+    } else if (fs.existsSync(fullResolvePath)) {
+      const code = fs.readFileSync(fullResolvePath).toString();
+      const ast = Parser.parse(code, this.luaParseSettings) as Chunk;
+      if ("globals" in ast) {
+        ast.globals?.map((v) => this.identifiersInUse.add(v.name));
+
+        const sourceNode = new MinifyFile(
+          resolvePath,
+          ast,
+          this,
+          this.mode
+        ).parse(resolvePath === this.entryModule);
+
+        this.moduleSourceText.set(moduleName, code);
+        this.moduleAST.set(moduleName, ast);
+        this.moduleSourceNode.set(moduleName, sourceNode);
+        return sourceNode;
+      }
+    }
+    throw new Error(moduleName + " is not found");
+  }
+}