@rpgjs/vite 5.0.0-alpha.9 → 5.0.0-beta.10

package/src/compatibility-v4/load-config-file.ts

@@ -0,0 +1,38 @@
+import fs from "fs";
+import path from "path";
+import { loadEnv } from "vite";
+import toml from "@iarna/toml";
+import { Config, replaceEnvVars } from "./utils";
+
+export function loadConfigFileSync(mode = "development", root = process.cwd()): Config {
+  const tomlFile = path.resolve(root, "rpg.toml");
+  const jsonFile = path.resolve(root, "rpg.json");
+  let config: any = {};
+
+  if (fs.existsSync(tomlFile)) {
+    config = toml.parse(fs.readFileSync(tomlFile, "utf8"));
+  } else if (fs.existsSync(jsonFile)) {
+    config = JSON.parse(fs.readFileSync(jsonFile, "utf8"));
+  }
+
+  config = replaceEnvVars(config, loadEnv(mode, root, ""));
+  config.autostart = config.autostart ?? true;
+  config.modulesRoot = config.modulesRoot ?? "";
+  config.compilerOptions ??= {};
+  config.compilerOptions.build ??= {};
+  config.compilerOptions.build.pwaEnabled ??= true;
+  config.compilerOptions.build.outputDir ??= "dist";
+
+  if (config.modules) {
+    config.modules = config.modules.map((module: string) => {
+      if (module.startsWith(".")) {
+        return "./" + path.join(config.modulesRoot, module);
+      }
+      return module;
+    });
+  }
+
+  config.startMap = config.startMap || config.start?.map;
+  return config as Config;
+}
+

package/src/compatibility-v4/require-transform.ts

@@ -0,0 +1,67 @@
+import * as parser from "@babel/parser";
+import _traverse from "@babel/traverse";
+import _generate from "@babel/generator";
+import { importDeclaration, importDefaultSpecifier, identifier, stringLiteral } from "@babel/types";
+import type { Plugin } from "vite";
+
+const traverse = (_traverse as any).default ?? _traverse;
+const generate = (_generate as any).default ?? _generate;
+
+function readStaticRequireArg(arg: any, ast: any): string {
+  if (!arg) return "";
+  if (arg.type === "StringLiteral") return arg.value;
+  if (arg.type === "Identifier") {
+    let value = "";
+    traverse(ast, {
+      VariableDeclarator(path: any) {
+        if (path.node.id?.name === arg.name && path.node.init?.type === "StringLiteral") {
+          value = path.node.init.value;
+        }
+      },
+    });
+    return value;
+  }
+  if (arg.type === "BinaryExpression" && arg.operator === "+") {
+    const left = readStaticRequireArg(arg.left, ast);
+    const right = readStaticRequireArg(arg.right, ast);
+    return left && right ? left + right : "";
+  }
+  return "";
+}
+
+export default function vitePluginRequire(): Plugin {
+  return {
+    name: "rpgjs-v4-require-transform",
+    transform(code, id) {
+      const fileRegex = /(.jsx?|.tsx?)(\?.*)?$/;
+      const allowRegex = /^(?!.*node_modules(?:\/|\\)(?!rpgjs-|@rpgjs)).*$/;
+      if (!fileRegex.test(id) || !allowRegex.test(id)) {
+        return { code, map: null };
+      }
+
+      const ast = parser.parse(code, {
+        sourceType: "module",
+        plugins: ["typescript", "jsx", "decorators-legacy", "classProperties"],
+      });
+
+      let changed = false;
+      traverse(ast, {
+        CallExpression(path: any) {
+          if (!path.node.callee || path.node.callee.type !== "Identifier" || path.node.callee.name !== "require") return;
+
+          const request = readStaticRequireArg(path.node.arguments[0], ast);
+          if (!request) return;
+
+          const variableName = `__rpgjs_v4_require_${path.scope.generateUidIdentifier("asset").name}`;
+          ast.program.body.unshift(importDeclaration([importDefaultSpecifier(identifier(variableName))], stringLiteral(request)));
+          path.replaceWith(identifier(variableName));
+          changed = true;
+        },
+      });
+
+      if (!changed) return { code, map: null };
+      return { code: generate(ast, {}).code, map: null };
+    },
+  };
+}
+

package/src/compatibility-v4/utils.ts

@@ -0,0 +1,170 @@
+import fs from "fs";
+import path from "path";
+
+export interface ClientBuildConfigOptions {
+  serveMode?: boolean;
+  side?: "client" | "server";
+  type?: "rpg" | "mmorpg";
+  mode?: string;
+  config?: Config;
+  tiledMapBasePath?: string;
+}
+
+export interface Config {
+  modules?: string[];
+  modulesRoot?: string;
+  startMap?: string;
+  start?: {
+    map?: string;
+    graphic?: string;
+    hitbox?: [number, number];
+  };
+  inputs?: Record<string, { bind: string | string[] }>;
+  spritesheetDirectories?: string[];
+  compilerOptions?: {
+    alias?: Record<string, string>;
+    build?: {
+      outputDir?: string;
+      pwaEnabled?: boolean;
+      assetsPath?: string;
+      serverUrl?: string;
+    };
+  };
+  autostart?: boolean;
+  type?: "rpg" | "mmorpg";
+  vite?: any;
+  [key: string]: any;
+}
+
+export interface ImportObject {
+  importString: string;
+  variablesString: string;
+  folder: string;
+  relativePath: string;
+}
+
+export function dedent(strings: TemplateStringsArray, ...values: unknown[]) {
+  const fullString = strings.reduce((acc, str, i) => acc + str + (values[i] ?? ""), "");
+  const lines = fullString.split("\n");
+  let minIndent = Infinity;
+
+  for (const line of lines) {
+    if (!line.trim()) continue;
+    minIndent = Math.min(minIndent, line.match(/^\s*/)?.[0].length ?? 0);
+  }
+
+  if (minIndent === Infinity) return fullString.trim();
+
+  return lines
+    .map((line) => line.trim() ? line.slice(minIndent) : line)
+    .join("\n")
+    .trim();
+}
+
+export function warn(message: string) {
+  console.warn(`[RPG-JS v4 compatibility] ${message}`);
+}
+
+export function toPosix(value: string) {
+  return value.replace(/\\/g, "/");
+}
+
+export function formatVariableName(value: string) {
+  return value.replace(/\./g, "").replace(/[.@/\\ -]/g, "_").replace(/[^A-Za-z0-9_$]/g, "_");
+}
+
+export function transformPathIfModule(moduleName: string) {
+  if (moduleName.startsWith("@rpgjs") || moduleName.startsWith("rpgjs-")) {
+    return path.join("node_modules", moduleName);
+  }
+  return moduleName;
+}
+
+export function resolveModuleImport(moduleName: string) {
+  return moduleName.replace(/^\.\//, "");
+}
+
+export function getAllFiles(dirPath: string): string[] {
+  if (!fs.existsSync(dirPath)) return [];
+  const files: string[] = [];
+  const dirents = fs.readdirSync(dirPath, { withFileTypes: true });
+
+  for (const dirent of dirents) {
+    const fullPath = path.join(dirPath, dirent.name);
+    if (dirent.isDirectory()) {
+      files.push(...getAllFiles(fullPath));
+    } else {
+      files.push(fullPath);
+    }
+  }
+
+  return files;
+}
+
+export function importPathForFile(file: string, root: string) {
+  const srcPath = path.join(root, "src");
+  if (file.startsWith(srcPath + path.sep)) {
+    return `@/${toPosix(path.relative(srcPath, file))}`;
+  }
+  return `./${toPosix(path.relative(root, file))}`;
+}
+
+export function importString(modulePath: string, fileName: string, variableName = fileName, projectRoot = process.cwd()) {
+  const file = path.resolve(projectRoot, transformPathIfModule(modulePath), `${fileName}.ts`);
+  if (!fs.existsSync(file)) return "";
+  return `import ${variableName} from '${importPathForFile(file, projectRoot)}'`;
+}
+
+export function searchFolderAndTransformToImportString(
+  folderPath: string,
+  modulePath: string,
+  extensionFilter: string | string[],
+  returnCb?: (file: string, variableName: string, absoluteFile: string) => string,
+  options?: {
+    customFilter?: (file: string) => boolean;
+  },
+  projectRoot = process.cwd()
+): ImportObject {
+  const folder = path.resolve(projectRoot, transformPathIfModule(modulePath), folderPath);
+  if (!fs.existsSync(folder)) {
+    return { variablesString: "", importString: "", folder: "", relativePath: "" };
+  }
+
+  const extensions = Array.isArray(extensionFilter) ? extensionFilter : [extensionFilter];
+  let importString = "";
+  let relativePath = "";
+  const variablesString = getAllFiles(folder)
+    .filter((file) => extensions.some((ext) => file.endsWith(ext)))
+    .filter((file) => options?.customFilter ? options.customFilter(file) : true)
+    .map((file) => {
+      const importPath = importPathForFile(file, projectRoot);
+      const variableName = formatVariableName(importPath);
+      relativePath = importPath;
+      importString += `\nimport ${variableName} from '${importPath}'`;
+      return returnCb ? returnCb(importPath, variableName, file) : variableName;
+    })
+    .join(",");
+
+  return {
+    variablesString,
+    importString,
+    folder,
+    relativePath,
+  };
+}
+
+export function replaceEnvVars(obj: any, envs: Record<string, string | undefined>): any {
+  if (obj == null) return obj;
+  if (typeof obj === "string" && obj.startsWith("$ENV:")) {
+    return envs[obj.slice(5)];
+  }
+  if (Array.isArray(obj)) return obj.map((item) => replaceEnvVars(item, envs));
+  if (typeof obj === "object") {
+    return Object.fromEntries(Object.entries(obj).map(([key, value]) => [key, replaceEnvVars(value, envs)]));
+  }
+  return obj;
+}
+
+export function assetsFolder(outputDir: string) {
+  return path.join(outputDir, "assets");
+}

package/src/index.ts

@@ -5,4 +5,5 @@ export { removeImportsPlugin, type RemoveImportsPluginOptions } from './remove-i
 export { replaceConfigImport } from './replace-config-import';
 export { rpgjs } from './rpgjs-plugin';
 export { serverPlugin } from './server-plugin';
-export { entryPointPlugin, type EntryPointPluginOptions } from './entry-point-plugin';
+export { entryPointPlugin, type EntryPointPluginOptions } from './entry-point-plugin';
+export { default as compatibilityV4Plugin } from './compatibility-v4';

package/src/mmorpg-build-plugin.ts

@@ -0,0 +1,123 @@
+import { existsSync, rmSync } from "node:fs";
+import { resolve } from "node:path";
+import { build as viteBuild, type Plugin, type ResolvedConfig } from "vite";
+
+interface MmorpgBuildPluginOptions {
+  rpgType: string;
+  serverEntry: string;
+  adapterEntries?: Record<string, string>;
+}
+
+function isBareImport(id: string): boolean {
+  return !id.startsWith(".") && !id.startsWith("/") && !id.startsWith("\0");
+}
+
+function resolveEntry(root: string, entry: string): string {
+  return resolve(root, entry);
+}
+
+function collectServerEntries(
+  root: string,
+  serverEntry: string,
+  adapterEntries: Record<string, string>,
+): Record<string, string> {
+  const entries: Record<string, string> = {};
+  const resolvedServerEntry = resolveEntry(root, serverEntry);
+
+  if (!existsSync(resolvedServerEntry)) {
+    throw new Error(`[rpgjs:mmorpg-build] Missing server entry: ${serverEntry}`);
+  }
+
+  entries.server = resolvedServerEntry;
+
+  for (const [name, entry] of Object.entries(adapterEntries)) {
+    const resolvedAdapterEntry = resolveEntry(root, entry);
+    if (!existsSync(resolvedAdapterEntry)) {
+      throw new Error(`[rpgjs:mmorpg-build] Missing adapter entry "${name}": ${entry}`);
+    }
+    entries[name] = resolvedAdapterEntry;
+  }
+
+  return entries;
+}
+
+export function mmorpgBuildPlugin({
+  rpgType,
+  serverEntry,
+  adapterEntries = {},
+}: MmorpgBuildPluginOptions): Plugin {
+  let config: ResolvedConfig;
+  let didBuildServer = false;
+  let didCleanDist = false;
+
+  return {
+    name: "rpgjs:mmorpg-build",
+    apply: "build",
+    enforce: "post",
+    config(_, env) {
+      if (env.command !== "build" || rpgType !== "mmorpg") {
+        return;
+      }
+
+      return {
+        build: {
+          outDir: "dist/client",
+        },
+      };
+    },
+    configResolved(resolvedConfig) {
+      config = resolvedConfig;
+    },
+    buildStart() {
+      if (rpgType !== "mmorpg" || didCleanDist) {
+        return;
+      }
+      didCleanDist = true;
+      rmSync(resolve(config.root, "dist"), { recursive: true, force: true });
+    },
+    async closeBundle() {
+      if (rpgType !== "mmorpg" || didBuildServer) {
+        return;
+      }
+      didBuildServer = true;
+
+      const entries = collectServerEntries(config.root, serverEntry, adapterEntries);
+      console.log(
+        `[rpgjs:mmorpg-build] Building server bundle(s): ${Object.keys(entries).join(", ")}`,
+      );
+
+      await viteBuild({
+        configFile: false,
+        root: config.root,
+        define: config.define,
+        resolve: {
+          alias: config.resolve.alias,
+          dedupe: config.resolve.dedupe,
+          extensions: config.resolve.extensions,
+          mainFields: config.resolve.mainFields,
+          conditions: config.resolve.conditions,
+        },
+        publicDir: false,
+        build: {
+          emptyOutDir: true,
+          minify: false,
+          outDir: "dist/server",
+          sourcemap: config.build.sourcemap,
+          target: "node18",
+          lib: {
+            entry: entries,
+            formats: ["es"],
+          },
+          rollupOptions: {
+            external(id) {
+              return isBareImport(id);
+            },
+            output: {
+              entryFileNames: "[name].js",
+            },
+          },
+        },
+      });
+    },
+  };
+}

package/src/module-config.ts

@@ -1,6 +1,8 @@
 import { defineConfig, build } from "vite";
 import canvasengine from "@canvasengine/compiler";
 import dts from "vite-plugin-dts";
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
 import { directivePlugin, removeImportsPlugin } from "./index";
 
 /**
@@ -22,6 +24,14 @@ import { directivePlugin, removeImportsPlugin } from "./index";
  */
 function createBuildConfig({ side, watch }: { side: 'client' | 'server', watch: boolean }) {
   const isClient = side === 'client';
+  const runtimeDir = resolve(process.cwd(), "runtime");
+  const resolveOptions = existsSync(runtimeDir)
+    ? {
+        alias: {
+          "@common": runtimeDir,
+        },
+      }
+    : undefined;
   
   const plugins = isClient 
     ? [
@@ -36,6 +46,7 @@ function createBuildConfig({ side, watch }: { side: 'client' | 'server', watch:
 
   return {
     configFile: false as const, // Prevent using this config file
+    resolve: resolveOptions,
     plugins: [
       ...plugins,
       dts({ 
@@ -57,7 +68,9 @@ function createBuildConfig({ side, watch }: { side: 'client' | 'server', watch:
       rollupOptions: {
         external: [
           /@rpgjs/,
+          /@signestack/,
           "canvasengine",
+          "pixi.js",
           "esbuild",
           "@canvasengine/presets",
           "rxjs",

package/src/rpgjs-plugin.ts

@@ -2,12 +2,37 @@ import canvasengine from "@canvasengine/compiler";
 import { replaceConfigImport } from "./replace-config-import";
 import { serverPlugin } from "./server-plugin";
 import { entryPointPlugin } from "./entry-point-plugin";
+import { mmorpgBuildPlugin } from "./mmorpg-build-plugin";
+
+type MmorpgEntryPoints =
+  | string
+  | {
+      client?: string;
+      server?: string;
+      adapters?: Record<string, string>;
+    };
 
 interface RpgjsPluginOptions {
   server: any;
   entryPoints?: {
-    rpg: string;
-    mmorpg: string;
+    rpg?: string;
+    mmorpg?: MmorpgEntryPoints;
+  };
+}
+
+function normalizeMmorpgEntryPoints(entryPoints?: MmorpgEntryPoints) {
+  if (!entryPoints || typeof entryPoints === "string") {
+    return {
+      client: entryPoints ?? "./src/client.ts",
+      server: "./src/server.ts",
+      adapters: {},
+    };
+  }
+
+  return {
+    client: entryPoints.client ?? "./src/client.ts",
+    server: entryPoints.server ?? "./src/server.ts",
+    adapters: entryPoints.adapters ?? {},
   };
 }
 
@@ -15,15 +40,22 @@ export function rpgjs({
   server,
   entryPoints
 }: RpgjsPluginOptions) {
+  const mmorpgEntryPoints = normalizeMmorpgEntryPoints(entryPoints?.mmorpg);
+
   return [
     canvasengine(),
     replaceConfigImport(),
     serverPlugin(server),
+    mmorpgBuildPlugin({
+      rpgType: process.env.RPG_TYPE || "rpg",
+      serverEntry: mmorpgEntryPoints.server,
+      adapterEntries: mmorpgEntryPoints.adapters,
+    }),
     entryPointPlugin({
       entryPoints: {
         rpg: entryPoints?.rpg ?? './src/standalone.ts',
-        mmorpg: entryPoints?.mmorpg ?? './src/client.ts'
+        mmorpg: mmorpgEntryPoints.client,
       }
     })
   ]
-}
+}