minecraft-inventory 0.1.0

package/src/components/Tooltip/Tooltip.module.css

@@ -0,0 +1,56 @@
+.tooltip {
+  background: #100010;
+  border: 1px solid #100010;
+  border-radius: 5px;
+  display: flex;
+  flex-direction: column;
+  font-family: 'Minecraftia', 'Minecraft', monospace;
+  image-rendering: pixelated;
+  line-height: 1.2;
+  /* MC tooltip: 2-layer purple gradient inner glow */
+  box-shadow:
+    inset 0 1px 0 0 #5000a0,
+    inset 1px 0 0 0 #5000a0,
+    inset -1px 0 0 0 #5000a0,
+    inset 0 -1px 0 0 #28007f,
+    0 0 0 1px #100010;
+}
+
+.name {
+  font-weight: bold;
+  white-space: nowrap;
+  margin-bottom: 2px;
+}
+
+.section {
+  display: flex;
+  flex-direction: column;
+}
+
+.enchantment {
+  color: #8080ff;
+  white-space: nowrap;
+}
+
+.lore {
+  display: flex;
+  flex-direction: column;
+  color: #6b29a4;
+  font-style: italic;
+  border-top: 1px solid #2d0069;
+  margin-top: 3px;
+  padding-top: 3px;
+}
+
+.durability {
+  color: #dddddd;
+  border-top: 1px solid #2d0069;
+  margin-top: 3px;
+  padding-top: 3px;
+}
+
+.typeId {
+  color: #444455;
+  font-size: 0.8em;
+  margin-top: 2px;
+}

package/src/components/Tooltip/Tooltip.tsx

@@ -0,0 +1,130 @@
+import React, { useRef, useState, useEffect, useLayoutEffect } from 'react'
+import { createPortal } from 'react-dom'
+import type { ItemStack } from '../../types'
+import { useScale } from '../../context/ScaleContext'
+import { MessageFormattedString } from '../Text/MessageFormattedString'
+import styles from './Tooltip.module.css'
+
+interface TooltipProps {
+  item: ItemStack
+  mouseX: number
+  mouseY: number
+  visible: boolean
+}
+
+function getRarityColor(item: ItemStack): string {
+  if (item.enchantments && item.enchantments.length > 0) return '#8080ff'
+  return '#ffffff'
+}
+
+function formatEnchantment(e: { name: string; level: number }): string {
+  const roman = ['', 'I', 'II', 'III', 'IV', 'V', 'VI', 'VII', 'VIII', 'IX', 'X']
+  return e.level <= 10 ? `${e.name} ${roman[e.level]}` : `${e.name} ${e.level}`
+}
+
+export function Tooltip({ item, mouseX, mouseY, visible }: TooltipProps) {
+  const { scale } = useScale()
+  const ref = useRef<HTMLDivElement>(null)
+  const [pos, setPos] = useState({ x: -9999, y: -9999 })
+  const [ready, setReady] = useState(false)
+
+  // Recompute position every time mouse moves or item changes
+  useLayoutEffect(() => {
+    if (!visible || !ref.current) return
+    const el = ref.current
+    const tw = el.offsetWidth
+    const th = el.offsetHeight
+    const vw = window.innerWidth
+    const vh = window.innerHeight
+    const gapX = 12
+    const gapY = 2
+
+    let x = mouseX + gapX
+    let y = mouseY - th - gapY  // above cursor by default
+
+    if (x + tw > vw - 4) x = mouseX - tw - gapX
+    if (y < 4) y = mouseY + gapY  // flip below if no space above
+    if (y + th > vh - 4) y = vh - th - 4
+
+    setPos({ x, y })
+    setReady(true)
+  }, [mouseX, mouseY, visible, item, scale])
+
+  // Reset ready when tooltip becomes hidden
+  useEffect(() => {
+    if (!visible) setReady(false)
+  }, [visible])
+
+  if (!visible) return null
+
+  const nameColor = getRarityColor(item)
+  const hasDurability =
+    item.durability !== undefined &&
+    item.maxDurability !== undefined &&
+    item.durability < item.maxDurability
+
+  const fs = Math.round(8 * scale)
+  const pad = Math.round(4 * scale)
+  const gap2 = Math.round(1 * scale)
+
+  const tooltip = (
+    <div
+      ref={ref}
+      className={['mc-inv-tooltip', styles.tooltip].join(' ')}
+      style={{
+        position: 'fixed',
+        left: pos.x,
+        top: pos.y,
+        zIndex: 10000,
+        fontSize: fs,
+        padding: pad,
+        gap: gap2,
+        minWidth: Math.round(80 * scale),
+        maxWidth: Math.round(220 * scale),
+        visibility: ready ? 'visible' : 'hidden',
+        pointerEvents: 'none',
+      }}
+    >
+      <div className={styles.name} style={{ color: nameColor }}>
+        <MessageFormattedString
+          text={item.displayName ?? (item.name ? item.name.replace(/_/g, ' ') : `Item #${item.type}`)}
+          fallbackColor={nameColor}
+        />
+      </div>
+
+      {item.enchantments && item.enchantments.length > 0 && (
+        <div className={styles.section}>
+          {item.enchantments.map((e, i) => (
+            <div key={i} className={styles.enchantment}>
+              {formatEnchantment(e)}
+            </div>
+          ))}
+        </div>
+      )}
+
+      {item.lore && item.lore.length > 0 && (
+        <div className={styles.lore}>
+          {item.lore.map((line, i) => (
+            <div key={i}>
+              <MessageFormattedString text={line} />
+            </div>
+          ))}
+        </div>
+      )}
+
+      {hasDurability && (
+        <div className={styles.durability}>
+          Durability: {item.durability} / {item.maxDurability}
+        </div>
+      )}
+
+      <div className={styles.typeId}>
+        {item.name ?? `#${item.type}`}
+        {item.metadata !== undefined && item.metadata > 0 ? `:${item.metadata}` : ''}
+      </div>
+    </div>
+  )
+
+  // Portal to document.body so position:fixed works even inside transformed ancestors
+  return createPortal(tooltip, document.body)
+}

package/src/components/Tooltip/index.ts

@@ -0,0 +1 @@
+export { Tooltip } from './Tooltip'

package/src/connector/demo.ts

@@ -0,0 +1,213 @@
+import type { InventoryAction, InventoryWindowState, PlayerState, SlotState, ItemStack } from '../types'
+import type { InventoryConnector, ConnectorListener, ConnectorEvent } from './types'
+
+export interface ActionLogEntry {
+  id: number
+  timestamp: number
+  action: InventoryAction
+  description: string
+}
+
+export interface DemoConnectorOptions {
+  windowType: string
+  windowTitle?: string
+  slots?: SlotState[]
+  playerInventory?: SlotState[]
+  onAction?: (entry: ActionLogEntry) => void
+}
+
+let actionCounter = 0
+
+function describeAction(action: InventoryAction): string {
+  switch (action.type) {
+    case 'click':
+      return `${action.mode === 'shift' ? 'Shift-' : ''}${action.button === 'right' ? 'Right' : 'Left'} click slot ${action.slotIndex}${action.mode === 'number' ? ` (hotbar ${action.numberKey})` : ''}`
+    case 'drop':
+      return `Drop ${action.all ? 'all' : 'one'} from slot ${action.slotIndex}`
+    case 'drag':
+      return `Drag ${action.button} across slots: ${action.slots.join(', ')}`
+    case 'close':
+      return 'Close window'
+    case 'trade':
+      return `Trade at index ${action.tradeIndex}`
+    case 'rename':
+      return `Rename to "${action.text}"`
+    case 'enchant':
+      return `Select enchantment ${action.enchantIndex}`
+    case 'beacon':
+      return `Set beacon effects: ${action.primaryEffect} / ${action.secondaryEffect}`
+    case 'hotbar-swap':
+      return `Swap slot ${action.slotIndex} with hotbar ${action.hotbarSlot}`
+    default:
+      return JSON.stringify(action)
+  }
+}
+
+export function createDemoConnector(options: DemoConnectorOptions): InventoryConnector & {
+  actionLog: ActionLogEntry[]
+  updateSlots(slots: SlotState[]): void
+  setHeldItem(item: ItemStack | null): void
+  openWindow(type: string, title: string, slots: SlotState[]): void
+  closeWindowExternal(): void
+} {
+  const listeners = new Set<ConnectorListener>()
+  const actionLog: ActionLogEntry[] = []
+
+  let windowState: InventoryWindowState | null = {
+    windowId: 1,
+    type: options.windowType,
+    title: options.windowTitle ?? options.windowType,
+    slots: options.slots ?? [],
+    heldItem: null,
+  }
+
+  let playerState: PlayerState = {
+    activeHotbarSlot: 0,
+    inventory: options.playerInventory ?? [],
+  }
+
+  function emit(event: ConnectorEvent) {
+    listeners.forEach((l) => l(event))
+  }
+
+  return {
+    actionLog,
+
+    getWindowState: () => windowState,
+    getPlayerState: () => playerState,
+
+    sendAction: (action: InventoryAction) => {
+      const entry: ActionLogEntry = {
+        id: ++actionCounter,
+        timestamp: Date.now(),
+        action,
+        description: describeAction(action),
+      }
+      actionLog.unshift(entry)
+      if (actionLog.length > 100) actionLog.splice(100)
+      options.onAction?.(entry)
+
+      // Demo: simulate simple click behavior
+      if (action.type === 'click' && windowState) {
+        const slots = [...windowState.slots]
+        const slotState = slots.find((s) => s.index === action.slotIndex)
+        const held = windowState.heldItem
+
+        if (action.button === 'left' && action.mode === 'normal') {
+          if (held && slotState) {
+            const idx = slots.indexOf(slotState)
+            const existing = slotState.item
+            if (!existing) {
+              slots[idx] = { ...slotState, item: held }
+              windowState = { ...windowState, slots, heldItem: null }
+            } else if (
+              existing.type === held.type &&
+              (existing.name ?? '') === (held.name ?? '') &&
+              (existing.metadata ?? 0) === (held.metadata ?? 0)
+            ) {
+              // Same item type — combine stacks
+              const maxStack = 64
+              const space = maxStack - existing.count
+              if (space > 0) {
+                const take = Math.min(held.count, space)
+                slots[idx] = { ...slotState, item: { ...existing, count: existing.count + take } }
+                const remain = held.count - take
+                windowState = { ...windowState, slots, heldItem: remain > 0 ? { ...held, count: remain } : null }
+              } else {
+                // Stack full — swap
+                slots[idx] = { ...slotState, item: held }
+                windowState = { ...windowState, slots, heldItem: existing }
+              }
+            } else {
+              // Different item types — swap
+              slots[idx] = { ...slotState, item: held }
+              windowState = { ...windowState, slots, heldItem: existing }
+            }
+          } else if (!held && slotState?.item) {
+            const idx = slots.indexOf(slotState)
+            slots[idx] = { ...slotState, item: null }
+            windowState = { ...windowState, slots, heldItem: slotState.item }
+          }
+        } else if (action.button === 'right' && action.mode === 'normal') {
+          if (!held && slotState?.item) {
+            const item = slotState.item
+            const half = Math.ceil(item.count / 2)
+            const remain = item.count - half
+            const idx = slots.indexOf(slotState)
+            slots[idx] = { ...slotState, item: remain > 0 ? { ...item, count: remain } : null }
+            windowState = { ...windowState, slots, heldItem: { ...item, count: half } }
+          } else if (held && slotState) {
+            const idx = slots.indexOf(slotState)
+            const existing = slotState.item
+            if (!existing || existing.type === held.type) {
+              slots[idx] = {
+                ...slotState,
+                item: { ...held, count: (existing?.count ?? 0) + 1 },
+              }
+              const newCount = held.count - 1
+              windowState = {
+                ...windowState,
+                slots,
+                heldItem: newCount > 0 ? { ...held, count: newCount } : null,
+              }
+            }
+          }
+        } else if (action.mode === 'shift' && slotState?.item) {
+          // Simulate shift-click: just log it
+        }
+
+        emit({ type: 'windowUpdate', state: windowState })
+      }
+
+      if (action.type === 'drop' && windowState) {
+        const slots = [...windowState.slots]
+        const slotState = slots.find((s) => s.index === action.slotIndex)
+        if (slotState?.item) {
+          const idx = slots.indexOf(slotState)
+          if (action.all) {
+            slots[idx] = { ...slotState, item: null }
+          } else {
+            const count = slotState.item.count - 1
+            slots[idx] = { ...slotState, item: count > 0 ? { ...slotState.item, count } : null }
+          }
+          windowState = { ...windowState, slots }
+          emit({ type: 'windowUpdate', state: windowState })
+        }
+      }
+    },
+
+    closeWindow: () => {
+      windowState = null
+      emit({ type: 'windowClose' })
+    },
+
+    subscribe: (listener: ConnectorListener) => {
+      listeners.add(listener)
+      return () => listeners.delete(listener)
+    },
+
+    updateSlots: (slots: SlotState[]) => {
+      if (windowState) {
+        windowState = { ...windowState, slots }
+        emit({ type: 'windowUpdate', state: windowState })
+      }
+    },
+
+    setHeldItem: (item: ItemStack | null) => {
+      if (windowState) {
+        windowState = { ...windowState, heldItem: item }
+        emit({ type: 'heldItemChange', item })
+      }
+    },
+
+    openWindow: (type: string, title: string, slots: SlotState[]) => {
+      windowState = { windowId: ++actionCounter, type, title, slots, heldItem: null }
+      emit({ type: 'windowOpen', state: windowState })
+    },
+
+    closeWindowExternal: () => {
+      windowState = null
+      emit({ type: 'windowClose' })
+    },
+  }
+}

package/src/connector/index.ts

@@ -0,0 +1,4 @@
+export type { InventoryConnector, ConnectorEvent, ConnectorListener, MineflayerBot } from './types'
+export { createMineflayerConnector } from './mineflayer'
+export { createDemoConnector } from './demo'
+export type { DemoConnectorOptions, ActionLogEntry } from './demo'

package/src/connector/mineflayer.ts

@@ -0,0 +1,113 @@
+import type { InventoryAction, InventoryWindowState, PlayerState, SlotState, ItemStack } from '../types'
+import type { InventoryConnector, ConnectorListener, ConnectorEvent, MineflayerBot } from './types'
+
+function botSlotToItemStack(slot: MineflayerBot['heldItem']): ItemStack | null {
+  if (!slot || slot.type === -1 || slot.type === 0) return null
+  return {
+    type: slot.type,
+    count: slot.count,
+    metadata: slot.metadata,
+    nbt: slot.nbt as Record<string, unknown> | undefined,
+  }
+}
+
+function botSlotsToSlotStates(slots: MineflayerBot['inventory']['slots']): SlotState[] {
+  return slots.map((slot, index) => ({
+    index,
+    item: botSlotToItemStack(slot),
+  }))
+}
+
+function modeFromAction(action: InventoryAction): [number, number] {
+  if (action.type !== 'click') return [0, 0]
+  if (action.mode === 'shift') return [action.button === 'left' ? 0 : 1, 1]
+  if (action.mode === 'number' && action.numberKey !== undefined) return [action.numberKey, 2]
+  if (action.mode === 'middle') return [2, 3]
+  if (action.mode === 'drop') return [action.button === 'left' ? 0 : 1, 4]
+  if (action.mode === 'drag') return [action.button === 'left' ? 0 : 4, 5]
+  if (action.mode === 'double') return [0, 6]
+  return [action.button === 'left' ? 0 : 1, 0]
+}
+
+export function createMineflayerConnector(bot: MineflayerBot): InventoryConnector {
+  const listeners = new Set<ConnectorListener>()
+
+  function emit(event: ConnectorEvent) {
+    listeners.forEach((l) => l(event))
+  }
+
+  function buildWindowState(): InventoryWindowState | null {
+    const win = bot.currentWindow
+    if (!win) return null
+    return {
+      windowId: win.id,
+      type: win.type ?? 'unknown',
+      title: win.title,
+      slots: botSlotsToSlotStates(win.slots),
+      heldItem: botSlotToItemStack(bot.heldItem),
+    }
+  }
+
+  function buildPlayerState(): PlayerState {
+    const inv = bot.inventory.slots
+    return {
+      activeHotbarSlot: bot.quickBarSlot,
+      inventory: botSlotsToSlotStates(inv),
+    }
+  }
+
+  const onWindowOpen = () => {
+    const state = buildWindowState()
+    if (state) emit({ type: 'windowOpen', state })
+  }
+
+  const onWindowClose = () => {
+    emit({ type: 'windowClose' })
+  }
+
+  const onSetSlot = () => {
+    const state = buildWindowState()
+    if (state) emit({ type: 'windowUpdate', state })
+    else {
+      emit({ type: 'playerUpdate', state: buildPlayerState() })
+    }
+  }
+
+  bot.on('windowOpen', onWindowOpen)
+  bot.on('windowClose', onWindowClose)
+  bot.on('setSlot', onSetSlot)
+
+  return {
+    getWindowState: buildWindowState,
+    getPlayerState: buildPlayerState,
+
+    sendAction: async (action: InventoryAction) => {
+      if (action.type === 'click') {
+        const [mouseButton, mode] = modeFromAction(action)
+        await bot.clickWindow(action.slotIndex, mouseButton, mode)
+      } else if (action.type === 'drop') {
+        await bot.clickWindow(action.slotIndex, action.all ? 1 : 0, 4)
+      } else if (action.type === 'close') {
+        const win = bot.currentWindow
+        if (win) bot.closeWindow(win)
+      } else if (action.type === 'hotbar-swap') {
+        await bot.clickWindow(action.slotIndex, action.hotbarSlot, 2)
+      }
+    },
+
+    closeWindow: () => {
+      const win = bot.currentWindow
+      if (win) bot.closeWindow(win)
+    },
+
+    subscribe: (listener: ConnectorListener) => {
+      listeners.add(listener)
+      return () => {
+        listeners.delete(listener)
+        bot.off('windowOpen', onWindowOpen)
+        bot.off('windowClose', onWindowClose)
+        bot.off('setSlot', onSetSlot)
+      }
+    },
+  }
+}

package/src/connector/types.ts

@@ -0,0 +1,41 @@
+import type { InventoryAction, InventoryWindowState, PlayerState, TradeOffer } from '../types'
+
+export interface InventoryConnector {
+  getWindowState(): InventoryWindowState | null
+  getPlayerState(): PlayerState | null
+  sendAction(action: InventoryAction): void | Promise<void>
+  closeWindow(): void | Promise<void>
+  subscribe(listener: ConnectorListener): () => void
+}
+
+export type ConnectorEvent =
+  | { type: 'windowOpen'; state: InventoryWindowState }
+  | { type: 'windowClose' }
+  | { type: 'windowUpdate'; state: InventoryWindowState }
+  | { type: 'playerUpdate'; state: PlayerState }
+  | { type: 'heldItemChange'; item: InventoryWindowState['heldItem'] }
+
+export type ConnectorListener = (event: ConnectorEvent) => void
+
+export interface MineflayerBot {
+  inventory: {
+    slots: Array<{ type: number; count: number; metadata?: number; nbt?: unknown } | null>
+  }
+  currentWindow: {
+    id: number
+    type: string
+    title?: string
+    slots: Array<{ type: number; count: number; metadata?: number; nbt?: unknown } | null>
+  } | null
+  heldItem: { type: number; count: number; metadata?: number; nbt?: unknown } | null
+  health: number
+  food: number
+  foodSaturation: number
+  experience: { level: number; progress: number; points: number }
+  quickBarSlot: number
+  clickWindow(slot: number, mouseButton: number, mode: number): Promise<void>
+  closeWindow(window: unknown): void
+  on(event: string, listener: (...args: unknown[]) => void): void
+  off(event: string, listener: (...args: unknown[]) => void): void
+  removeListener(event: string, listener: (...args: unknown[]) => void): void
+}