minecraft-renderer 0.1.79 → 0.1.81

package/src/lib/workerProxy.ts

@@ -9,7 +9,7 @@ export function createWorkerProxy<T extends Record<string, (...args: any[]) => v
     if (handlers[type]) {
       const result = handlers[type](...args)
       if (result instanceof Promise) {
-        void result.then((result) => {
+        void result.then(result => {
           target.postMessage({
             type: 'result',
             msgId,
@@ -33,7 +33,10 @@ export function createWorkerProxy<T extends Record<string, (...args: any[]) => v
  * const workerChannel = useWorkerProxy<typeof importedTypeWorkerProxy>(worker)
  * ```
  */
-export const useWorkerProxy = <T extends { __workerProxy: Record<string, (...args: any[]) => void> }>(worker: Worker | MessagePort, autoTransfer = true): T['__workerProxy'] & {
+export const useWorkerProxy = <T extends { __workerProxy: Record<string, (...args: any[]) => void> }>(
+  worker: Worker | MessagePort,
+  autoTransfer = true
+): T['__workerProxy'] & {
   transfer: (...args: Transferable[]) => T['__workerProxy']
 } => {
   let messageId = 0
@@ -42,31 +45,45 @@ export const useWorkerProxy = <T extends { __workerProxy: Record<string, (...arg
     get(target, prop) {
       if (prop === 'transfer') {
         return (...transferable: Transferable[]) => {
-          return new Proxy({}, {
-            get(target, prop) {
-              return (...args: any[]) => {
-                worker.postMessage({
-                  type: prop,
-                  args,
-                }, transferable)
+          return new Proxy(
+            {},
+            {
+              get(target, prop) {
+                return (...args: any[]) => {
+                  worker.postMessage(
+                    {
+                      type: prop,
+                      args
+                    },
+                    transferable
+                  )
+                }
               }
             }
-          })
+          )
         }
       }
       return (...args: any[]) => {
         const msgId = messageId++
-        const transfer = autoTransfer ? args.filter(arg => {
-          return arg instanceof ArrayBuffer || arg instanceof MessagePort
-            || (typeof ImageBitmap !== 'undefined' && arg instanceof ImageBitmap)
-            || (typeof OffscreenCanvas !== 'undefined' && arg instanceof OffscreenCanvas)
-            || (typeof ImageData !== 'undefined' && arg instanceof ImageData)
-        }) : []
-        worker.postMessage({
-          type: prop,
-          msgId,
-          args,
-        }, transfer)
+        const transfer = autoTransfer
+          ? args.filter(arg => {
+              return (
+                arg instanceof ArrayBuffer ||
+                arg instanceof MessagePort ||
+                (typeof ImageBitmap !== 'undefined' && arg instanceof ImageBitmap) ||
+                (typeof OffscreenCanvas !== 'undefined' && arg instanceof OffscreenCanvas) ||
+                (typeof ImageData !== 'undefined' && arg instanceof ImageData)
+              )
+            })
+          : []
+        worker.postMessage(
+          {
+            type: prop,
+            msgId,
+            args
+          },
+          transfer
+        )
         return {
           // eslint-disable-next-line unicorn/no-thenable
           then(onfulfilled: (value: any) => void) {
@@ -91,9 +108,7 @@ const DEBUG_SYNC = false
 
 type SyncDirection = 'toWorker' | 'fromWorker'
 
-export type WireSyncOp =
-  | { kind: 'set', path: (string | number | symbol)[], value: unknown }
-  | { kind: 'delete', path: (string | number | symbol)[] }
+export type WireSyncOp = { kind: 'set'; path: (string | number | symbol)[]; value: unknown } | { kind: 'delete'; path: (string | number | symbol)[] }
 
 type ValtioOp = readonly unknown[]
 
@@ -211,13 +226,7 @@ const wireOpsFromValtioOps = (ops: ValtioOp[], worker: Worker): WireSyncOp[] =>
   return wire
 }
 
-export const sendWorkerSyncOps = (
-  syncId: string,
-  ops: ValtioOp[],
-  worker: Worker,
-  direction: SyncDirection,
-  debugKey: string
-) => {
+export const sendWorkerSyncOps = (syncId: string, ops: ValtioOp[], worker: Worker, direction: SyncDirection, debugKey: string) => {
   if (ops.length === 0) return
   const wire = wireOpsFromValtioOps(ops, worker)
   if (wire.length === 0) return
@@ -235,12 +244,7 @@ export const sendWorkerSyncOps = (
   }
 }
 
-export const applySyncOps = (
-  target: any,
-  wireOps: WireSyncOp[],
-  worker: Worker,
-  countReceive: 'fromWorker' | false = false
-) => {
+export const applySyncOps = (target: any, wireOps: WireSyncOp[], worker: Worker, countReceive: 'fromWorker' | false = false) => {
   for (const op of wireOps) {
     if (op.kind === 'delete') {
       deleteByPath(target, op.path)
@@ -285,7 +289,7 @@ const setupObjectSync = (obj: any, originalObj: any, worker: Worker, isValtio: b
 
   if (syncToWorker || isValtio) {
     if (isValtio && syncToWorker !== false) {
-      subscribe(originalObj, (ops) => {
+      subscribe(originalObj, ops => {
         sendWorkerSyncOps(syncId, ops as ValtioOp[], worker, 'toWorker', `toWorker:${debugKey}`)
       })
     }
@@ -344,7 +348,14 @@ export const deepPrepareForTransfer = (obj: any, worker: Worker, autoRemoveMetho
       }
 
       // print a warning for Date, RegExp, Map, Set, WeakMap, WeakSet
-      if (obj[key] instanceof Date || obj[key] instanceof RegExp || obj[key] instanceof Map || obj[key] instanceof Set || obj[key] instanceof WeakMap || obj[key] instanceof WeakSet) {
+      if (
+        obj[key] instanceof Date ||
+        obj[key] instanceof RegExp ||
+        obj[key] instanceof Map ||
+        obj[key] instanceof Set ||
+        obj[key] instanceof WeakMap ||
+        obj[key] instanceof WeakSet
+      ) {
         console.warn(`Warning: ${key} is a ${typeof obj[key]}, which is not supported for transfer.`)
       }
 
@@ -395,7 +406,6 @@ export const deepPrepareForTransfer = (obj: any, worker: Worker, autoRemoveMetho
         }
         setupObjectSync(newObj[key], originalObj[key], worker, false, key)
 
-
         newObj[key] = deepPrepareForTransfer(newObj[key], worker, autoRemoveMethods, false, isValtio)
       }
     }
@@ -451,7 +461,7 @@ const receiveSyncedObject = (obj: any, worker: Worker, debugKey: string) => {
 
   if (obj['__syncFromWorker']) {
     if (obj['__valtio']) {
-      subscribe(obj, (ops) => {
+      subscribe(obj, ops => {
         sendWorkerSyncOps(syncId, ops as ValtioOp[], worker, 'fromWorker', `fromWorker:${debugKey}`)
       })
     }
@@ -474,7 +484,7 @@ const defaultRestorers = [
   }
 ]
 
-export const addDefaultRestorer = (restorer: { restorerName: string, restoreTransferred: (obj: any, worker: Worker) => any }) => {
+export const addDefaultRestorer = (restorer: { restorerName: string; restoreTransferred: (obj: any, worker: Worker) => any }) => {
   defaultRestorers.unshift(restorer)
 }
 

package/src/lib/workerSyncOps.test.ts

@@ -2,14 +2,7 @@
 import { describe, expect, it, vi, beforeEach, afterEach } from 'vitest'
 import { proxy, subscribe } from 'valtio'
 import { Vec3 } from 'vec3'
-import {
-  applySyncOps,
-  getWorkerSyncStatsForTest,
-  resetWorkerSyncStatsForTest,
-  sendWorkerSyncOps,
-  setByPath,
-  type WireSyncOp,
-} from './workerProxy'
+import { applySyncOps, getWorkerSyncStatsForTest, resetWorkerSyncStatsForTest, sendWorkerSyncOps, setByPath, type WireSyncOp } from './workerProxy'
 import { defaultPerformanceInstabilityFactors } from '../performanceMonitor'
 
 const fakeWorker = () => {
@@ -23,22 +16,23 @@ const fakeWorker = () => {
     addEventListener: vi.fn((_type: string, listener: (event: { data: any }) => void) => {
       listeners.push(listener)
     }),
-    removeEventListener: vi.fn(),
+    removeEventListener: vi.fn()
   } as unknown as Worker
 }
 
-const makeRendererState = () => proxy({
-  world: {
-    chunksLoaded: {} as Record<string, true>,
-    heightmaps: {} as Record<string, Int16Array>,
-    allChunksLoaded: false,
-    mesherWork: false,
-    instabilityFactors: defaultPerformanceInstabilityFactors(),
-    intersectMedia: null as null | object,
-  },
-  renderer: '...',
-  preventEscapeMenu: false,
-})
+const makeRendererState = () =>
+  proxy({
+    world: {
+      chunksLoaded: {} as Record<string, true>,
+      heightmaps: {} as Record<string, Int16Array>,
+      allChunksLoaded: false,
+      mesherWork: false,
+      instabilityFactors: defaultPerformanceInstabilityFactors(),
+      intersectMedia: null as null | object
+    },
+    renderer: '...',
+    preventEscapeMenu: false
+  })
 
 describe('workerSyncOps', () => {
   it('set op round-trips mesherWork', () => {
@@ -75,11 +69,17 @@ describe('workerSyncOps', () => {
     sender.world.heightmaps['0,0'] = source
     const receiver = makeRendererState()
     const buf = sender.world.heightmaps['0,0']!
-    applySyncOps(receiver, [{
-      kind: 'set',
-      path: ['world', 'heightmaps', '0,0'],
-      value: new Int16Array(buf),
-    }], fakeWorker())
+    applySyncOps(
+      receiver,
+      [
+        {
+          kind: 'set',
+          path: ['world', 'heightmaps', '0,0'],
+          value: new Int16Array(buf)
+        }
+      ],
+      fakeWorker()
+    )
     expect([...receiver.world.heightmaps['0,0']!]).toEqual([1, 2, 3])
     expect(sender.world.heightmaps['0,0']![0]).toBe(1)
   })
@@ -87,11 +87,17 @@ describe('workerSyncOps', () => {
   it('Vec3 value survives via restorer', () => {
     const target = makeRendererState() as any
     const vec = new Vec3(1, 2, 3)
-    applySyncOps(target, [{
-      kind: 'set',
-      path: ['world', 'intersectMedia'],
-      value: { pos: { x: 1, y: 2, z: 3, __restorer: 'Vec3' } },
-    }], fakeWorker())
+    applySyncOps(
+      target,
+      [
+        {
+          kind: 'set',
+          path: ['world', 'intersectMedia'],
+          value: { pos: { x: 1, y: 2, z: 3, __restorer: 'Vec3' } }
+        }
+      ],
+      fakeWorker()
+    )
     expect(target.world.intersectMedia.pos).toBeInstanceOf(Vec3)
     expect(target.world.intersectMedia.pos.x).toBe(1)
   })
@@ -105,8 +111,8 @@ describe('workerSyncOps', () => {
       messageCount++
       expect(data.ops.length).toBeGreaterThanOrEqual(2)
     })
-    await new Promise<void>((resolve) => {
-      subscribe(source, (ops) => {
+    await new Promise<void>(resolve => {
+      subscribe(source, ops => {
         sendWorkerSyncOps(syncId, ops, worker, 'toWorker', 'test')
         resolve()
       })
@@ -128,20 +134,31 @@ describe('workerSyncOps', () => {
 
     it('one postMessage increments toWorker by 1 regardless of op count', () => {
       const worker = fakeWorker()
-      sendWorkerSyncOps('id', [
-        ['set', ['world', 'mesherWork'], true, false],
-        ['set', ['renderer'], 'x', '...'],
-      ], worker, 'toWorker', 'test')
+      sendWorkerSyncOps(
+        'id',
+        [
+          ['set', ['world', 'mesherWork'], true, false],
+          ['set', ['renderer'], 'x', '...']
+        ],
+        worker,
+        'toWorker',
+        'test'
+      )
       expect(worker.postMessage).toHaveBeenCalledTimes(1)
       expect(getWorkerSyncStatsForTest().toWorker).toBe(1)
     })
 
     it('applySyncOps with fromWorker counts one receive per message', () => {
       const target = makeRendererState()
-      applySyncOps(target, [
-        { kind: 'set', path: ['world', 'mesherWork'], value: true },
-        { kind: 'set', path: ['renderer'], value: 'y' },
-      ], fakeWorker(), 'fromWorker')
+      applySyncOps(
+        target,
+        [
+          { kind: 'set', path: ['world', 'mesherWork'], value: true },
+          { kind: 'set', path: ['renderer'], value: 'y' }
+        ],
+        fakeWorker(),
+        'fromWorker'
+      )
       expect(getWorkerSyncStatsForTest().fromWorker).toBe(1)
     })
   })

package/src/lib/worldrendererCommon.reconfigure.test.ts

@@ -15,13 +15,13 @@ vi.mock('./ui/newStats', () => ({
   updateStatText: vi.fn(),
   removeAllStats: vi.fn(),
   updatePanesVisibility: vi.fn(),
-  MC_RENDERER_DEBUG_OVERLAY_CLASS: 'mc-renderer-debug-overlay',
+  MC_RENDERER_DEBUG_OVERLAY_CLASS: 'mc-renderer-debug-overlay'
 }))
 
 vi.mock('./utils/skins', () => ({
   setSkinsConfig: vi.fn(),
   steveTexture: {},
-  stevePngUrl: '',
+  stevePngUrl: ''
 }))
 
 function ensurePromiseWithResolvers() {
@@ -60,10 +60,10 @@ function createRenderer(workerCount = 2, worldView?: DisplayWorldOptions['worldV
       allChunksLoaded: false,
       mesherWork: false,
       instabilityFactors: defaultPerformanceInstabilityFactors(),
-      intersectMedia: null,
+      intersectMedia: null
     },
     renderer: '',
-    preventEscapeMenu: false,
+    preventEscapeMenu: false
   })
 
   const displayOptions: DisplayWorldOptions = {
@@ -79,19 +79,19 @@ function createRenderer(workerCount = 2, worldView?: DisplayWorldOptions['worldV
       world: {
         chunksLoadedCount: 0,
         chunksTotalNumber: 0,
-        chunksFullInfo: '',
+        chunksFullInfo: ''
       },
       renderer: {
-        timeline: { live: [], frozen: [], lastSecond: [] },
-      },
+        timeline: { live: [], frozen: [], lastSecond: [] }
+      }
     },
     resourcesManager: {
       currentResources: {
         mcData: { version: {} },
         blocksAtlasJson: {},
-        blockstatesModels: {},
-      },
-    } as DisplayWorldOptions['resourcesManager'],
+        blockstatesModels: {}
+      }
+    } as DisplayWorldOptions['resourcesManager']
   }
 
   const initOptions: GraphicsInitOptions = {
@@ -100,15 +100,15 @@ function createRenderer(workerCount = 2, worldView?: DisplayWorldOptions['worldV
     callbacks: {
       displayCriticalError: vi.fn(),
       setRendererSpecificSettings: vi.fn(),
-      fireCustomEvent: vi.fn(),
-    },
+      fireCustomEvent: vi.fn()
+    }
   }
 
   const renderer = new TestWorldRenderer(displayOptions.resourcesManager, displayOptions, initOptions)
   renderer.active = true
   renderer.workers = Array.from({ length: workerCount }, () => ({
     postMessage: vi.fn(),
-    terminate: vi.fn(),
+    terminate: vi.fn()
   }))
   renderer['syncMesherPoolSnapshot']()
   renderer.viewDistance = 8
@@ -121,12 +121,15 @@ describe('WorldRendererCommon.reconfigureMesherWorkers', () => {
   beforeEach(() => {
     ensurePromiseWithResolvers()
     vi.stubGlobal('location', { href: 'http://localhost/' })
-    vi.stubGlobal('Worker', class MockWorker {
-      postMessage = vi.fn()
-      terminate = vi.fn()
-      addEventListener = vi.fn()
-      onmessage: ((event: MessageEvent) => void) | null = null
-    })
+    vi.stubGlobal(
+      'Worker',
+      class MockWorker {
+        postMessage = vi.fn()
+        terminate = vi.fn()
+        addEventListener = vi.fn()
+        onmessage: ((event: MessageEvent) => void) | null = null
+      }
+    )
     vi.spyOn(worldRendererModule, 'meshersSendMcData').mockImplementation(() => {})
   })
 
@@ -137,7 +140,7 @@ describe('WorldRendererCommon.reconfigureMesherWorkers', () => {
 
   test('recreates workers with new count and reloads chunks', async () => {
     const { renderer, reloadLoadedChunks } = createRenderer(3)
-    const terminated = renderer.workers.map((worker) => worker.terminate)
+    const terminated = renderer.workers.map(worker => worker.terminate)
     renderer.worldRendererConfig.mesherWorkers = 1
 
     await renderer.reconfigureMesherWorkers()
@@ -151,7 +154,7 @@ describe('WorldRendererCommon.reconfigureMesherWorkers', () => {
 
   test('recreates workers when mesher pipeline changes', async () => {
     const { renderer, reloadLoadedChunks } = createRenderer(2)
-    const terminated = renderer.workers.map((worker) => worker.terminate)
+    const terminated = renderer.workers.map(worker => worker.terminate)
     renderer.worldRendererConfig.wasmMesher = false
 
     await renderer.reconfigureMesherWorkers()

package/src/lib/worldrendererCommon.removeColumn.test.ts

@@ -14,13 +14,13 @@ vi.mock('./ui/newStats', () => ({
   updateStatText: vi.fn(),
   removeAllStats: vi.fn(),
   updatePanesVisibility: vi.fn(),
-  MC_RENDERER_DEBUG_OVERLAY_CLASS: 'mc-renderer-debug-overlay',
+  MC_RENDERER_DEBUG_OVERLAY_CLASS: 'mc-renderer-debug-overlay'
 }))
 
 vi.mock('./utils/skins', () => ({
   setSkinsConfig: vi.fn(),
   steveTexture: {},
-  stevePngUrl: '',
+  stevePngUrl: ''
 }))
 
 function ensurePromiseWithResolvers() {
@@ -58,10 +58,10 @@ function createRenderer() {
       allChunksLoaded: false,
       mesherWork: false,
       instabilityFactors: defaultPerformanceInstabilityFactors(),
-      intersectMedia: null,
+      intersectMedia: null
     },
     renderer: '',
-    preventEscapeMenu: false,
+    preventEscapeMenu: false
   })
 
   const displayOptions = {
@@ -78,13 +78,13 @@ function createRenderer() {
         chunksLoaded: new Set<string>(),
         chunksLoadedCount: 0,
         chunksTotalNumber: 0,
-        chunksFullInfo: '',
+        chunksFullInfo: ''
       },
       renderer: {
-        timeline: { live: [], frozen: [], lastSecond: [] },
-      },
+        timeline: { live: [], frozen: [], lastSecond: [] }
+      }
     },
-    resourcesManager: {} as DisplayWorldOptions['resourcesManager'],
+    resourcesManager: {} as DisplayWorldOptions['resourcesManager']
   }
 
   const initOptions: GraphicsInitOptions = {
@@ -93,8 +93,8 @@ function createRenderer() {
     callbacks: {
       displayCriticalError: vi.fn(),
       setRendererSpecificSettings: vi.fn(),
-      fireCustomEvent: vi.fn(),
-    },
+      fireCustomEvent: vi.fn()
+    }
   }
 
   const renderer = new TestWorldRenderer(displayOptions.resourcesManager, displayOptions as DisplayWorldOptions, initOptions)
@@ -159,9 +159,7 @@ describe('WorldRendererCommon.removeColumn sectionsWaiting reconciliation', () =
     }).not.toThrow()
 
     expect(renderer.sectionsWaiting.has(sectionKey)).toBe(false)
-    expect(debugSpy).toHaveBeenCalledWith(
-      expect.stringContaining('sectionFinished for non-outstanding section'),
-    )
+    expect(debugSpy).toHaveBeenCalledWith(expect.stringContaining('sectionFinished for non-outstanding section'))
 
     debugSpy.mockRestore()
   })