refactor: replace [email protected] node imports with node: built-ins

Author: Jobians

deno/mod.js.bak

@@ -0,0 +1,2 @@
+// @deno-types="./types/index.d.ts"
+export { default } from './src/index.js'

deno/polyfills.js

@@ -1,7 +1,7 @@
 /* global Deno */
 
-import { Buffer } from 'https://deno.land/[email protected]/node/buffer.ts'
-import { isIP } from 'https://deno.land/[email protected]/node/net.ts'
+import { Buffer } from 'node:buffer'
+import { isIP } from 'node:net'
 
 const events = () => ({ data: [], error: [], drain: [], connect: [], secureConnect: [], close: [] })
 

deno/polyfills.js.bak

@@ -0,0 +1,189 @@
+/* global Deno */
+
+import { Buffer } from 'https://deno.land/[email protected]/node/buffer.ts'
+import { isIP } from 'https://deno.land/[email protected]/node/net.ts'
+
+const events = () => ({ data: [], error: [], drain: [], connect: [], secureConnect: [], close: [] })
+
+class Socket {
+  constructor() {
+    return createSocket()
+  }
+}
+
+function createSocket() {
+  let paused
+    , resume
+    , keepAlive
+
+  const socket = {
+    error,
+    success,
+    readyState: 'open',
+    setKeepAlive: x => {
+      keepAlive = x
+      socket.raw && socket.raw.setKeepAlive && socket.raw.setKeepAlive(x)
+    },
+    connect: (port, hostname) => {
+      socket.raw = null
+      socket.readyState = 'connecting'
+      typeof port === 'string'
+        ? Deno.connect({ transport: 'unix', path: socket.path = port }).then(success, error)
+        : Deno.connect({ transport: 'tcp', port: socket.port = port, hostname: socket.hostname = hostname || 'localhost' }).then(success, error) // eslint-disable-line
+      return socket
+    },
+    pause: () => {
+      paused = new Promise(r => resume = r)
+    },
+    resume: () => {
+      resume && resume()
+      paused = null
+    },
+    isPaused: () => !!paused,
+    removeAllListeners: () => socket.events = events(),
+    events: events(),
+    raw: null,
+    on: (x, fn) => socket.events[x].push(fn),
+    once: (x, fn) => {
+      if (x === 'data')
+        socket.break = true
+      const e = socket.events[x]
+      e.push(once)
+      once.once = fn
+      function once(...args) {
+        fn(...args)
+        e.indexOf(once) > -1 && e.splice(e.indexOf(once), 1)
+      }
+    },
+    removeListener: (x, fn) => {
+      socket.events[x] = socket.events[x].filter(x => x !== fn && x.once !== fn)
+    },
+    write: (x, cb) => {
+      socket.raw.write(x).then(l => {
+        l < x.length
+          ? socket.write(x.slice(l), cb)
+          : (cb && cb(null))
+      }).catch(err => {
+        cb && cb()
+        call(socket.events.error, err)
+      })
+      return false
+    },
+    destroy: () => close(),
+    end: (x) => {
+      x && socket.write(x)
+      close()
+    }
+  }
+
+  return socket
+
+  async function success(raw) {
+    if (socket.readyState !== 'connecting')
+      return raw.close()
+
+    const encrypted = socket.encrypted
+    socket.raw = raw
+    keepAlive != null && raw.setKeepAlive && raw.setKeepAlive(keepAlive)
+    socket.readyState = 'open'
+    socket.encrypted
+      ? call(socket.events.secureConnect)
+      : call(socket.events.connect)
+
+    const b = new Uint8Array(1024)
+    let result
+
+    try {
+      while ((result = socket.readyState === 'open' && await raw.read(b))) {
+        call(socket.events.data, Buffer.from(b.subarray(0, result)))
+        if (!encrypted && socket.break && (socket.break = false, b[0] === 83))
+          return socket.break = false
+        paused && await paused
+      }
+    } catch (e) {
+      if (e instanceof Deno.errors.BadResource === false)
+        error(e)
+    }
+
+    if (!socket.encrypted || encrypted)
+      closed()
+  }
+
+  function close() {
+    try {
+      socket.raw && socket.raw.close()
+    } catch (e) {
+      if (e instanceof Deno.errors.BadResource === false)
+        call(socket.events.error, e)
+    }
+  }
+
+  function closed() {
+    if (socket.readyState === 'closed')
+      return
+
+    socket.break = socket.encrypted = false
+    socket.readyState = 'closed'
+    call(socket.events.close)
+  }
+
+  function error(err) {
+    call(socket.events.error, err)
+    socket.raw
+      ? close()
+      : closed()
+  }
+
+  function call(xs, x) {
+    xs.slice().forEach(fn => fn(x))
+  }
+}
+
+export const net = {
+  isIP,
+  createServer() {
+    const server =  {
+      address() {
+        return { port: 9876 }
+      },
+      async listen() {
+        server.raw = Deno.listen({ port: 9876, transport: 'tcp' })
+        for await (const conn of server.raw)
+          setTimeout(() => conn.close(), 500)
+      },
+      close() {
+        server.raw.close()
+      }
+    }
+    return server
+  },
+  Socket
+}
+
+export const tls = {
+  connect({ socket, ...options }) {
+    socket.encrypted = true
+    socket.readyState = 'connecting'
+    Deno.startTls(socket.raw, { hostname: socket.hostname, ...options })
+      .then(socket.success, socket.error)
+    socket.raw = null
+    return socket
+  }
+}
+
+let ids = 1
+const tasks = new Set()
+export const setImmediate = fn => {
+  const id = ids++
+  tasks.add(id)
+  queueMicrotask(() => {
+    if (tasks.has(id)) {
+      fn()
+      tasks.delete(id)
+    }
+  })
+  return id
+}
+
+export const clearImmediate = id => tasks.delete(id)
+

deno/src/bytes.js

@@ -1,4 +1,4 @@
-import { Buffer } from 'https://deno.land/[email protected]/node/buffer.ts'
+import { Buffer } from 'node:buffer'
 const size = 256
 let buffer = Buffer.allocUnsafe(size)
 

deno/src/bytes.js.bak

@@ -0,0 +1,79 @@
+import { Buffer } from 'https://deno.land/[email protected]/node/buffer.ts'
+const size = 256
+let buffer = Buffer.allocUnsafe(size)
+
+const messages = 'BCcDdEFfHPpQSX'.split('').reduce((acc, x) => {
+  const v = x.charCodeAt(0)
+  acc[x] = () => {
+    buffer[0] = v
+    b.i = 5
+    return b
+  }
+  return acc
+}, {})
+
+const b = Object.assign(reset, messages, {
+  N: String.fromCharCode(0),
+  i: 0,
+  inc(x) {
+    b.i += x
+    return b
+  },
+  str(x) {
+    const length = Buffer.byteLength(x)
+    fit(length)
+    b.i += buffer.write(x, b.i, length, 'utf8')
+    return b
+  },
+  i16(x) {
+    fit(2)
+    buffer.writeUInt16BE(x, b.i)
+    b.i += 2
+    return b
+  },
+  i32(x, i) {
+    if (i || i === 0) {
+      buffer.writeUInt32BE(x, i)
+      return b
+    }
+    fit(4)
+    buffer.writeUInt32BE(x, b.i)
+    b.i += 4
+    return b
+  },
+  z(x) {
+    fit(x)
+    buffer.fill(0, b.i, b.i + x)
+    b.i += x
+    return b
+  },
+  raw(x) {
+    buffer = Buffer.concat([buffer.subarray(0, b.i), x])
+    b.i = buffer.length
+    return b
+  },
+  end(at = 1) {
+    buffer.writeUInt32BE(b.i - at, at)
+    const out = buffer.subarray(0, b.i)
+    b.i = 0
+    buffer = Buffer.allocUnsafe(size)
+    return out
+  }
+})
+
+export default b
+
+function fit(x) {
+  if (buffer.length - b.i < x) {
+    const prev = buffer
+        , length = prev.length
+
+    buffer = Buffer.allocUnsafe(length + (length >> 1) + x)
+    prev.copy(buffer)
+  }
+}
+
+function reset() {
+  b.i = 0
+  return b
+}

deno/src/connection.js

@@ -1,10 +1,10 @@
 import { HmacSha256 } from 'https://deno.land/[email protected]/hash/sha256.ts'
-import { Buffer } from 'https://deno.land/[email protected]/node/buffer.ts'
+import { Buffer } from 'node:buffer'
 import { setImmediate, clearImmediate } from '../polyfills.js'
 import { net } from '../polyfills.js'
 import { tls } from '../polyfills.js'
-import crypto from 'https://deno.land/[email protected]/node/crypto.ts'
-import Stream from 'https://deno.land/[email protected]/node/stream.ts'
+import crypto from 'node:crypto'
+import Stream from 'node:stream'
 
 
 import { stringify, handleValue, arrayParser, arraySerializer } from './types.js'