ranuts 0.1.0-alpha → 0.1.0-alpha-21

package/dist/src/ml/ocr.d.ts

@@ -0,0 +1,11 @@
+import type { BaseReturn } from '@/utils/bom';
+interface Options {
+    images: string[];
+    language: string;
+    langPath?: string;
+}
+interface OcrReturn extends BaseReturn {
+    data: null | Tesseract.RecognizeResult[];
+}
+export declare const ocr: ({ images, language, langPath }: Options) => Promise<OcrReturn>;
+export {};

package/dist/src/node/appendFile.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @description: 给一个已经存在的文件追加内容
+ * @param {string} path 文件路径
+ * @param {string} content 新加的内容
+ * @return {Promise}
+ */
+export declare const appendFile: (path: string, content: string) => Promise<Ranuts.Identification>;

package/dist/src/node/body.d.ts

@@ -0,0 +1,9 @@
+import type { MiddlewareFunction } from '@/node/server';
+interface ServerBody {
+    uploadDir: string;
+    encoding: BufferEncoding;
+    urlencoded: boolean;
+    json: boolean;
+}
+declare const bodyMiddleware: (options?: Partial<ServerBody>) => MiddlewareFunction;
+export default bodyMiddleware;

package/dist/src/node/color.d.ts

@@ -0,0 +1,7 @@
+declare const _default: Record<string, (input: string) => string | StringConstructor> & {
+    isColorSupported: boolean;
+    reset: (s: string) => string;
+    bold: (input: string) => string;
+    dim: (input: string) => string;
+};
+export default _default;

package/dist/src/node/command.d.ts

@@ -0,0 +1,8 @@
+export declare const runCommand: (command: string, args: string[]) => Promise<void>;
+interface PromptOption {
+    message: string;
+    defaultResponse: string;
+    stream: NodeJS.ReadWriteStream;
+}
+export declare const prompt: ({ message, stream, defaultResponse }: PromptOption) => Promise<boolean>;
+export {};

package/dist/src/node/ctx2req.d.ts

@@ -0,0 +1,5 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import type { MiddlewareFunction } from '@/node/server';
+type ConnectMiddleware = (req: IncomingMessage, res: ServerResponse, next?: Function) => void;
+declare function connect(connectMiddleware: ConnectMiddleware): MiddlewareFunction;
+export default connect;

package/dist/src/node/fileInfo.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @description: 查询一个文件的详细信息，一般用于区分文件还是目录（data.isDirectory()）
+ * @param {string} path 文件路径
+ * @return {Promise}
+ */
+declare const queryFileInfo: (path: string) => Promise<Ranuts.Identification>;
+export default queryFileInfo;

package/dist/src/node/fs.d.ts

@@ -0,0 +1,7 @@
+import fs from 'node:fs';
+import type { Noop } from '@/utils/noop';
+export type FilePromiseResult = Promise<Ranuts.Identification> & {
+    abort?: Noop;
+};
+export type Error = NodeJS.ErrnoException | null;
+export default fs;

package/dist/src/node/get.d.ts

@@ -0,0 +1,10 @@
+interface Request {
+    url: string;
+}
+interface Response {
+    success: boolean;
+    data: unknown;
+    message: string;
+}
+declare const get: ({ url }: Request) => Promise<Response>;
+export default get;

package/dist/src/node/getIPAdress.d.ts

@@ -0,0 +1 @@
+export declare const getIPAdress: () => string | undefined;

package/dist/src/node/index.d.ts

@@ -0,0 +1,25 @@
+import Server from './server';
+import { appendFile } from './appendFile';
+import colors from './color';
+import body from './body';
+import { prompt, runCommand } from './command';
+import connect from './ctx2req';
+import queryFileInfo from './fileInfo';
+import get from './get';
+import { getIPAdress } from './getIPAdress';
+import isColorSupported from './isColorSupported';
+import paresUrl from './paresUrl';
+import readDir from './readDir';
+import readFile from './readFile';
+import Router from './router';
+import staticMiddleware from './send';
+import startTask from './startTask';
+import { readStream, writeStream } from './stream';
+import taskEnd from './taskEnd';
+import { traverse, traverseSync } from './traverse';
+import watchFile from './watchFile';
+import WSS from './ws';
+import writeFile from './writeFile';
+import type { Context } from './server';
+export { appendFile, colors, body, prompt, runCommand, connect, queryFileInfo, get, getIPAdress, isColorSupported, paresUrl, readDir, Router, readFile, staticMiddleware, Server, startTask, readStream, writeStream, taskEnd, traverse, traverseSync, watchFile, WSS, writeFile, };
+export type { Context };

package/dist/src/node/index.js

@@ -0,0 +1,54 @@
+import { R, S, W, a, b, c, d, g, e, i, p, f, q, r, h, j, k, s, l, t, m, n, w, o } from "../../ws-D7Jt2dzL.js";
+import fs from "node:fs";
+const writeFile = (path, content) => new Promise((resolve, reject) => {
+  fs.writeFile(
+    path,
+    content,
+    {
+      mode: 438,
+      // 可读可写666，转化为十进制就是438
+      flag: "w+",
+      // r+并不会清空再写入，w+会清空再写入
+      encoding: "utf-8"
+    },
+    (err) => {
+      if (err) {
+        reject({ success: false, _identification: false, data: err });
+        throw err;
+      } else {
+        resolve({
+          success: true,
+          _identification: false,
+          data: { path, content }
+        });
+      }
+    }
+  );
+});
+export {
+  R as Router,
+  S as Server,
+  W as WSS,
+  a as appendFile,
+  b as body,
+  c as colors,
+  d as connect,
+  g as get,
+  e as getIPAdress,
+  i as isColorSupported,
+  p as paresUrl,
+  f as prompt,
+  q as queryFileInfo,
+  r as readDir,
+  h as readFile,
+  j as readStream,
+  k as runCommand,
+  s as startTask,
+  l as staticMiddleware,
+  t as taskEnd,
+  m as traverse,
+  n as traverseSync,
+  w as watchFile,
+  writeFile,
+  o as writeStream
+};

package/dist/src/node/isColorSupported.d.ts

@@ -0,0 +1,2 @@
+declare const isColorSupported: boolean;
+export default isColorSupported;

package/dist/src/node/paresUrl.d.ts

@@ -0,0 +1,19 @@
+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;
+export {};

package/dist/src/node/readDir.d.ts

@@ -0,0 +1,6 @@
+interface Options {
+    dirPath: string;
+    ignores?: Array<string>;
+}
+declare const readDir: (options: Options) => Array<string>;
+export default readDir;

package/dist/src/node/readFile.d.ts

@@ -0,0 +1,9 @@
+import type { FilePromiseResult } from '@/node/fs';
+/**
+ * @description: 读取一个文件，读取成功返回状态码和文件内容
+ * @param {string} path 文件路径
+ * @param {string} format 读取格式，默认utf-8
+ * @return {Promise}
+ */
+declare const readFile: (path: string, format?: BufferEncoding) => FilePromiseResult;
+export default readFile;

package/dist/src/node/router.d.ts

@@ -0,0 +1,42 @@
+import type { Context, MiddlewareFunction, Next } from '@/node/server';
+/**
+ * @description:
+ *
+ * Basic usage:
+ *
+ * ```javascript
+ * import Server from '@/server/server'
+ * import Router from '@/server/router'
+ *
+ * const app = new Server();
+ * const router = new Router();
+ *
+ * router.get('/', (ctx, next) => {
+ *   // ctx.router available
+ * });
+ *
+ * app
+ *   .use(router.routes())
+ *   .use(router.allowedMethods());
+ * ```
+ * @return {*}
+ */
+type Handler = (ctx: Context, next: Next) => void;
+declare class Router {
+    ctx?: Context;
+    map: Map<string, Map<string, Handler>>;
+    methods: Set<string>;
+    paths: Set<string>;
+    constructor();
+    get(url: string, handler: Handler): void;
+    post(url: string, handler: Handler): void;
+    put(url: string, handler: Handler): void;
+    patch(url: string, handler: Handler): void;
+    del(url: string, handler: Handler): void;
+    head(url: string, handler: Handler): void;
+    options(url: string, handler: Handler): void;
+    private addHandlerToMap;
+    routes(): MiddlewareFunction;
+    allowedMethods(): MiddlewareFunction;
+}
+export default Router;

package/dist/src/node/send.d.ts

@@ -0,0 +1,7 @@
+import type { MiddlewareFunction } from '@/node/server';
+interface Option {
+    pathname: string;
+    fileTypes: Record<string, string>;
+}
+declare const staticMiddleware: (option?: Partial<Option>) => MiddlewareFunction;
+export default staticMiddleware;

package/dist/src/node/server.d.ts

@@ -0,0 +1,18 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import http from 'node:http';
+export type Next = () => Promise<never> | Promise<void>;
+export type MiddlewareFunction = (ctx: Context, next: Next) => void | Promise<void>;
+export interface Context {
+    [x: string]: any;
+    ipv4: () => string | undefined;
+    req: IncomingMessage;
+    res: ServerResponse;
+}
+declare class Server {
+    middleware: Array<MiddlewareFunction>;
+    ctx: Context;
+    constructor();
+    use(handle: MiddlewareFunction): void;
+    listen(...args: any): http.Server;
+}
+export default Server;

package/dist/src/node/startTask.d.ts

@@ -0,0 +1,2 @@
+declare const startTask: () => symbol;
+export default startTask;

package/dist/src/node/stream.d.ts

@@ -0,0 +1,15 @@
+import type { ReadStream, WriteStream } from 'node:fs';
+interface ReadOption {
+    path: string;
+    encoding: string;
+    start: number;
+    end: number;
+    highWaterMark: number;
+}
+interface WriteOption {
+    path: string;
+    encoding: string;
+}
+export declare const readStream: (option: ReadOption) => ReadStream;
+export declare const writeStream: (option: WriteOption) => WriteStream;
+export {};

package/dist/src/node/taskEnd.d.ts

@@ -0,0 +1,2 @@
+declare const taskEnd: (symbol: symbol) => number | bigint;
+export default taskEnd;

package/dist/src/node/traverse.d.ts

@@ -0,0 +1,17 @@
+import type { Stats } from 'node:fs';
+type Caller = (relPath: string, absPath: string, stats: Stats) => any;
+/**
+ * @description: 递归遍历每一个目录，为找到的文件都执行一个函数
+ * @param {string} dir
+ * @param {Caller} callback
+ * @param {*} pre
+ */
+export declare function traverse(dir: string, callback: Caller, pre?: string): Promise<any>;
+/**
+ * @description: 同步方法，递归遍历每一个目录，为找到的文件都执行一个函数
+ * @param {string} dir
+ * @param {Caller} callback
+ * @param {*} pre
+ */
+export declare function traverseSync(dir: string, callback: Caller, pre?: string): void;
+export {};

package/dist/src/node/watchFile.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @description: 观察一个文件是否被改变，返回状态
+ * @param {string} path 监听的文件路径
+ * @param {number} interval 监听的时间，单位毫秒，默认 20 毫秒
+ * @return {Promise}
+ */
+declare const watchFile: (path: string, interval?: number) => Promise<Ranuts.Identification>;
+export default watchFile;

package/dist/src/node/websocket.d.ts

@@ -0,0 +1,57 @@
+import http from 'node:http';
+import type internal from 'node:stream';
+import EventEmitter from 'node:events';
+interface FrameMeta {
+    fin: boolean;
+    opcode: number;
+    mask: boolean;
+    maskKey: Buffer | null;
+    payloadSize: number;
+    size: number;
+    metaSize: number;
+}
+export declare class Client extends EventEmitter {
+    socket: internal.Duplex;
+    connectTime: number;
+    constructor(socket: internal.Duplex);
+    createFrame(content: string, options?: {
+        opcode: number;
+    }): Buffer;
+    send(data: string, options?: {
+        opcode: number;
+    }): void;
+    ping(): void;
+    pong(): void;
+    close(): void;
+}
+declare class WebSocket extends EventEmitter {
+    server: http.Server<typeof http.IncomingMessage, typeof http.ServerResponse>;
+    clients: Array<Client>;
+    constructor({ port }: {
+        port: number;
+    });
+    /**
+     * @description: 向所有 client 广播
+     * @param {string} data
+     */
+    broadcast(data: string): void;
+    /**
+     * @description: 创建 client
+     * @param {http} req
+     * @param {internal} socket
+     */
+    create(req: http.IncomingMessage, socket: internal.Duplex): void;
+    /**
+     * @description: 增加 client 监听关闭事件
+     * @param {Client} client
+     */
+    addListenCloseClient(client: Client): void;
+    /**
+     * @description: 解析帧 meta
+     * @param {Buffer} source
+     * @return {FrameMeta}
+     */
+    parseFrameMeta(source: Buffer): FrameMeta;
+    iMask(data: Buffer, key: Buffer | null): Buffer;
+}
+export default WebSocket;

package/dist/src/node/writeFile.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @description: 根据文件路径创建文件，如果文件存在会清空再写入，如果不存在会创建
+ * @param {string} path 文件路径
+ * @param {string} content 文件内容
+ * @return {Promise}
+ */
+declare const writeFile: (path: string, content: string) => Promise<Ranuts.Identification>;
+export default writeFile;

package/dist/src/node/ws.d.ts

@@ -0,0 +1,8 @@
+import type http from 'node:http';
+/**
+ * Create a WebSocket Server
+ * @constructor
+ * @param { http.Server } server server from http(s).createServer()
+ */
+declare function WSS(this: any, server: http.Server): void;
+export default WSS;

package/dist/src/optimize/index.d.ts

@@ -0,0 +1,36 @@
+/**
+ * @description: 实现 object.create，将传入的对象作为原型
+ * @param {*} obj
+ * @return {*}
+ */
+/**
+ * @description: 实现 instanceof: object instanceof constructor
+ * @param {*} left
+ * @param {*} right
+ * @return {*}
+ */
+export declare const instanceOf: (obj: Record<string, unknown>, cst: Function) => boolean;
+/**
+ * @description: 实现 new 操作符
+ * @param {*} 构造函数
+ * @param {*} 参数
+ * @return {*} Object
+ */
+export declare function customNew(...args: unknown[]): Record<string, unknown>;
+/**
+ * @description: 防抖
+ * @param {Function} fn
+ * @param {number} wait
+ * @return {*}
+ */
+export declare function debounce<T extends (...args: any[]) => any>(ms: number, callback: T): (...args: Parameters<T>) => Promise<ReturnType<T>>;
+/**
+ * @description: 首节流
+ * @return {*}
+ */
+export declare function throttle(fn: Function, wait?: number): Function;
+/**
+ * @description: 实现 call 函数
+ * @param {unknown} this
+ * @return {*}
+ */

package/dist/src/ran/index.d.ts

@@ -0,0 +1,20 @@
+type InventedElementProps = any;
+interface InventedElement {
+    type: string;
+    props: InventedElementProps;
+}
+/**
+ * @description: 创建虚拟DOM，参考React源码：https://github.com/facebook/react/blob/main/packages/react/src/ReactElement.js
+ * @param {string} type
+ * @param {VirtualDomProps} props
+ * @param {array} children
+ * @return {VirtualDom}
+ */
+declare function createElement(type: string, config: InventedElementProps, children: Array<InventedElement>): InventedElement;
+/**
+ * @description: 传入虚拟DOM和需要挂载的根节点，将虚拟DOM转化为Fiber，将fiber转化为真实DOM进行挂载
+ * @param {InventedElement} inventedElement
+ * @param {Element} root
+ */
+declare function render(inventedElement: InventedElement, root: Element): void;
+export { render, createElement };

package/dist/src/ran/min.d.ts

@@ -0,0 +1,32 @@
+interface Fiber {
+    type: string;
+    dom?: HTMLElement | Text;
+    parent?: Fiber;
+    child?: Fiber;
+    sibling?: Fiber;
+    props: {
+        [x: string]: Array<Fiber> | string | undefined;
+        children?: Array<Fiber>;
+    };
+}
+/**
+ * @description: render 函数
+ * @param {RanElement} element
+ * @param {HTMLElement} container
+ */
+declare const render: (element: Fiber, container: HTMLElement) => void;
+export declare class Concurrent {
+    nextUnitOfWork: Fiber | undefined;
+    wipRoot: Fiber | undefined;
+    constructor(element: Fiber, container: HTMLElement);
+    workLoop(deadline: IdleDeadline): void;
+    /**
+     * @description: 执行一个任务单元，并返回下一个任务单元
+     * @return {*}
+     */
+    performUnitOfWork(fiber: Fiber): Fiber | undefined;
+    startWork(): void;
+    commitRoot(): void;
+    commitWork(fiber: Fiber | undefined): void;
+}
+export { render };

package/dist/src/react/index.d.ts

@@ -0,0 +1,2 @@
+import reactify from '@/react/reactify';
+export { reactify };

package/dist/src/react/index.js

@@ -0,0 +1,4 @@
+import { r } from "../../reactify-Z-V9Vblb.js";
+export {
+  r as reactify
+};

package/dist/src/react/reactify.d.ts

@@ -0,0 +1,2 @@
+export declare const reactifyWebComponent: <T = unknown>(WC: string) => any;
+export default reactifyWebComponent;

package/dist/src/sort/bubble.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @description: 冒泡排序，两两比较，交换位置，遍历n^2
+ * @param {Array} list
+ * @return {Array}
+ */
+declare const bubble: (list: number[]) => number[];
+export default bubble;

package/dist/src/sort/bucket.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @description: 桶排序
+ * @param {Array<number>} list
+ * @return {Array<number>}
+ */
+declare const bucket: (list: Array<number>, bucketSize?: number, max?: number, min?: number) => Array<number>;
+export default bucket;

package/dist/src/sort/count.d.ts

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

package/dist/src/sort/heap.d.ts

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

package/dist/src/sort/insert.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @description: 插入排序，维护一个有序的数组，将后面的数字插入到前面的有序数组中
+ * @param {Array} list
+ * @return {Array}
+ */
+declare const insert: (list: number[]) => number[];
+export default insert;

package/dist/src/sort/merge.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @description: 归并排序
+ * @param {Array} list
+ * @return {Array}
+ */
+declare const merge: (list: Array<number>) => Array<number>;
+export default merge;

package/dist/src/sort/quick.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @description: 快速排序
+ * @param {Array} list
+ * @return {Array}
+ */
+declare const quick: (list?: number[]) => number[];
+export default quick;

package/dist/src/sort/radix.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @description: 基数排序
+ * @param {Array<number>} list
+ * @return {Array<number>}
+ */
+declare const radix: (list: Array<number>, maxDigit?: number) => Array<number>;
+export default radix;

package/dist/src/sort/randomArray.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @description: 通过数组长度，数组最大值，数组的最小值随机生成数组
+ * @param {number} length
+ * @param {number} min
+ * @param {number} max
+ * @return {Array<number>}
+ */
+declare const randomArray: (length?: number, min?: number, max?: number) => Array<number>;
+export default randomArray;

package/dist/src/sort/select.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @description: 选择排序，遍历一遍，找到最小值，放到最前面，重复n次上述操作。
+ * @param {Array} list
+ * @return {Array}
+ */
+declare const select: (list: number[]) => number[];
+export default select;

package/dist/src/sort/shell.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @description: 希尔排序，是简单插入排序的改进版。它与插入排序的不同之处在于，它会优先比较距离较远的元素。希尔排序又叫缩小增量排序。
+ * @param {Array} list
+ * @return {Array}
+ */
+declare const shell: (list: number[]) => number[];
+export default shell;

package/dist/src/utils/audioRecorder.d.ts

@@ -0,0 +1,16 @@
+export declare const webmFixDuration: (blob: Blob, duration: number, type?: string) => Promise<Blob>;
+/**
+ * @description: 录音
+ * @return {*}
+ */
+export declare class AudioRecorder {
+    startTime: number;
+    chunks: Blob[];
+    mediaRecorder?: MediaRecorder;
+    blob?: Blob;
+    constructor();
+    private init;
+    start(): MediaRecorder | undefined;
+    pause(): MediaRecorder | undefined;
+    stop(): Blob | undefined;
+}