minecraft-renderer 0.1.54 → 0.1.56

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "minecraft-renderer",
-  "version": "0.1.54",
+  "version": "0.1.56",
   "description": "The most Modular Minecraft world renderer with Three.js WebGL backend",
   "type": "module",
   "main": "./dist/index.js",

package/src/lib/buildWorkerMcDataIndexes.test.ts

@@ -0,0 +1,48 @@
+//@ts-nocheck
+import { describe, expect, it } from 'vitest'
+import { augmentWorkerMcData } from './buildWorkerMcDataIndexes'
+
+describe('augmentWorkerMcData', () => {
+  it('is idempotent when mcData is augmented twice (menu then world)', () => {
+    const mcData: Record<string, unknown> = {
+      entities: [{ name: 'bat', id: 1, type: 'mob' }],
+      blocks: [{ name: 'stone', id: 3, minStateId: 48, maxStateId: 63, defaultState: 48 }],
+    }
+    augmentWorkerMcData(mcData)
+    expect(() => augmentWorkerMcData(mcData)).not.toThrow()
+    expect(mcData.__workerIndexesBuilt).toBe(true)
+    expect(Array.isArray(mcData.blocksArray)).toBe(true)
+  })
+
+  it('keeps *Array sources after indexing (esbuild mc-data plugin reads blocksArray)', () => {
+    const mcData: Record<string, unknown> = {
+      blocks: [{ name: 'stone', id: 3, minStateId: 48, maxStateId: 63, defaultState: 48 }],
+    }
+    augmentWorkerMcData(mcData)
+    expect(Array.isArray(mcData.blocksArray)).toBe(true)
+    expect((mcData.blocksArray as unknown[]).length).toBe(1)
+    expect(Array.isArray(mcData.blocks)).toBe(false)
+  })
+
+  it('coerces valtio-style dense objects into arrays', () => {
+    const mcData: Record<string, unknown> = {
+      entities: { 0: { name: 'bat', id: 1, type: 'mob' } },
+    }
+    augmentWorkerMcData(mcData)
+    expect((mcData.entitiesByName as Record<string, { name: string }>).bat?.name).toBe('bat')
+  })
+
+  it('builds entitiesByName and items indexes from arrays', () => {
+    const mcData: Record<string, unknown> = {
+      entities: [{ name: 'bat', id: 1, type: 'mob' }],
+      items: [{ name: 'dirt', id: 2 }],
+      blocks: [{ name: 'stone', id: 3, minStateId: 48, maxStateId: 63, defaultState: 48 }],
+    }
+    augmentWorkerMcData(mcData)
+    expect((mcData.entitiesByName as Record<string, { name: string }>).bat?.name).toBe('bat')
+    expect((mcData.entities as Record<number, { id: number }>)[1]?.id).toBe(1)
+    expect((mcData.itemsByName as Record<string, unknown>).dirt).toBeDefined()
+    expect((mcData.items as Record<number, unknown>)[2]).toBeDefined()
+    expect((mcData.blocksByStateId as Record<number, unknown>)[48]).toBeDefined()
+  })
+})

package/src/lib/buildWorkerMcDataIndexes.ts

@@ -0,0 +1,121 @@
+//@ts-nocheck
+type McElement = Record<string, unknown>
+
+function coerceDenseArray (value: unknown): McElement[] | undefined {
+  if (Array.isArray(value)) {
+    return value as McElement[]
+  }
+  if (!value || typeof value !== 'object') {
+    return undefined
+  }
+  const record = value as Record<string, McElement>
+  const keys = Object.keys(record).filter((k) => /^\d+$/.test(k)).map(Number).sort((a, b) => a - b)
+  if (!keys.length || keys[0] !== 0) {
+    return undefined
+  }
+  for (let i = 0; i < keys.length; i++) {
+    if (keys[i] !== i) {
+      return undefined
+    }
+  }
+  return keys.map((k) => record[String(k)])
+}
+
+function buildIndexFromArray<T extends McElement> (
+  array: T[],
+  field: keyof T
+): Record<string | number, T> {
+  if (!Array.isArray(array)) {
+    console.warn('[augmentWorkerMcData] buildIndexFromArray expected array, got', typeof array)
+    return {}
+  }
+  return array.reduce<Record<string | number, T>>((index, element) => {
+    index[element[field] as string | number] = element
+    return index
+  }, {})
+}
+
+function buildIndexFromArrayWithRanges<T extends McElement> (
+  array: T[],
+  minField: keyof T,
+  maxField: keyof T
+): Record<number, T> {
+  if (!Array.isArray(array)) {
+    console.warn('[augmentWorkerMcData] buildIndexFromArrayWithRanges expected array, got', typeof array)
+    return {}
+  }
+  return array.reduce<Record<number, T>>((index, element) => {
+    const min = element[minField] as number
+    const max = element[maxField] as number
+    for (let i = min; i <= max; i++) {
+      index[i] = element
+    }
+    return index
+  }, {})
+}
+
+function ensureBlockStateIds (blocks: McElement[]) {
+  if (!blocks.length) return
+  if ('minStateId' in blocks[0] && 'defaultState' in blocks[0]) return
+  for (const block of blocks) {
+    const id = block.id as number
+    block.minStateId = id << 4
+    block.maxStateId = (block.minStateId as number) + 15
+    block.defaultState = block.minStateId
+  }
+}
+
+function getSourceArray (
+  mcData: Record<string, unknown>,
+  arrayKey: string,
+  rawKey: string
+): McElement[] | undefined {
+  const fromArrayKey = coerceDenseArray(mcData[arrayKey])
+  if (fromArrayKey?.length) {
+    return fromArrayKey
+  }
+  const raw = coerceDenseArray(mcData[rawKey])
+  if (raw?.length) {
+    return raw
+  }
+  return undefined
+}
+
+export function augmentWorkerMcData (mcData: Record<string, unknown>) {
+  if (mcData.__workerIndexesBuilt) {
+    return mcData
+  }
+
+  const blocks = getSourceArray(mcData, 'blocksArray', 'blocks')
+  if (blocks?.length) {
+    ensureBlockStateIds(blocks)
+    mcData.blocksArray = blocks
+    mcData.blocks = buildIndexFromArray(blocks, 'id')
+    mcData.blocksByName = buildIndexFromArray(blocks, 'name')
+    mcData.blocksByStateId = buildIndexFromArrayWithRanges(blocks, 'minStateId', 'maxStateId')
+  }
+
+  const items = getSourceArray(mcData, 'itemsArray', 'items')
+  if (items?.length) {
+    mcData.itemsArray = items
+    mcData.itemsByName = buildIndexFromArray(items, 'name')
+    mcData.items = buildIndexFromArray(items, 'id')
+  }
+
+  const entities = getSourceArray(mcData, 'entitiesArray', 'entities')
+  if (entities?.length) {
+    mcData.entitiesArray = entities
+    mcData.entitiesByName = buildIndexFromArray(entities, 'name')
+    mcData.entities = buildIndexFromArray(entities, 'id')
+  }
+
+  const biomes = getSourceArray(mcData, 'biomesArray', 'biomes')
+  if (biomes?.length) {
+    mcData.biomesArray = biomes
+    mcData.biomes = buildIndexFromArray(biomes, 'id')
+    mcData.biomesByName = buildIndexFromArray(biomes, 'name')
+  }
+
+  mcData.__workerIndexesBuilt = true
+  return mcData
+}

package/src/lib/items.ts

@@ -4,7 +4,7 @@ import nbt from 'prismarine-nbt'
 import { fromFormattedString } from '@xmcl/text-component'
 import { getItemSelector } from '../playerState/playerState'
 import { getItemDefinition } from 'mc-assets/dist/itemDefinitions'
-import { ResourcesManagerCommon } from '../resourcesManager'
+import { getItemsDefinitionsStoreForRender, ResourcesManagerCommon } from '../resourcesManager'
 import { ItemSpecificContextProperties } from '../playerState/types'
 import { PlayerStateRenderer } from '../playerState/playerState'
 
@@ -131,9 +131,10 @@ export const getItemModelName = (item: GeneralInputItem, specificProps: ItemSpec
   const itemSelector = getItemSelector(playerState, {
     ...specificProps
   })
-  const modelFromDef = getItemDefinition(resourcesManager.currentResources!.itemsDefinitionsStore, {
+  const resources = resourcesManager.currentResources!
+  const modelFromDef = getItemDefinition(getItemsDefinitionsStoreForRender(resources), {
     name: itemModelName,
-    version: resourcesManager.currentResources!.version,
+    version: resources.version,
     properties: itemSelector
   })?.model
   const model = (modelFromDef === 'minecraft:special' ? undefined : modelFromDef) ?? itemModelName

package/src/lib/utils.ts

@@ -42,7 +42,7 @@ const detectFullOffscreenCanvasSupport = () => {
 const hasFullOffscreenCanvasSupport = detectFullOffscreenCanvasSupport()
 
 export const createCanvas = (width: number, height: number): OffscreenCanvas => {
-  if (hasFullOffscreenCanvasSupport) {
+  if (hasFullOffscreenCanvasSupport || typeof document === 'undefined') {
     return new OffscreenCanvas(width, height)
   }
   const canvas = document.createElement('canvas')

package/src/lib/workerMessageSanitize.test.ts

@@ -0,0 +1,14 @@
+//@ts-nocheck
+import { describe, expect, it } from 'vitest'
+import { sanitizeForWorkerPostMessage } from './workerMessageSanitize'
+
+describe('sanitizeForWorkerPostMessage', () => {
+  it('drops functions such as debug loggers', () => {
+    const debug = Object.assign(() => {}, { enabled: false })
+    const entity = { id: 1, name: 'zombie', debug, position: { x: 1, y: 2, z: 3 } }
+    const sanitized = sanitizeForWorkerPostMessage(entity) as Record<string, unknown>
+    expect(sanitized.debug).toBeUndefined()
+    expect(sanitized.id).toBe(1)
+    expect(() => structuredClone(sanitized)).not.toThrow()
+  })
+})

package/src/lib/workerMessageSanitize.ts

@@ -0,0 +1,48 @@
+//@ts-nocheck
+/**
+ * Strip non–structured-clone values before Worker.postMessage (e.g. mineflayer `debug` on entities).
+ */
+export function sanitizeForWorkerPostMessage (value: unknown, depth = 0): unknown {
+  if (depth > 16) return undefined
+  if (value === null || value === undefined) return value
+
+  const t = typeof value
+  if (t === 'function' || t === 'symbol') return undefined
+  if (t === 'bigint') return value.toString()
+  if (t !== 'object') return value
+
+  if (value instanceof ArrayBuffer) return value
+  if (ArrayBuffer.isView(value)) {
+    const view = value as ArrayBufferView
+    return view.buffer.slice(view.byteOffset, view.byteOffset + view.byteLength)
+  }
+  if (value instanceof Date) return value.toISOString()
+
+  if (Array.isArray(value)) {
+    return value
+      .map((entry) => sanitizeForWorkerPostMessage(entry, depth + 1))
+      .filter((entry) => entry !== undefined)
+  }
+
+  const record = value as Record<string, unknown>
+  if (
+    typeof record.x === 'number'
+    && typeof record.y === 'number'
+    && typeof record.z === 'number'
+    && !('w' in record)
+  ) {
+    return { x: record.x, y: record.y, z: record.z }
+  }
+
+  const out: Record<string, unknown> = {}
+  for (const key of Object.keys(record)) {
+    if (key === '_client' || key === '_events' || key === '_eventsCount') continue
+    const sanitized = sanitizeForWorkerPostMessage(record[key], depth + 1)
+    if (sanitized !== undefined) out[key] = sanitized
+  }
+  return out
+}
+
+export function sanitizeWorkerEventArgs (args: unknown[]): unknown[] {
+  return args.map((arg) => sanitizeForWorkerPostMessage(arg))
+}

package/src/lib/workerProxy.restore.test.ts

@@ -0,0 +1,29 @@
+//@ts-nocheck
+import { describe, expect, it } from 'vitest'
+import { restoreTransferred } from './workerProxy'
+
+describe('restoreTransferred Set/Map', () => {
+  const worker = null as unknown as Worker
+
+  it('restores Set from __setValues', () => {
+    const out = restoreTransferred({ __restorer: 'Set', __setValues: ['a', 'b'] }, [], worker, false)
+    expect(out).toEqual(new Set(['a', 'b']))
+  })
+
+  it('does not throw when legacy values is a function (Map.values collision)', () => {
+    const map = new Map([['k', 1]])
+    const out = restoreTransferred({ __restorer: 'Set', values: map.values.bind(map) }, [], worker, false)
+    expect(out).toEqual(new Set())
+  })
+
+  it('restores Map from __mapEntries', () => {
+    const out = restoreTransferred({ __restorer: 'Map', __mapEntries: [['a', 1]] }, [], worker, false)
+    expect(out).toEqual(new Map([['a', 1]]))
+  })
+
+  it('does not throw when legacy entries is a function', () => {
+    const m = new Map()
+    const out = restoreTransferred({ __restorer: 'Map', entries: m.entries.bind(m) }, [], worker, false)
+    expect(out).toEqual(new Map())
+  })
+})

package/src/lib/workerProxy.ts

@@ -117,6 +117,10 @@ const getSyncId = () => {
   return Math.random().toString(36).slice(2, 15) + Math.random().toString(36).slice(2, 15)
 }
 
+const applySyncPatch = (target: any, patch: any, worker: Worker) => {
+  Object.assign(target, restoreTransferred(patch, [], worker, false))
+}
+
 const setupObjectSync = (obj: any, originalObj: any, worker: Worker, isValtio: boolean, debugKey: string) => {
   if (!obj['__syncToWorker'] && !obj['__syncFromWorker'] && !isValtio) return
 
@@ -141,13 +145,45 @@ const setupObjectSync = (obj: any, originalObj: any, worker: Worker, isValtio: b
     worker.addEventListener('message', (event: any) => {
       if (event.data.type === 'sync' && event.data.syncId === syncId) {
         currentWorkerSyncStats.fromWorker++
-        Object.assign(originalObj, event.data.value)
+        applySyncPatch(originalObj, event.data.value, worker)
       }
     })
   }
 }
 
+const serializeMapForTransfer = (map: Map<unknown, unknown>) => ({
+  __restorer: 'Map',
+  __mapEntries: Array.from(map.entries()),
+})
+
+const serializeSetForTransfer = (set: Set<unknown>) => ({
+  __restorer: 'Set',
+  __setValues: [...set],
+})
+
+const isSetLike = (value: unknown): value is Set<unknown> => {
+  return value instanceof Set || Object.prototype.toString.call(value) === '[object Set]'
+}
+
+const isMapLike = (value: unknown): value is Map<unknown, unknown> => {
+  return value instanceof Map || Object.prototype.toString.call(value) === '[object Map]'
+}
+
+const iterableFromPlainObject = (obj: Record<string, unknown>) => {
+  return Object.keys(obj)
+    .filter(k => !k.startsWith('__'))
+    .sort((a, b) => Number(a) - Number(b))
+    .map(k => obj[k])
+}
+
 const cloneValtioObject = (obj: any) => {
+  if (isMapLike(obj)) {
+    return serializeMapForTransfer(obj)
+  }
+  if (isSetLike(obj)) {
+    return serializeSetForTransfer(obj)
+  }
+
   if (getVersion(obj) === undefined) {
     return obj
   }
@@ -179,16 +215,19 @@ export const deepPrepareForTransfer = (obj: any, worker: Worker, autoRemoveMetho
         continue
       }
 
-      // print a warning for Date, RegExp, Map, WeakMap, WeakSet
-      if (obj[key] instanceof Date || obj[key] instanceof RegExp || obj[key] instanceof Map || obj[key] instanceof WeakMap || obj[key] instanceof WeakSet) {
+      // print a warning for Date, RegExp, WeakMap, WeakSet
+      if (obj[key] instanceof Date || obj[key] instanceof RegExp || obj[key] instanceof WeakMap || obj[key] instanceof WeakSet) {
         console.warn(`Warning: ${key} is a ${typeof obj[key]}, which is not supported for transfer.`)
       }
 
       // default restorers main -> worker
+      if (isMapLike(obj[key])) {
+        newObj[key] = serializeMapForTransfer(obj[key])
+        continue
+      }
       // Set (only primitive values)
-      if (obj[key] instanceof Set) {
-        newObj[key] = [...obj[key]]
-        newObj[key]['__restorer'] = 'Set'
+      if (isSetLike(obj[key])) {
+        newObj[key] = serializeSetForTransfer(obj[key])
         continue
       }
       if (obj[key] instanceof Vec3) {
@@ -253,7 +292,7 @@ const receiveSyncedObject = (obj: any, worker: Worker, debugKey: string) => {
   if (obj['__syncToWorker']) {
     worker.addEventListener('message', (event: any) => {
       if (event.data.type === 'sync' && event.data.syncId === syncId) {
-        Object.assign(obj, event.data.value)
+        applySyncPatch(obj, event.data.value, worker)
       }
     })
   }
@@ -275,10 +314,36 @@ const receiveSyncedObject = (obj: any, worker: Worker, debugKey: string) => {
 }
 
 const defaultRestorers = [
+  {
+    restorerName: 'Map',
+    restoreTransferred(obj, _worker: Worker) {
+      if (Array.isArray(obj)) {
+        return new Map(obj)
+      }
+      const raw = obj.__mapEntries ?? obj.entries
+      if (Array.isArray(raw)) {
+        return new Map(raw)
+      }
+      if (raw != null && typeof raw === 'object' && typeof raw !== 'function') {
+        return new Map(Object.entries(raw as Record<string, unknown>))
+      }
+      return new Map()
+    }
+  },
   {
     restorerName: 'Set',
-    restoreTransferred(obj, worker: Worker) {
-      return new Set(obj)
+    restoreTransferred(obj, _worker: Worker) {
+      if (Array.isArray(obj)) {
+        return new Set(obj)
+      }
+      const raw = obj.__setValues ?? obj.values
+      if (Array.isArray(raw)) {
+        return new Set(raw)
+      }
+      if (raw != null && typeof raw === 'object' && typeof raw !== 'function') {
+        return new Set(iterableFromPlainObject(raw as Record<string, unknown>))
+      }
+      return new Set()
     }
   },
   {
@@ -296,41 +361,50 @@ export const addDefaultRestorer = (restorer: { restorerName: string, restoreTran
 export const restoreTransferred = (obj: any, restorersArg: any[], worker: Worker, errorHandler: ((error: Error) => void) | boolean = true) => {
   const restorers = [...defaultRestorers, ...restorersArg]
 
-  for (const key in obj) {
-    if (Object.prototype.hasOwnProperty.call(obj, key)) {
-      if (!obj[key]) continue
+  const restoreValue = (value: any, debugKey: string): any => {
+    if (value == null || typeof value !== 'object') {
+      return value
+    }
 
-      if (typeof obj[key] === 'object' && obj[key] !== null) {
-        restoreTransferred(obj[key], restorers, worker, errorHandler)
+    if (value['__restorer']) {
+      const restorer = restorers.find(r => {
+        return r.restorerName ? r.restorerName === value['__restorer'] : r.name === value['__restorer']
+      })
+      if (restorer) {
+        return restorer.restoreTransferred(value, worker)
       }
-
-      if (obj[key]['__restorer']) {
-        // find restorer
-        const restorer = restorers.find(restorer => {
-          return restorer.restorerName ? restorer.restorerName === obj[key]['__restorer'] : restorer.name === obj[key]['__restorer']
-        })
-        if (restorer) {
-          obj[key] = restorer.restoreTransferred(obj[key], worker)
-        } else {
-          const error = new Error(`Restorer ${obj[key]['__restorer']} not found`)
-          if (typeof errorHandler === 'function') {
-            errorHandler(error)
-          } else if (errorHandler) {
-            throw error
-          } else {
-            console.error(error)
-          }
-        }
+      const error = new Error(`Restorer ${value['__restorer']} not found`)
+      if (typeof errorHandler === 'function') {
+        errorHandler(error)
+      } else if (errorHandler) {
+        throw error
+      } else {
+        console.error(error)
       }
+      return value
+    }
+
+    if (Array.isArray(value)) {
+      return value.map((item, index) => restoreValue(item, `${debugKey}[${index}]`))
+    }
 
-      if (obj[key]['__valtio']) {
-        obj[key] = proxy(obj[key])
+    for (const key in value) {
+      if (!Object.prototype.hasOwnProperty.call(value, key)) continue
+      const child = value[key]
+      if (child != null && typeof child === 'object') {
+        value[key] = restoreValue(child, `${debugKey}.${key}`)
       }
+    }
 
-      receiveSyncedObject(obj[key], worker, key)
+    if (value['__valtio']) {
+      value = proxy(value)
     }
+
+    receiveSyncedObject(value, worker, debugKey)
+    return value
   }
-  return obj
+
+  return restoreValue(obj, 'root')
 }
 
 // const workerProxy = createWorkerProxy({

package/src/lib/worldrendererCommon.ts

@@ -1295,3 +1295,28 @@ export const meshersSendMcData = (workers: Worker[], version: string, mcDataKeys
     worker.postMessage({ type: 'mcData', mcData })
   }
 }
+
+/** Wait for worker `mcDataApplied` after {@link meshersSendMcData}. */
+export const meshersSendMcDataAwait = (
+  workers: Worker[],
+  version: string,
+  mcDataKeys = dynamicMcDataFiles,
+  mcDataFull: IndexedData,
+  timeoutMs = 10_000
+): Promise<void> => {
+  return Promise.all(workers.map(worker => new Promise<void>((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      worker.removeEventListener('message', handler as EventListener)
+      reject(new Error(`mcData transfer timeout (${timeoutMs}ms)`))
+    }, timeoutMs)
+    const handler = ({ data }: MessageEvent) => {
+      if (data?.type === 'mcDataApplied') {
+        clearTimeout(timeout)
+        worker.removeEventListener('message', handler as EventListener)
+        resolve()
+      }
+    }
+    worker.addEventListener('message', handler as EventListener)
+    meshersSendMcData([worker], version, mcDataKeys, mcDataFull)
+  }))).then(() => undefined)
+}