@kevisual/router 0.0.2

package/dist/io.d.ts

@@ -0,0 +1,3 @@
+export declare class IOApp {
+    constructor();
+}

package/dist/result/error.d.ts

@@ -0,0 +1,22 @@
+/** 自定义错误 */
+export declare class CustomError extends Error {
+    code?: number;
+    data?: any;
+    message: string;
+    tips?: string;
+    constructor(code?: number | string, message?: string, tips?: string);
+    static fromCode(code?: number): CustomError;
+    static fromErrorData(code?: number, data?: any): CustomError;
+    static parseError(e: CustomError): {
+        code: number;
+        data: any;
+        message: string;
+        tips: string;
+    };
+    parse(e?: CustomError): {
+        code: number;
+        data: any;
+        message: string;
+        tips: string;
+    };
+}

package/dist/result/index.d.ts

@@ -0,0 +1,27 @@
+export declare const Code400: {
+    code: number;
+    msg: string;
+    zn: string;
+}[];
+export declare const ResultCode: {
+    code: number;
+    msg: string;
+    zn: string;
+}[];
+type ResultProps = {
+    code?: number;
+    msg?: string;
+    userTip?: string;
+};
+export declare const Result: {
+    ({ code, msg, userTip, ...other }: ResultProps): {
+        code: number;
+        msg: string;
+        userTip: any;
+    };
+    success(data?: any): {
+        code: number;
+        data: any;
+    };
+};
+export {};

package/dist/route.d.ts

@@ -0,0 +1,234 @@
+import { Schema, Rule } from './validator/index.ts';
+export type RouterContextT = {
+    code?: number;
+    [key: string]: any;
+};
+export type RouteContext<T = {
+    code?: number;
+}, S = any> = {
+    query?: {
+        [key: string]: any;
+    };
+    /** return body */
+    body?: number | string | Object;
+    /** return code */
+    code?: number;
+    /** return msg */
+    message?: string;
+    state?: S;
+    currentPath?: string;
+    currentKey?: string;
+    currentRoute?: Route;
+    progress?: [[string, string]][];
+    nextQuery?: {
+        [key: string]: any;
+    };
+    end?: boolean;
+    queryRouter?: QueryRouter;
+    error?: any;
+    call?: (message: {
+        path: string;
+        key: string;
+        payload?: any;
+    }, ctx?: RouteContext & {
+        [key: string]: any;
+    }) => Promise<any>;
+    index?: number;
+} & T;
+export type Run<T = any> = (ctx?: RouteContext<T>) => Promise<typeof ctx | null | void>;
+export type NextRoute = Pick<Route, 'id' | 'path' | 'key'>;
+export type RouteOpts = {
+    path?: string;
+    key?: string;
+    id?: string;
+    run?: Run;
+    nextRoute?: NextRoute;
+    description?: string;
+    middleware?: Route[] | string[];
+    type?: 'route' | 'middleware';
+    /**
+     * validator: {
+     *  packageName: {
+     *    type: 'string',
+     *    required: true,
+     *  },
+     * }
+     */
+    validator?: {
+        [key: string]: Rule;
+    };
+    schema?: {
+        [key: string]: Schema<any>;
+    };
+    isVerify?: boolean;
+    verify?: (ctx?: RouteContext, dev?: boolean) => boolean;
+    verifyKey?: (key: string, ctx?: RouteContext, dev?: boolean) => boolean;
+    idUsePath?: boolean;
+    isDebug?: boolean;
+};
+export type DefineRouteOpts = Omit<RouteOpts, 'idUsePath' | 'verify' | 'verifyKey' | 'nextRoute'>;
+declare const pickValue: readonly ["path", "key", "id", "description", "type", "validator", "middleware"];
+export type RouteInfo = Pick<Route, (typeof pickValue)[number]>;
+export declare class Route {
+    path?: string;
+    key?: string;
+    id?: string;
+    share?: boolean;
+    run?: Run;
+    nextRoute?: NextRoute;
+    description?: string;
+    middleware?: (Route | string)[];
+    type?: string;
+    private _validator?;
+    schema?: {
+        [key: string]: Schema<any>;
+    };
+    data?: any;
+    isVerify?: boolean;
+    isDebug?: boolean;
+    constructor(path: string, key?: string, opts?: RouteOpts);
+    private createSchema;
+    /**
+     * set validator and create schema
+     * @param validator
+     */
+    set validator(validator: {
+        [key: string]: Rule;
+    });
+    get validator(): {
+        [key: string]: Rule;
+    };
+    /**
+     * has code, body, message in ctx, return ctx if has error
+     * @param ctx
+     * @param dev
+     * @returns
+     */
+    verify(ctx: RouteContext, dev?: boolean): void;
+    /**
+     * Need to manully call return ctx fn and configure body, code, message
+     * @param key
+     * @param ctx
+     * @param dev
+     * @returns
+     */
+    verifyKey(key: string, ctx: RouteContext, dev?: boolean): {
+        message: string;
+        path: string;
+        key: string;
+        error: any;
+    } | {
+        message: string;
+        path: string;
+        key: string;
+        error?: undefined;
+    };
+    setValidator(validator: {
+        [key: string]: Rule;
+    }): this;
+    define<T extends {
+        [key: string]: any;
+    } = RouterContextT>(opts: DefineRouteOpts): this;
+    define<T extends {
+        [key: string]: any;
+    } = RouterContextT>(fn: Run<T>): this;
+    define<T extends {
+        [key: string]: any;
+    } = RouterContextT>(key: string, fn: Run<T>): this;
+    define<T extends {
+        [key: string]: any;
+    } = RouterContextT>(path: string, key: string, fn: Run<T>): this;
+    addTo(router: QueryRouter | {
+        add: (route: Route) => void;
+        [key: string]: any;
+    }): void;
+    setData(data: any): this;
+}
+export declare class QueryRouter {
+    routes: Route[];
+    maxNextRoute: number;
+    constructor();
+    add(route: Route): void;
+    /**
+     * remove route by path and key
+     * @param route
+     */
+    remove(route: Route | {
+        path: string;
+        key: string;
+    }): void;
+    /**
+     * remove route by id
+     * @param uniqueId
+     */
+    removeById(unique: string): void;
+    /**
+     * 执行route
+     * @param path
+     * @param key
+     * @param ctx
+     * @returns
+     */
+    runRoute(path: string, key: string, ctx?: RouteContext): any;
+    /**
+     * 第一次执行
+     * @param message
+     * @param ctx
+     * @returns
+     */
+    parse(message: {
+        path: string;
+        key?: string;
+        payload?: any;
+    }, ctx?: RouteContext & {
+        [key: string]: any;
+    }): Promise<any>;
+    call(message: {
+        path: string;
+        key: string;
+        payload?: any;
+    }, ctx?: RouteContext & {
+        [key: string]: any;
+    }): Promise<any>;
+    getList(): RouteInfo[];
+    getHandle<T = any>(router: QueryRouter, wrapperFn?: HandleFn<T>, ctx?: RouteContext): (msg: {
+        path: string;
+        key?: string;
+        [key: string]: any;
+    }) => Promise<{
+        [key: string]: any;
+        code: string;
+        data?: any;
+        message?: string;
+    } | {
+        code: any;
+        data: any;
+        message: any;
+    }>;
+}
+type QueryRouterServerOpts = {
+    handleFn?: HandleFn;
+    context?: RouteContext;
+};
+interface HandleFn<T = any> {
+    (msg: {
+        path: string;
+        [key: string]: any;
+    }, ctx?: any): {
+        code: string;
+        data?: any;
+        message?: string;
+        [key: string]: any;
+    };
+    (res: RouteContext<T>): any;
+}
+/**
+ * QueryRouterServer
+ * @description 移除server相关的功能，只保留router相关的功能，和http.createServer不相关，独立
+ */
+export declare class QueryRouterServer extends QueryRouter {
+    handle: any;
+    constructor(opts?: QueryRouterServerOpts);
+    setHandle(wrapperFn?: HandleFn, ctx?: RouteContext): void;
+}
+export {};

package/dist/server/handle-server.d.ts

@@ -0,0 +1,10 @@
+import { IncomingMessage, ServerResponse } from 'http';
+/**
+ * get params and body
+ * @param req
+ * @param res
+ * @returns
+ */
+export declare const handleServer: (req: IncomingMessage, res: ServerResponse) => Promise<{
+    token: string;
+}>;

package/dist/server/index.d.ts

@@ -0,0 +1,2 @@
+export { Server } from './server.ts';
+export { handleServer } from './handle-server.ts';

package/dist/server/parse-body.d.ts

@@ -0,0 +1,2 @@
+import * as http from 'http';
+export declare const parseBody: (req: http.IncomingMessage) => Promise<unknown>;

package/dist/server/server.d.ts

@@ -0,0 +1,54 @@
+import http, { IncomingMessage, ServerResponse } from 'http';
+export type Listener = (...args: any[]) => void;
+export type Cors = {
+    /**
+     * @default '*''
+     */
+    origin?: string | undefined;
+};
+type ServerOpts = {
+    /**path default `/api/router` */
+    path?: string;
+    /**handle Fn */
+    handle?: (msg?: {
+        path: string;
+        key?: string;
+        [key: string]: any;
+    }) => any;
+    cors?: Cors;
+};
+export declare const resultError: (error: string, code?: number) => string;
+export declare class Server {
+    path: string;
+    private _server;
+    handle: ServerOpts['handle'];
+    private _callback;
+    private cors;
+    private hasOn;
+    constructor(opts?: ServerOpts);
+    listen(port: number, hostname?: string, backlog?: number, listeningListener?: () => void): void;
+    listen(port: number, hostname?: string, listeningListener?: () => void): void;
+    listen(port: number, backlog?: number, listeningListener?: () => void): void;
+    listen(port: number, listeningListener?: () => void): void;
+    listen(path: string, backlog?: number, listeningListener?: () => void): void;
+    listen(path: string, listeningListener?: () => void): void;
+    listen(handle: any, backlog?: number, listeningListener?: () => void): void;
+    listen(handle: any, listeningListener?: () => void): void;
+    setHandle(handle?: any): void;
+    /**
+     * get callback
+     * @returns
+     */
+    createCallback(): (req: IncomingMessage, res: ServerResponse) => Promise<void>;
+    get handleServer(): any;
+    set handleServer(fn: any);
+    /**
+     * 兜底监听，当除开 `/api/router` 之外的请求，框架只监听一个api，所以有其他的请求都执行其他的监听
+     * @description 主要是为了兼容其他的监听
+     * @param listener
+     */
+    on(listener: Listener | Listener[]): void;
+    get callback(): any;
+    get server(): http.Server<typeof http.IncomingMessage, typeof http.ServerResponse>;
+}
+export {};

package/dist/server/ws-server.d.ts

@@ -0,0 +1,37 @@
+import { WebSocketServer, WebSocket } from 'ws';
+import { Server } from './server.ts';
+export declare const createWsServer: (server: Server) => import("ws").Server<typeof import("ws"), typeof import("http").IncomingMessage>;
+type WsServerBaseOpts = {
+    wss?: WebSocketServer;
+    path?: string;
+};
+export type ListenerFn = (message: {
+    data: Record<string, any>;
+    ws: WebSocket;
+    end: (data: any) => any;
+}) => Promise<any>;
+export type Listener<T = 'router' | 'chat' | 'ai'> = {
+    type: T;
+    listener: ListenerFn;
+};
+export declare class WsServerBase {
+    wss: WebSocketServer;
+    path: string;
+    listeners: {
+        type: string;
+        listener: ListenerFn;
+    }[];
+    listening: boolean;
+    constructor(opts: WsServerBaseOpts);
+    setPath(path: string): void;
+    listen(): void;
+    addListener(type: string, listener: ListenerFn): void;
+    removeListener(type: string): void;
+}
+export declare class WsServer extends WsServerBase {
+    server: Server;
+    constructor(server: Server, opts?: any);
+    initListener(): void;
+    listen(): void;
+}
+export {};

package/dist/static.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/parse.d.ts

@@ -0,0 +1,3 @@
+export declare const parseIfJson: (input: string) => {
+    [key: string]: any;
+} | string;

package/dist/utils/pick.d.ts

@@ -0,0 +1 @@
+export declare function pick<T extends object, K extends keyof T>(obj: T, keys: K[]): Pick<T, K>;

package/dist/validator/index.d.ts

@@ -0,0 +1 @@
+export * from './rule.ts';

package/dist/validator/rule.d.ts

@@ -0,0 +1,40 @@
+import { z, Schema } from 'zod';
+export { Schema };
+type BaseRule = {
+    value?: any;
+    required?: boolean;
+    message?: string;
+};
+type RuleString = {
+    type: 'string';
+    minLength?: number;
+    maxLength?: number;
+    regex?: string;
+} & BaseRule;
+type RuleNumber = {
+    type: 'number';
+    min?: number;
+    max?: number;
+} & BaseRule;
+type RuleBoolean = {
+    type: 'boolean';
+} & BaseRule;
+type RuleArray = {
+    type: 'array';
+    items: Rule;
+    minItems?: number;
+    maxItems?: number;
+} & BaseRule;
+type RuleObject = {
+    type: 'object';
+    properties: {
+        [key: string]: Rule;
+    };
+} & BaseRule;
+type RuleAny = {
+    type: 'any';
+} & BaseRule;
+export type Rule = RuleString | RuleNumber | RuleBoolean | RuleArray | RuleObject | RuleAny;
+export declare const schemaFormRule: (rule: Rule) => z.ZodType<any, any, any>;
+export declare const createSchema: (rule: Rule) => Schema;
+export declare const createSchemaList: (rules: Rule[]) => z.ZodType<any, z.ZodTypeDef, any>[];

package/package.json

@@ -0,0 +1,47 @@
+{
+  "$schema": "https://json.schemastore.org/package",
+  "name": "@kevisual/router",
+  "version": "0.0.2",
+  "description": "",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "type": "module",
+  "scripts": {
+    "build": "npm run clean && rollup -c",
+    "watch": "rollup -c -w",
+    "clean": "rm -rf dist"
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "devDependencies": {
+    "@rollup/plugin-commonjs": "^26.0.1",
+    "@rollup/plugin-node-resolve": "^15.2.4",
+    "@rollup/plugin-typescript": "^12.1.0",
+    "@types/lodash-es": "^4.17.12",
+    "@types/node": "^22.5.5",
+    "@types/ws": "^8.5.12",
+    "lodash-es": "^4.17.21",
+    "nanoid": "^5.0.7",
+    "rollup": "^4.22.4",
+    "ts-loader": "^9.5.1",
+    "ts-node": "^10.9.2",
+    "tslib": "^2.7.0",
+    "typescript": "^5.6.2",
+    "zod": "^3.23.8"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/abearxiong/kevisual-router.git"
+  },
+  "dependencies": {
+    "ws": "^8.18.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/readme.md

@@ -0,0 +1,31 @@
+# router
+
+```
+import { App } from '@kevisual/router';
+
+const app = new App();
+app.listen(4002);
+
+new app.Route('demo', '01')
+  .define(async (ctx) => {
+    ctx.body = '01';
+    return ctx;
+  })
+  .addTo(app);
+
+app
+  .route({path:'demo', key: '02})
+  .define(async (ctx) => {
+    ctx.body = '02';
+    return ctx;
+  })
+  .addTo(app);
+
+app
+  .route('demo', '03')
+  .define(async (ctx) => {
+    ctx.body = '03';
+    return ctx;
+  })
+  .addTo(app);
+```