Full TypeScript rewrite. Best type defs

package.json

@@ -2,19 +2,22 @@
   "name": "flying-squid",
   "description": "A minecraft server written in node.js",
   "version": "1.8.0",
-  "main": "index.js",
+  "main": "dist/index.js",
+  "bin": "dist/app.js",
   "author": "mhsjlw <[email protected]>",
   "contributors": [
     {
       "name": "rom1504",
       "email": "[email protected]"
     }
   ],
-  "bin": "app.js",
   "scripts": {
+    "start": "tsc && node dist/app.js",
+    "build": "tsc && node scripts/genTypes.mjs",
+    "prepare": "npm run build",
     "prepublishOnly": "cp docs/README.md README.md",
-    "lint": "standard test/*.test.js src/**/*.js src/**/**/*.js src/*.js examples/*.js *.js",
-    "fix": "standard --fix test/*.test.js src/**/*.js src/**/**/*.js src/*.js examples/*.js *.js",
+    "lint": "ts-standard test/*.test.js src/ examples/ *.js",
+    "fix": "ts-standard --fix test/*.test.js src/ examples/ *.js",
     "mocha_test": "mocha --reporter spec --timeout 3000 --exit",
     "test": "npm run mocha_test",
     "pretest": "npm run lint"
@@ -53,6 +56,7 @@
     "range": "^0.0.3",
     "readline": "^1.3.0",
     "spiralloop": "^1.0.2",
+    "typed-emitter": "1.4.0",
     "uuid-1345": "^1.0.1",
     "vec3": "^0.1.6",
     "yargs": "^17.0.1"
@@ -71,6 +75,7 @@
     "minecraft-wrap": "^1.2.3",
     "mineflayer": "^4.17.0",
     "mocha": "^10.0.0",
-    "standard": "^17.0.0"
+    "standard": "^17.0.0",
+    "ts-standard": "^12.0.2"
   }
 }

scripts/genTypes.mjs

@@ -0,0 +1,7 @@
+import fs from 'fs'
+
+const targetFile = './dist/types.d.ts';
+let types = fs.readFileSync(targetFile, 'utf8')
+const plugins = fs.readdirSync('./dist/lib/plugins').filter(f => f !== 'index')
+types = plugins.filter(module => module.endsWith('.d.ts')).map(module => `import "./lib/plugins/${module}"`).join('\n') + '\n' + types
+fs.writeFileSync(targetFile, types, 'utf8')

src/globals.d.ts

@@ -1,12 +1,21 @@
 // make process.platform also accept browser
 declare namespace NodeJS {
-    interface Process {
-        platform: string;
-        browser?: boolean
-    }
+  interface Process {
+    // @ts-expect-error
+    platform: string
+    browser?: boolean
+  }
 
 }
 interface NodeRequire {
-    // webpack bundling
-    context: (path: string, deep: boolean, filter: RegExp) => { keys: () => string[]; (id: string): any };
+  // webpack bundling
+  context: (path: string, deep: boolean, filter: RegExp) => { keys: () => string[], (id: string): any }
+}
+
+interface ObjectConstructor {
+  keys: <T extends object>(obj: T) => Array<StringKeys<T>>
+  entries: <T extends object>(obj: T) => Array<[StringKeys<T>, T[keyof T]]>
+  // todo review https://stackoverflow.com/questions/57390305/trying-to-get-fromentries-type-right
+  fromEntries: <T extends Array<[string, any]>>(obj: T) => Record<T[number][0], T[number][1]>
+  assign: <T extends Record<string, any>, K extends Record<string, any>>(target: T, source: K) => asserts target is T & K
 }

src/index.ts

@@ -0,0 +1,98 @@
+import { createServer, Server as ProtocolServer } from 'minecraft-protocol'
+
+import { testedVersions, latestSupportedVersion, oldestSupportedVersion } from './lib/version'
+import Command from './lib/command'
+import * as plugins from './lib/plugins'
+import { EventEmitter } from 'events'
+
+import { IndexedData } from 'minecraft-data'
+import './types' // include Server declarations from all plugins
+import './modules'
+
+if (typeof process !== 'undefined' && !process.browser && process.platform !== 'browser' && parseInt(process.versions.node.split('.')[0]) < 18) {
+  console.error('[\x1b[31mCRITICAL\x1b[0m] Node.JS 18 or newer is required')
+  console.error('[\x1b[31mCRITICAL\x1b[0m] You can download the new version from https://nodejs.org/')
+  console.error(`[\x1b[31mCRITICAL\x1b[0m] Your current Node.JS version is: ${process.versions.node}`)
+  process.exit(1)
+}
+
+require('emit-then').register()
+if (process.env.NODE_ENV === 'dev') {
+  require('longjohn')
+}
+
+type InputOptions = Partial<Options> & Pick<Options, 'version'>
+
+export function createMCServer (options: InputOptions) {
+  const mcServer = new MCServer()
+  mcServer.connect({
+    // defaults
+    'max-entities': 100,
+    ...options
+  })
+  return mcServer as unknown as Server
+}
+
+class MCServer extends EventEmitter {
+  pluginsReady = false
+  _server: ProtocolServer = null!
+  constructor () {
+    plugins.initPlugins()
+    super()
+  }
+
+  connect (options) {
+    const server = this as unknown as Server
+    const registry = require('prismarine-registry')(options.version)
+    if (!registry?.version) throw new Error(`Server version '${registry?.version}' is not supported, no data for version`)
+
+    const versionData = registry.version
+    if (versionData['>'](latestSupportedVersion)) {
+      throw new Error(`Server version '${registry?.version}' is not supported. Latest supported version is '${latestSupportedVersion}'.`)
+    } else if (versionData['<'](oldestSupportedVersion)) {
+      throw new Error(`Server version '${registry?.version}' is not supported. Oldest supported version is '${oldestSupportedVersion}'.`)
+    }
+
+    server.commands = new Command({})
+    server._server = createServer(options)
+
+    const promises: Array<Promise<any>> = []
+    for (const plugin of plugins.builtinPlugins) {
+      promises.push(plugin.server?.(server, options))
+    }
+    Promise.all(promises).then(() => {
+      server.emit('pluginsReady')
+      server.pluginsReady = true
+    })
+
+    if (options.logging === true) server.createLog()
+    server._server.on('error', error => {
+      server.emit('error', error)
+    })
+    server._server.on('listening', () => {
+      // @ts-expect-error dont remember the right cast
+      server.emit('listening', server._server.socketServer.address().port)
+    })
+    server.emit('asap')
+  }
+}
+
+declare global {
+  interface Server {
+    commands: Command
+    pluginsReady: boolean
+    _server: ProtocolServer
+    supportFeature: (feature: string) => boolean
+  }
+}
+
+export {
+  testedVersions
+}
+
+export * as Behavior from './lib/behavior'
+export * as Command from './lib/command'
+export { default as generations } from './lib/generations'
+export * as experience from './lib/experience'
+export * as UserError from './lib/user_error'
+export { default as portal_detector } from './lib/portal_detector'

src/lib/behavior.js → src/lib/behavior.ts

@@ -1,5 +1,5 @@
-module.exports = (obj) => {
-  return async (eventName, data, func, cancelFunc) => {
+export default (obj) => {
+  return async (eventName: string, data?: any, func: Function = (() => { }), cancelFunc?: Function) => {
     let hiddenCancelled = false
     let cancelled = false
     let cancelCount = 0
@@ -13,9 +13,7 @@ module.exports = (obj) => {
       defaultCancel = dC
     }
 
-    let resp
-
-    func = func || (() => {})
+    let resp!: boolean | Promise<any>
 
     await obj.emitThen(eventName + '_cancel', data, cancel).catch((err) => setTimeout(() => { throw err }, 0))
     await obj.emitThen(eventName, data, cancelled, cancelCount).catch((err) => setTimeout(() => { throw err }, 0))
@@ -24,7 +22,7 @@ module.exports = (obj) => {
       resp = func(data)
       if (resp instanceof Promise) resp = await resp.catch((err) => setTimeout(() => { throw err }, 0))
       if (typeof resp === 'undefined') resp = true
-    } else if (cancelFunc && defaultCancel) {
+    } else if ((cancelFunc != null) && defaultCancel) {
       resp = cancelFunc(data)
       if (resp instanceof Promise) resp = await resp.catch((err) => setTimeout(() => { throw err }, 0))
       if (typeof resp === 'undefined') resp = false

src/lib/command.js → src/lib/command.ts

@@ -1,9 +1,33 @@
-const UserError = require('./user_error')
+import UserError from './user_error'
+
+type Ctx<P extends boolean> = P extends true ? {
+  player: Player
+} : {
+  player?: Player
+}
+
+type NonFalsey<T> = T extends false ? never : NonNullable<T>
+
+interface AddParams<T, P extends boolean = false> {
+  base: string
+  aliases?: string[]
+  info: string
+  usage: string
+  onlyPlayer?: P
+  op?: boolean
+  parse?: (string: string, ctx: Ctx<P>) => T
+  action: (data: NonFalsey<T>, ctx: Ctx<P>) => any
+  tab?: string[]
+}
 
 class Command {
-  constructor (params, parent, hash) {
-    this.params = params
-    this.parent = parent
+  hash: any
+  uniqueHash: any
+  parentBase: any
+  base: any
+  path: string
+
+  constructor (public params, public parent?, hash?) {
     this.hash = parent ? parent.hash : {}
     this.uniqueHash = parent ? parent.uniqueHash : {}
     this.parentBase = (this.parent && this.parent.base && this.parent.base + ' ') || ''
@@ -20,21 +44,21 @@ class Command {
     return undefined
   }
 
-  async use (command, ctx = {}, op = true) {
+  async use (command, ctx: Ctx<false> = {}, op = true) {
     const resultsFound = this.find(command)
     let parsedResponse
-    if (resultsFound) {
+    if (resultsFound != null) {
       const wantedCommand = resultsFound[0]
       const passedArgs = resultsFound[1]
-      if (wantedCommand.params.onlyConsole && ctx.player) return 'This command is console only'
-      if (wantedCommand.params.onlyPlayer && !ctx.player) throw new UserError('This command is player only')
+      if (wantedCommand.params.onlyConsole && (ctx.player != null)) return 'This command is console only'
+      if (wantedCommand.params.onlyPlayer && (ctx.player == null)) throw new UserError('This command is player only')
       if (wantedCommand.params.op && !op) return 'You do not have permission to use this command'
       const customArgsParser = wantedCommand.params.parse
       if (customArgsParser) {
         if (typeof customArgsParser === 'function') {
           parsedResponse = customArgsParser(passedArgs, ctx)
           if (parsedResponse === false) {
-            if (ctx.player) return wantedCommand.params.usage ? 'Usage: ' + wantedCommand.params.usage : 'Bad syntax'
+            if (ctx.player != null) return wantedCommand.params.usage ? 'Usage: ' + wantedCommand.params.usage : 'Bad syntax'
             else throw new UserError(wantedCommand.params.usage ? 'Usage: ' + wantedCommand.params.usage : 'Bad syntax')
           }
         } else {
@@ -46,7 +70,7 @@ class Command {
       else output = await wantedCommand.params.action(resultsFound[1], ctx) // just give back the passed arg
       if (output) return '' + output
     } else {
-      if (ctx.player) return 'Command not found'
+      if (ctx.player != null) return 'Command not found'
       else throw new UserError('Command not found')
     }
   }
@@ -56,7 +80,7 @@ class Command {
 
     const list = [this.base]
     if (this.params.aliases && this.params.aliases.length) {
-      this.params.aliases.forEach(al => list.unshift(this.parentBase + al))
+      this.params.aliases.forEach(al => list.unshift(this.parentBase + al.replace(/^\//, '')))
     }
 
     list.forEach((command) => {
@@ -69,11 +93,11 @@ class Command {
     this.uniqueHash[this.base] = this
   }
 
-  add (params) {
+  add <T, P extends boolean>(params: AddParams<T, P>) {
     return new Command(params, this)
   }
 
-  space (end) {
+  space (end = false) {
     const first = !(this.parent && this.parent.parent)
     return this.params.merged || (!end && first) ? '' : ' '
   }
@@ -83,9 +107,10 @@ class Command {
   }
 
   tab (command, i) {
+    // @ts-expect-error
     if (this.find(command)[0].params.tab) return this.find(command)[0].params.tab[i]
     return 'player'
   }
 }
 
-module.exports = Command
+export default Command