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

package/tests/fixtures/v4-game/src/modules/main/sprite.ts

@@ -0,0 +1,4 @@
+export default {
+  onInit() {}
+}
+

package/tests/fixtures/v4-game/src/modules/main/worlds/maps/world-map.tmx

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<map version="1.9" tiledversion="1.9.2" orientation="orthogonal" renderorder="right-down" width="1" height="1" tilewidth="32" tileheight="32" infinite="0" nextlayerid="2" nextobjectid="1">
+ <layer id="1" name="Ground" width="1" height="1">
+  <data encoding="csv">0</data>
+ </layer>
+</map>

package/tests/fixtures/v4-game/src/modules/main/worlds/world.world

@@ -0,0 +1,13 @@
+{
+  "maps": [
+    {
+      "fileName": "maps/world-map.tmx",
+      "height": 640,
+      "width": 800,
+      "x": 64,
+      "y": -160
+    }
+  ],
+  "onlyShowAdjacentMaps": false,
+  "type": "world"
+}

package/tests/latency-simulation.spec.ts

@@ -0,0 +1,209 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+
+// Mock the PartyConnection class for testing
+class MockPartyConnection {
+  public static latencyEnabled: boolean = false;
+  public static latencyMinMs: number = 50;
+  public static latencyMaxMs: number = 200;
+  public static latencyFilter: string = '';
+
+  public id: string;
+  private ws: any;
+
+  constructor(ws: any, id?: string) {
+    this.ws = ws;
+    this.id = id || 'test-connection';
+  }
+
+  async send(data: any): Promise<void> {
+    if (this.ws.readyState === 1) {
+      const message = typeof data === "string" ? data : JSON.stringify(data);
+      
+      // Check if latency simulation is enabled
+      if (MockPartyConnection.latencyEnabled && MockPartyConnection.latencyMaxMs > 0) {
+        // Apply filter if specified
+        if (MockPartyConnection.latencyFilter && !message.includes(MockPartyConnection.latencyFilter)) {
+          this.ws.send(message);
+          return;
+        }
+        
+        // Calculate random latency between min and max
+        const latencyMs = Math.random() * (MockPartyConnection.latencyMaxMs - MockPartyConnection.latencyMinMs) + MockPartyConnection.latencyMinMs;
+        
+        // Delay the message
+        await new Promise(resolve => setTimeout(resolve, latencyMs));
+      }
+      
+      this.ws.send(message);
+    }
+  }
+
+  static configureLatency(enabled: boolean, minMs: number, maxMs: number, filter?: string): void {
+    MockPartyConnection.latencyEnabled = enabled;
+    MockPartyConnection.latencyMinMs = Math.max(0, minMs);
+    MockPartyConnection.latencyMaxMs = Math.max(MockPartyConnection.latencyMinMs, maxMs);
+    MockPartyConnection.latencyFilter = filter || '';
+  }
+
+  static getLatencyStatus(): { enabled: boolean; minMs: number; maxMs: number; filter: string } {
+    return {
+      enabled: MockPartyConnection.latencyEnabled,
+      minMs: MockPartyConnection.latencyMinMs,
+      maxMs: MockPartyConnection.latencyMaxMs,
+      filter: MockPartyConnection.latencyFilter
+    };
+  }
+}
+
+describe('Latency Simulation', () => {
+  let mockWs: any;
+
+  beforeEach(() => {
+    // Reset latency settings before each test
+    MockPartyConnection.configureLatency(false, 0, 0);
+    
+    // Create mock WebSocket
+    mockWs = {
+      readyState: 1, // WebSocket.OPEN
+      send: vi.fn(),
+      close: vi.fn()
+    };
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('Configuration', () => {
+    it('should configure latency settings correctly', () => {
+      MockPartyConnection.configureLatency(true, 100, 300, 'sync');
+      
+      const status = MockPartyConnection.getLatencyStatus();
+      expect(status.enabled).toBe(true);
+      expect(status.minMs).toBe(100);
+      expect(status.maxMs).toBe(300);
+      expect(status.filter).toBe('sync');
+    });
+
+    it('should clamp minMs to 0', () => {
+      MockPartyConnection.configureLatency(true, -50, 200);
+      
+      const status = MockPartyConnection.getLatencyStatus();
+      expect(status.minMs).toBe(0);
+    });
+
+    it('should ensure maxMs is at least minMs', () => {
+      MockPartyConnection.configureLatency(true, 200, 100);
+      
+      const status = MockPartyConnection.getLatencyStatus();
+      expect(status.maxMs).toBe(200); // Should be set to minMs value
+    });
+
+    it('should disable latency when enabled is false', () => {
+      MockPartyConnection.configureLatency(false, 100, 300);
+      
+      const status = MockPartyConnection.getLatencyStatus();
+      expect(status.enabled).toBe(false);
+    });
+  });
+
+  describe('Message Sending', () => {
+    it('should send message immediately when latency is disabled', async () => {
+      const connection = new MockPartyConnection(mockWs);
+      const startTime = Date.now();
+      
+      await connection.send('test message');
+      
+      const endTime = Date.now();
+      expect(mockWs.send).toHaveBeenCalledWith('test message');
+      expect(endTime - startTime).toBeLessThan(10); // Should be almost immediate
+    });
+
+    it('should delay message when latency is enabled', async () => {
+      MockPartyConnection.configureLatency(true, 50, 100);
+      const connection = new MockPartyConnection(mockWs);
+      const startTime = Date.now();
+      
+      await connection.send('test message');
+      
+      const endTime = Date.now();
+      expect(mockWs.send).toHaveBeenCalledWith('test message');
+      expect(endTime - startTime).toBeGreaterThanOrEqual(50);
+      expect(endTime - startTime).toBeLessThanOrEqual(150); // Allow some buffer
+    });
+
+    it('should apply filter correctly', async () => {
+      MockPartyConnection.configureLatency(true, 50, 100, 'sync');
+      const connection = new MockPartyConnection(mockWs);
+      
+      // Message with filter should be delayed
+      const startTime1 = Date.now();
+      await connection.send('sync message');
+      const endTime1 = Date.now();
+      expect(endTime1 - startTime1).toBeGreaterThanOrEqual(50);
+      
+      // Message without filter should be sent immediately
+      const startTime2 = Date.now();
+      await connection.send('normal message');
+      const endTime2 = Date.now();
+      expect(endTime2 - startTime2).toBeLessThan(10);
+    });
+
+    it('should not send when WebSocket is not open', async () => {
+      mockWs.readyState = 3; // WebSocket.CLOSED
+      const connection = new MockPartyConnection(mockWs);
+      
+      await connection.send('test message');
+      
+      expect(mockWs.send).not.toHaveBeenCalled();
+    });
+
+    it('should handle JSON data correctly', async () => {
+      const connection = new MockPartyConnection(mockWs);
+      const testData = { type: 'test', value: 123 };
+      
+      await connection.send(testData);
+      
+      expect(mockWs.send).toHaveBeenCalledWith(JSON.stringify(testData));
+    });
+  });
+
+  describe('Edge Cases', () => {
+    it('should handle zero latency range', async () => {
+      MockPartyConnection.configureLatency(true, 0, 0);
+      const connection = new MockPartyConnection(mockWs);
+      const startTime = Date.now();
+      
+      await connection.send('test message');
+      
+      const endTime = Date.now();
+      expect(mockWs.send).toHaveBeenCalledWith('test message');
+      expect(endTime - startTime).toBeLessThan(10); // Should be immediate
+    });
+
+    it('should handle very high latency', async () => {
+      MockPartyConnection.configureLatency(true, 1000, 2000);
+      const connection = new MockPartyConnection(mockWs);
+      const startTime = Date.now();
+      
+      await connection.send('test message');
+      
+      const endTime = Date.now();
+      expect(mockWs.send).toHaveBeenCalledWith('test message');
+      expect(endTime - startTime).toBeGreaterThanOrEqual(1000);
+      expect(endTime - startTime).toBeLessThanOrEqual(2100); // Allow buffer
+    });
+
+    it('should handle empty filter string', async () => {
+      MockPartyConnection.configureLatency(true, 50, 100, '');
+      const connection = new MockPartyConnection(mockWs);
+      const startTime = Date.now();
+      
+      await connection.send('test message');
+      
+      const endTime = Date.now();
+      expect(mockWs.send).toHaveBeenCalledWith('test message');
+      expect(endTime - startTime).toBeGreaterThanOrEqual(50); // Should still be delayed
+    });
+  });
+});

package/tests/remove-imports-plugin.spec.ts

@@ -0,0 +1,56 @@
+import { afterEach, describe, expect, test, vi } from "vitest";
+import { removeImportsPlugin } from "../src/remove-imports-plugin";
+
+const transform = async (code: string, id = "/tmp/source.ts") => {
+  const plugin = removeImportsPlugin({
+    patterns: ["vue", /^@server\//],
+  });
+  return plugin.transform?.call({} as any, code, id) as any;
+};
+
+describe("removeImportsPlugin", () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  test("replaces default, named and namespace imports with null declarations", async () => {
+    const result = await transform(`
+      import Vue, { ref as vueRef, computed } from "vue";
+      import * as serverApi from "@server/api";
+      import { keep } from "client";
+
+      export const state = [Vue, vueRef, computed, serverApi, keep];
+    `);
+
+    expect(result.code).toContain("const Vue = null;");
+    expect(result.code).toContain("const vueRef = null;");
+    expect(result.code).toContain("const computed = null;");
+    expect(result.code).toContain("const serverApi = null;");
+    expect(result.code).toContain('import { keep } from "client";');
+    expect(result.map).toBeDefined();
+  });
+
+  test("replaces side-effect imports with a stable comment", async () => {
+    const result = await transform(`
+      import "vue";
+      export const ready = true;
+    `);
+
+    expect(result.code).toContain("// removed import: vue");
+    expect(result.code).toContain("export const ready = true;");
+  });
+
+  test("ignores unmatched files and parse failures", async () => {
+    expect(await transform('import "vue";', "/tmp/style.css")).toBeNull();
+    expect(await transform('import { broken from "vue";')).toBeNull();
+  });
+
+  test("warns once when parsing fails", async () => {
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+
+    await transform('import { broken from "vue";');
+
+    expect(warn).toHaveBeenCalledOnce();
+    expect(String(warn.mock.calls[0][0])).toContain("Failed to parse");
+  });
+});

package/tsconfig.json

@@ -2,7 +2,7 @@
   "compilerOptions": {
     "target": "ES2020",
     "module": "ESNext",
-    "moduleResolution": "node",
+    "moduleResolution": "bundler",
     "declaration": true,
     "outDir": "dist",
     "rootDir": "src",
@@ -14,4 +14,4 @@
   },
   "include": ["src/**/*"],
   "exclude": ["node_modules", "dist"]
-} 
+} 

package/vite.config.ts

@@ -36,9 +36,15 @@ export default defineConfig({
         'vite',
         'vite-plugin-dts',
         '@canvasengine/compiler',
+        '@iarna/toml',
+        'image-size',
+        '@babel/parser',
+        '@babel/traverse',
+        '@babel/generator',
+        '@babel/types',
         'chokidar',
         'ws'
       ]
     }
   },
-})
+})