ranuts 0.1.0-alpha → 0.1.0-alpha.1

package/src/server/paresUrl.ts

@@ -0,0 +1,40 @@
+import type { IncomingMessage } from 'node:http'
+
+interface ParseUrl {
+  search?: string
+  query?: string
+  pathname?: string
+  path?: string
+  href?: string
+  _raw?: string
+}
+interface Req extends IncomingMessage {
+  _parsedUrl?: ParseUrl
+}
+/**
+ * @description: 解析 IncomingMessage 类型的请求url，返回的类型永远是 ParseUrl
+ * @param {Req} req
+ * @return {ParseUrl}
+ */
+export default function (req: Req): ParseUrl | undefined {
+  const url = req.url
+  if (url === void 0) return
+
+  let obj = req._parsedUrl
+  if (obj && obj._raw === url) return obj
+
+  obj = {}
+  obj.query = obj.search = undefined
+  obj.href = obj.path = obj.pathname = url
+
+  const idx = url.indexOf('?', 1)
+  if (idx !== -1) {
+    obj.search = url.substring(idx)
+    obj.query = obj.search.substring(1)
+    obj.pathname = url.substring(0, idx)
+  }
+
+  obj._raw = url
+
+  return (req._parsedUrl = obj)
+}

package/src/server/send.ts

@@ -0,0 +1,89 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import type { IncomingMessage, ServerResponse } from 'node:http'
+import type { MiddlewareFunction, Next } from '@/server/server'
+import { queryMime, setMime } from '@/node/http/mimeType'
+
+interface Option {
+  pathname: string
+  fileTypes: Record<string, string>
+}
+const staticMiddleware = (option: Partial<Option> = {}): MiddlewareFunction => {
+  const { pathname, fileTypes = {} } = option
+  return async (
+    req: IncomingMessage,
+    res: ServerResponse,
+    next: Next,
+  ): Promise<void> => {
+    try {
+      if (req.url) {
+        const htmlContentType = 'text/html'
+        // 获取传入的地址，如果没有，取当前的目录
+        const dirPath = pathname ? pathname : process.cwd()
+        // 静态资源文件根路径
+        const root = path.normalize(path.resolve(dirPath))
+        // 获取访问的文件类型
+        const extension = path.extname(req.url).slice(1)
+        // 增加mimeType
+        Object.keys(fileTypes).forEach((key) =>
+        setMime(key, fileTypes[key]),
+        )
+        // 文件类型后缀
+        const type = extension ? queryMime(extension) : htmlContentType
+        // 是否支持的文件类型
+        const supportedExtension = Boolean(type)
+        // 如果这个文件类型不允许访问，则直接返回404
+        if (!supportedExtension) {
+          res.writeHead(404, { 'Content-Type': 'text/html' })
+          res.end('404: File not found')
+          return
+        }
+
+        // 通过url获取访问的文件名称
+        let fileName = req.url
+        // 如果访问的路径是 /
+        if (req.url === '/') {
+          // 则文件名是 index.html
+          fileName = 'index.html'
+          // 如果访问的文件类型不在允许的类型里面，默认返回index.html
+        } else if (!extension) {
+          try {
+            // 检测文件是否允许访问
+            fs.accessSync(path.join(root, req.url + '.html'), fs.constants.F_OK)
+            // 当允许访问时，则返回对应的页面
+            fileName = req.url + '.html'
+          } catch (e) {
+            // 否则直接返回 index.html
+            fileName = path.join(req.url, 'index.html')
+          }
+        }
+        // 有文件名且访问的文件类型也允许访问
+        const filePath = path.join(root, fileName)
+        const isPathUnderRoot = path
+          .normalize(path.resolve(filePath))
+          .startsWith(root)
+
+        if (!isPathUnderRoot) {
+          res.writeHead(404, { 'Content-Type': 'text/html' })
+          res.end('404: File not found')
+          return
+        }
+
+        fs.readFile(filePath, (err, data) => {
+          if (err) {
+            res.writeHead(404, { 'Content-Type': 'text/html' })
+            res.end('404: File not found')
+          } else {
+            res.writeHead(200, { 'Content-Type': type })
+            res.end(data)
+          }
+        })
+      } else {
+        console.log('request has not url')
+      }
+      await next()
+    } catch (error) {}
+  }
+}
+
+export default staticMiddleware

package/src/server/server.ts

@@ -0,0 +1,67 @@
+import type { IncomingMessage, ServerResponse } from 'node:http'
+import http from 'node:http'
+
+export type Next = () => Promise<never> | Promise<void>
+
+export type MiddlewareFunction = (
+  req: IncomingMessage,
+  res: ServerResponse,
+  next: Next,
+) => void | Promise<void>
+
+class Server {
+  stack: Array<MiddlewareFunction>
+  constructor() {
+    this.stack = []
+    /**
+     * @description: 添加中间件
+     */
+  }
+  use(handle: MiddlewareFunction): void {
+    if (!handle) {
+      throw new Error('the use function has an incorrect argument')
+    }
+    this.stack.push(handle)
+  }
+  listen(
+    ...args: any
+  ): http.Server<typeof IncomingMessage, typeof ServerResponse> {
+    const fn = compose(this.stack)
+    const server = http.createServer((req, res) => {
+      fn(req, res).then().catch(onerror)
+    })
+    return server.listen(...args)
+  }
+}
+
+function onerror(err: Error) {
+  console.error(err.stack || err.toString())
+}
+
+function compose(middleware: Array<MiddlewareFunction>) {
+  if (!Array.isArray(middleware))
+    throw new TypeError('Middleware stack must be an array!')
+  for (const fn of middleware) {
+    if (typeof fn !== 'function')
+      throw new TypeError('Middleware must be composed of functions!')
+  }
+  return function (req: IncomingMessage, res: ServerResponse, next?: Next) {
+    let index = -1
+    function dispatch(i: number): Promise<never> | Promise<void> {
+      if (i <= index)
+        return Promise.reject(new Error('next() called multiple times'))
+      index = i
+      let fn = middleware[i]
+      if (i === middleware.length && next) fn = next
+      if (!fn) return Promise.resolve()
+      try {
+        return Promise.resolve(fn(req, res, dispatch.bind(null, i + 1)))
+      } catch (err) {
+        return Promise.reject(err)
+      }
+    }
+    return dispatch(0)
+  }
+}
+
+export default Server

package/src/server/status.ts

@@ -0,0 +1,191 @@
+// code map message
+const codes = new Map([
+  [100, 'Continue'],
+  [101, 'Switching Protocols'],
+  [102, 'Processing'],
+  [103, 'Early Hints'],
+  [200, 'OK'],
+  [201, 'Created'],
+  [202, 'Accepted'],
+  [203, 'Non-Authoritative Information'],
+  [204, 'No Content'],
+  [205, 'Reset Content'],
+  [206, 'Partial Content'],
+  [207, 'Multi-Status'],
+  [208, 'Already Reported'],
+  [226, 'IM Used'],
+  [300, 'Multiple Choices'],
+  [301, 'Moved Permanently'],
+  [302, 'Found'],
+  [303, 'See Other'],
+  [304, 'Not Modified'],
+  [305, 'Use Proxy'],
+  [307, 'Temporary Redirect'],
+  [308, 'Permanent Redirect'],
+  [400, 'Bad Request'],
+  [401, 'Unauthorized'],
+  [402, 'Payment Required'],
+  [403, 'Forbidden'],
+  [404, 'Not Found'],
+  [405, 'Method Not Allowed'],
+  [406, 'Not Acceptable'],
+  [407, 'Proxy Authentication Required'],
+  [408, 'Request Timeout'],
+  [409, 'Conflict'],
+  [410, 'Gone'],
+  [411, 'Length Required'],
+  [412, 'Precondition Failed'],
+  [413, 'Payload Too Large'],
+  [414, 'URI Too Long'],
+  [415, 'Unsupported Media Type'],
+  [416, 'Range Not Satisfiable'],
+  [417, 'Expectation Failed'],
+  [418, "I'm a Teapot"],
+  [421, 'Misdirected Request'],
+  [422, 'Unprocessable Entity'],
+  [423, 'Locked'],
+  [424, 'Failed Dependency'],
+  [425, 'Too Early'],
+  [426, 'Upgrade Required'],
+  [428, 'Precondition Required'],
+  [429, 'Too Many Requests'],
+  [431, 'Request Header Fields Too Large'],
+  [451, 'Unavailable For Legal Reasons'],
+  [500, 'Internal Server Error'],
+  [501, 'Not Implemented'],
+  [502, 'Bad Gateway'],
+  [503, 'Service Unavailable'],
+  [504, 'Gateway Timeout'],
+  [505, 'HTTP Version Not Supported'],
+  [506, 'Variant Also Negotiates'],
+  [507, 'Insufficient Storage'],
+  [508, 'Loop Detected'],
+  [509, 'Bandwidth Limit Exceeded'],
+  [510, 'Not Extended'],
+  [511, 'Network Authentication Required'],
+])
+
+const status = {
+  // status code to message map
+  message: codes,
+  // status message (lower-case) to code map
+  code: createMessageToStatusCodeMap(codes),
+  // array of status codes
+  codes: createStatusCodeList(codes),
+  // status codes for redirects
+  redirect: {
+    300: true,
+    301: true,
+    302: true,
+    303: true,
+    305: true,
+    307: true,
+    308: true,
+  },
+  // status codes for empty bodies
+  empty: {
+    204: true,
+    205: true,
+    304: true,
+  },
+  // status codes for when you should retry the request
+  retry: {
+    502: true,
+    503: true,
+    504: true,
+  },
+}
+
+/**
+ * @private
+ * @description: Create a map of message to status code.
+ * @param {Record} codes
+ * @param {*} string
+ * @return {Record<string, number>}
+ */
+function createMessageToStatusCodeMap(codes: Map<number, string>) {
+  const map: Map<string, number> = new Map()
+  for (const [status, message] of codes) {
+    map.set(message.toLowerCase(), status)
+  }
+  return map
+}
+
+/**
+ * Create a list of all status codes.
+ * @private
+ */
+
+function createStatusCodeList(codes: Map<number, string>) {
+  const codeList: Array<number> = []
+  for (const [status, _] of codes) {
+    codeList.push(status)
+  }
+  return codeList
+}
+
+/**
+ * Get the status code for given message.
+ * @private
+ */
+
+function getStatusCode(message: string) {
+  const msg = message.toLowerCase()
+  status.code.has(msg)
+  if (!status.code.has(msg)) {
+    throw new Error('invalid status message: "' + message + '"')
+  }
+
+  return status.code.get(msg)
+}
+
+/**
+ * Get the status message for given code.
+ * @private
+ */
+
+function getStatusMessage(code: number) {
+  if (!status.message.has(code)) {
+    throw new Error('invalid status code: ' + code)
+  }
+
+  return status.message.get(code)
+}
+
+/**
+ * Get the status code.
+ *
+ * Given a number, this will throw if it is not a known status
+ * code, otherwise the code will be returned. Given a string,
+ * the string will be parsed for a number and return the code
+ * if valid, otherwise will lookup the code assuming this is
+ * the status message.
+ *
+ * @param {string|number} code
+ * @returns {number}
+ * @public
+ */
+
+function getStatus(code?: number | string): number | string | undefined {
+  if (typeof code === 'number') {
+    // return message
+    return getStatusMessage(code)
+  }
+
+  if (typeof code !== 'string') {
+    throw new TypeError('code must be a number or string')
+  }
+
+  // '403'
+  const n = parseInt(code, 10)
+  if (!isNaN(n) && status.codes.includes(n)) {
+    // return message
+    return getStatusMessage(n)
+  }
+  // return code
+  return getStatusCode(code)
+}
+
+export default status
+
+export { getStatus }

package/src/server/traverse.ts

@@ -0,0 +1,54 @@
+import { join, resolve } from 'node:path'
+import type { Stats } from 'node:fs'
+import { readdir, readdirSync, stat, statSync } from 'node:fs'
+import { promisify } from 'node:util'
+
+const toStats = promisify(stat)
+const toRead = promisify(readdir)
+
+type Caller = (relPath: string, absPath: string, stats: Stats) => any
+/**
+ * @description: 递归遍历每一个目录，为找到的文件都执行一个函数
+ * @param {string} dir
+ * @param {Caller} callback
+ * @param {*} pre
+ */
+export async function traverse(
+  dir: string,
+  callback: Caller,
+  pre = '',
+): Promise<any> {
+  dir = resolve('.', dir)
+  await toRead(dir).then((arr) => {
+    return Promise.all(
+      arr.map((str) => {
+        const abs = join(dir, str)
+        return toStats(abs).then((stats) => {
+          return stats.isDirectory()
+            ? traverse(abs, callback, join(pre, str))
+            : callback(join(pre, str), abs, stats)
+        })
+      }),
+    )
+  })
+}
+/**
+ * @description: 同步方法，递归遍历每一个目录，为找到的文件都执行一个函数
+ * @param {string} dir
+ * @param {Caller} callback
+ * @param {*} pre
+ */
+export function traverseSync(dir: string, callback: Caller, pre = ''): void {
+  dir = resolve('.', dir)
+  const arr = readdirSync(dir)
+  let i = 0,
+    abs,
+    stats
+  for (; i < arr.length; i++) {
+    abs = join(dir, arr[i])
+    stats = statSync(abs)
+    stats.isDirectory()
+      ? traverseSync(abs, callback, join(pre, arr[i]))
+      : callback(join(pre, arr[i]), abs, stats)
+  }
+}

package/src/server/websocket.ts

@@ -0,0 +1,200 @@
+import http from 'node:http'
+import crypto from 'node:crypto'
+import type internal from 'node:stream'
+import EventEmitter from '@/designMode/EventEmitter'
+
+interface FrameMeta {
+    fin: boolean;
+    opcode: number;
+    mask: boolean;
+    maskKey: Buffer | null;
+    payloadSize: number;
+    size: number;
+    metaSize: number;
+}
+
+const sixteenBitsMax = 65535 // 65536 is the max of 16 bits
+
+const opcodeMap = {
+    text: 129  // 129 = 10000001, opcode = 0x1  
+}
+
+export class Client extends EventEmitter {
+    socket: internal.Duplex
+    connectTime: number;
+    constructor(socket: internal.Duplex) {
+        super()
+        this.socket = socket
+        this.connectTime = Date.now()
+    }
+    createFrame(content: string, options?: { opcode: number; }):Buffer {
+        const size = Buffer.byteLength(content); 
+        let buf
+        if (size > sixteenBitsMax) { 
+            buf = Buffer.alloc(10 + size);
+            buf[1] = 127;
+            buf.writeUInt32BE(size, 6);
+            buf.write(content, 10);
+        } else if (size > 125) {
+            buf = Buffer.alloc(4 + size);
+            buf[1] = 126; 
+            buf.writeUInt16BE(size, 2);
+            buf.write(content, 4);
+        } else {
+            buf = Buffer.alloc(2 + size);
+            buf[1] = size; 
+            buf.write(content, 2);
+        }
+        if (options) {
+            const { opcode } = options;
+            if (opcode && opcode < 15 && opcode >= 0) buf[0] = 128 | opcode; 
+        }
+        else buf[0] = opcodeMap.text
+        return buf;
+    }
+    send(data: string, options?: { opcode: number; }):void {
+        this.socket.write(this.createFrame(data, options));
+    }
+    ping():void {
+        this.socket.write(this.createFrame("", { opcode: 9 }));
+    }
+    pong():void {
+        this.socket.write(this.createFrame("", { opcode: 10 }));
+    }
+    close():void {
+        this.socket.write(this.createFrame("", { opcode: 8 }));
+        this.socket.destroy();
+        this.emit("close");
+    }
+}
+
+class WebSocket extends EventEmitter {
+    server: http.Server<typeof http.IncomingMessage, typeof http.ServerResponse>;
+    clients: Array<Client>
+    constructor({ port = 30104 }: { port: number }) {
+        super()
+        this.server = http.createServer();
+        this.server.listen(port);
+        this.clients = []
+        this.server.on("upgrade", (req, socket) => this.create(req, socket))
+    }
+    /**
+     * @description: 向所有 client 广播
+     * @param {string} data
+     */    
+    broadcast(data: string): void {
+        this.clients.forEach((client) => client.send(data));
+    }
+    /**
+     * @description: 创建client
+     * @param {http} req
+     * @param {internal} socket
+     */    
+    create(req: http.IncomingMessage, socket: internal.Duplex): void {
+        socket.write([
+            "HTTP/1.1 101 Switching Protocols",
+            "Upgrade: websocket",
+            "Connection: Upgrade",
+            "Sec-WebSocket-Accept: " + crypto.createHash("sha1").update(req.headers['sec-websocket-key'] + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11").digest("base64")
+        ].join("\n") + "\n\n");
+        const client = new Client(socket)
+        this.addListenCloseClient(client)
+        this.clients.push(client);
+        this.emit("connect", client);
+
+        let buf = Buffer.allocUnsafe(0); 
+        let data = Buffer.allocUnsafe(0); 
+        /**
+         * @description: 处理帧meta
+         * @param {FrameMeta} meta
+         */        
+        const handleFrameMeta = (meta: FrameMeta) => {
+            const metaLength = meta.metaSize
+            buf.subarray(0, metaLength)
+            buf = buf.subarray(metaLength); 
+            return buf
+        }
+        /**
+         * @description: 处理帧内容
+         * @param {FrameMeta} meta
+         */        
+        const handleFrameContent = (meta: FrameMeta) => {
+            const size = meta.size
+            const buffer = buf.subarray(0, size)
+            data = Buffer.concat([data, this.iMask(buffer, meta.maskKey)]); 
+            if (meta.fin) { 
+                if (meta.opcode === 8) return client.close();
+                if (meta.opcode === 9) return client.pong();
+                client.emit("data", data); 
+                data = Buffer.allocUnsafe(0);
+            }
+            buf = buf.subarray(size);
+        }
+        socket.on("data", (chunk) => { 
+            buf = Buffer.concat([buf, chunk]); 
+            const meta = this.parseFrameMeta(buf);
+            handleFrameMeta(meta)
+            handleFrameContent(meta)
+        });
+
+        socket.on("end", () => {
+            client.close();
+        });
+
+        socket.on("error", (err) => {
+            client.emit("error", err);
+            client.close();
+        });
+    }
+    /**
+     * @description: 增加 client 监听关闭事件
+     * @param {Client} client
+     */    
+    addListenCloseClient(client: Client): void {
+        client.on('close', () => {
+            const index = this.clients.indexOf(client);
+            if (index === -1) return false;
+            this.clients.splice(index, 1);
+        })
+    }
+    /**
+     * @description: 解析帧meta
+     * @param {Buffer} source
+     * @return {FrameMeta}
+     */    
+    parseFrameMeta(source: Buffer): FrameMeta {
+        const src = Buffer.from(source);
+        const payloadSize = src[1] & 127;
+        let size = 0; 
+        let metaSize = 0; 
+        const masked = src[1] >= 128;
+        if (payloadSize === 127) {
+            size = src.readUInt32BE(6);
+            metaSize = 10;
+        } else if (payloadSize === 126) {
+            size = src.readUInt16BE(2);
+            metaSize = 4;
+        } else {
+            size = payloadSize;
+            metaSize = 2;
+        }
+        return {
+            fin: src[0] >= 128,
+            opcode: src[0] & 15,
+            mask: masked,
+            maskKey: masked ? src.subarray(metaSize, metaSize + (masked ? 4 : 0)) : null,
+            payloadSize,
+            size,
+            metaSize: metaSize + (masked ? 4 : 0)
+        };
+    }
+    iMask(data: Buffer, key: Buffer | null): Buffer {
+        if (!key) return data;
+        const buffer = Buffer.from(data);
+        for (let i = 0; i < buffer.length; ++i) buffer[i] = buffer[i] ^ key[i % 4];
+        return buffer;
+    }
+}
+
+
+export default WebSocket

package/src/sort/bubble.ts

@@ -0,0 +1,21 @@
+/**
+ * @description: 冒泡排序，两两比较，交换位置，遍历n^2
+ * @param {Array} list
+ * @return {Array}
+ */
+const bubble = (list: Array<number>): Array<number> => {
+  const length = list.length
+  for (let i = 0; i < length; i++) {
+    for (let j = 0; j < length; j++) {
+      let temp
+      if (list[j] > list[i]) {
+        temp = list[j]
+        list[j] = list[i]
+        list[i] = temp
+      }
+    }
+  }
+  return list
+}
+
+export default bubble

package/src/sort/bucket.ts

@@ -0,0 +1,11 @@
+/**
+ * @description: 桶排序
+ * @param {Array<number>} list
+ * @return {Array<number>} 
+ */
+const bucket = (list: Array<number>): Array<number> => {
+    return list
+}
+
+export default bucket
+  

package/src/sort/count.ts

@@ -0,0 +1,10 @@
+/**
+ * @description: 计数排序
+ * @param {Array<number>} list
+ * @return {Array<number>} 
+ */
+const count = (list: Array<number>): Array<number> => {
+  return list
+}
+
+export default count

package/src/sort/heap.ts

@@ -0,0 +1,10 @@
+/**
+ * @description: 堆排序
+ * @param {Array} list
+ * @return {Array}
+ */
+const heap = (list: Array<string>): Array<string> => {
+  return list
+}
+
+export default heap