@kevisual/router 0.0.22 → 0.0.24

package/src/auto/load-ts.ts

@@ -0,0 +1,37 @@
+import { getRuntime } from './runtime.ts';
+import { glob } from './utils/glob.ts';
+type GlobOptions = {
+  cwd?: string;
+};
+
+export const getMatchFiles = async (match: string = './*.ts', { cwd = process.cwd() }: GlobOptions = {}): Promise<string[]> => {
+  const runtime = getRuntime();
+  if (runtime.isNode) {
+    console.error(`Node.js is not supported`);
+    return [];
+  }
+  if (runtime.isDeno) {
+    // Deno 环境下
+    return await glob(match);
+  }
+  if (runtime.isBun) {
+    // Bun 环境下
+    // @ts-ignore
+    const { Glob } = await import('bun');
+    const path = await import('path');
+    // @ts-ignore
+    const glob = new Glob(match, { cwd, absolute: true, onlyFiles: true });
+    const files: string[] = [];
+    for await (const file of glob.scan('.')) {
+      files.push(path.join(cwd, file));
+    }
+    // @ts-ignore
+    return Array.from(files);
+  }
+  return [];
+};
+
+export const loadTS = async (match: string = './*.ts', { cwd = process.cwd() }: GlobOptions = {}): Promise<any[]> => {
+  const files = await getMatchFiles(match, { cwd });
+  return Promise.all(files.map((file) => import(file)));
+};

package/src/auto/runtime.ts

@@ -0,0 +1,19 @@
+type RuntimeEngine = 'node' | 'deno' | 'bun';
+
+type Runtime = {
+  isNode?: boolean;
+  isDeno?: boolean;
+  isBun?: boolean;
+  engine: RuntimeEngine;
+};
+export const getRuntime = (): Runtime => {
+  // @ts-ignore
+  if (typeof Deno !== 'undefined') {
+    return { isDeno: true, engine: 'deno' };
+  }
+  // @ts-ignore
+  if (typeof Bun !== 'undefined') {
+    return { isBun: true, engine: 'bun' };
+  }
+  return { isNode: true, engine: 'node' };
+};

package/src/auto/utils/glob.ts

@@ -0,0 +1,83 @@
+type GlobOptions = {
+  cwd?: string;
+};
+
+export const glob = async (match: string = './*.ts', { cwd = process.cwd() }: GlobOptions = {}) => {
+  const fs = await import('node:fs');
+  const path = await import('node:path');
+
+  // 将 glob 模式转换为正则表达式
+  const globToRegex = (pattern: string): RegExp => {
+    const escaped = pattern
+      .replace(/\./g, '\\.')
+      .replace(/\*\*/g, '__DOUBLE_STAR__')  // 临时替换 **
+      .replace(/\*/g, '[^/]*')              // * 匹配除 / 外的任意字符
+      .replace(/__DOUBLE_STAR__/g, '.*')    // ** 匹配任意字符包括 /
+      .replace(/\?/g, '[^/]');              // ? 匹配除 / 外的单个字符
+    return new RegExp(`^${escaped}$`);
+  };
+
+  // 递归读取目录
+  const readDirRecursive = async (dir: string): Promise<string[]> => {
+    const files: string[] = [];
+    
+    try {
+      const entries = await fs.promises.readdir(dir, { withFileTypes: true });
+      
+      for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        
+        if (entry.isFile()) {
+          files.push(fullPath);
+        } else if (entry.isDirectory()) {
+          // 递归搜索子目录
+          const subFiles = await readDirRecursive(fullPath);
+          files.push(...subFiles);
+        }
+      }
+    } catch (error) {
+      // 忽略无法访问的目录
+    }
+    
+    return files;
+  };
+
+  // 解析模式是否包含递归搜索
+  const hasRecursive = match.includes('**');
+  
+  try {
+    let allFiles: string[] = [];
+    
+    if (hasRecursive) {
+      // 处理递归模式
+      const basePath = match.split('**')[0];
+      const startDir = path.resolve(cwd, basePath || '.');
+      allFiles = await readDirRecursive(startDir);
+    } else {
+      // 处理非递归模式
+      const dir = path.resolve(cwd, path.dirname(match));
+      const entries = await fs.promises.readdir(dir, { withFileTypes: true });
+      
+      for (const entry of entries) {
+        if (entry.isFile()) {
+          allFiles.push(path.join(dir, entry.name));
+        }
+      }
+    }
+
+    // 创建相对于 cwd 的匹配模式
+    const normalizedMatch = path.resolve(cwd, match);
+    const regex = globToRegex(normalizedMatch);
+    
+    // 过滤匹配的文件
+    const matchedFiles = allFiles.filter(file => {
+      const normalizedFile = path.resolve(file);
+      return regex.test(normalizedFile);
+    });
+
+    return matchedFiles;
+  } catch (error) {
+    console.error(`Error in glob pattern "${match}":`, error);
+    return [];
+  }
+};

package/src/browser.ts

@@ -1,6 +1,8 @@
 export { Route, QueryRouter, QueryRouterServer } from './route.ts';
 
-export { Rule, Schema, createSchema } from './validator/index.ts';
+export type { Rule, Schema } from './validator/index.ts';
+
+export { createSchema } from './validator/index.ts';
 
 export type { RouteContext, RouteOpts } from './route.ts';
 

package/src/index.ts

@@ -1,5 +1,4 @@
 export { Route, QueryRouter, QueryRouterServer } from './route.ts';
-export { Connect, QueryConnect } from './connect.ts';
 
 export type { RouteContext, RouteOpts, RouteMiddleware } from './route.ts';
 
@@ -11,8 +10,9 @@ export { Server, handleServer } from './server/index.ts';
  */
 export { CustomError } from './result/error.ts';
 
-export { Rule, Schema, createSchema } from './validator/index.ts';
-
+export { createSchema } from './validator/index.ts';
+export type { Rule } from './validator/rule.ts';
+export type { Schema } from 'zod';
 export { App } from './app.ts';
 
 export * from './router-define.ts';

package/src/route.ts

@@ -54,7 +54,7 @@ export type RouteContext<T = { code?: number }, S = any> = {
   queryRoute?: (message: { path: string; key?: string; payload?: any }, ctx?: RouteContext & { [key: string]: any }) => Promise<any>;
   index?: number;
   throw?: (code?: number | string, message?: string, tips?: string) => void;
-  /** 是否需要序列化 */
+  /** 是否需要序列化, 使用JSON.stringify和JSON.parse */
   needSerialize?: boolean;
 } & T;
 export type SimpleObject = Record<string, any>;
@@ -603,7 +603,12 @@ export class QueryRouter {
       message: res.message,
     };
   }
-  async setContext(ctx: RouteContext) {
+  /**
+   * 设置上下文
+   * @description 这里的上下文是为了在handle函数中使用
+   * @param ctx
+   */
+   setContext(ctx: RouteContext) {
     this.context = ctx;
   }
   getList(): RouteInfo[] {
@@ -647,7 +652,7 @@ export class QueryRouter {
   throw(...args: any[]) {
     throw new CustomError(...args);
   }
-  hasRoute(path: string, key?: string) {
+  hasRoute(path: string, key: string = '') {
     return this.routes.find((r) => r.path === path && r.key === key);
   }
 }

package/src/sign.ts

@@ -1,28 +1,33 @@
 import { generate } from 'selfsigned';
 
-type Attributes = {
+export type Attributes = {
   name: string;
   value: string;
 };
-type AltNames = {
+export type AltNames = {
   type: number;
   value?: string;
   ip?: string;
 };
 export const createCert = (attrs: Attributes[] = [], altNames: AltNames[] = []) => {
   let attributes = [
-    { name: 'commonName', value: '*' }, // 通配符域名
     { name: 'countryName', value: 'CN' }, // 国家代码
     { name: 'stateOrProvinceName', value: 'ZheJiang' }, // 州名
-    { name: 'localityName', value: 'Hangzhou' }, // 城市名
-    { name: 'organizationName', value: 'Envision' }, // 组织名
-    { name: 'organizationalUnitName', value: 'IT' }, // 组织单位
+    { name: 'localityName', value: 'HangZhou' }, // 城市名
+    { name: 'organizationName', value: 'kevisual' }, // 组织名
+    { name: 'organizationalUnitName', value: 'kevisual' }, // 组织单位
     ...attrs,
   ];
   // attribute 根据name去重复, 后面的覆盖前面的
-  attributes = attributes.filter((item, index, self) => {
-    return self.findIndex((t) => t.name === item.name) === index;
-  });
+  attributes = Object.values(
+    attributes.reduce(
+      (acc, attr) => ({
+        ...acc,
+        [attr.name]: attr,
+      }),
+      {} as Record<string, Attributes>,
+    ),
+  );
 
   const options = {
     days: 365, // 证书有效期（天）
@@ -32,6 +37,14 @@ export const createCert = (attrs: Attributes[] = [], altNames: AltNames[] = [])
         altNames: [
           { type: 2, value: '*' }, // DNS 名称
           { type: 2, value: 'localhost' }, // DNS
+          {
+            type: 2,
+            value: '[::1]',
+          },
+          {
+            type: 7,
+            ip: 'fe80::1',
+          },
           { type: 7, ip: '127.0.0.1' }, // IP 地址
           ...altNames,
         ],

package/src/test/static.ts

@@ -0,0 +1,22 @@
+import { proxyRoute, initProxy } from '@kevisual/local-proxy/proxy.ts';
+initProxy({
+  pagesDir: './demo',
+  watch: true,
+});
+import { App } from '../app.ts';
+
+const app = new App();
+app
+  .route({
+    path: 'a',
+  })
+  .define(async (ctx) => {
+    ctx.body = '1';
+  })
+  .addTo(app);
+
+app.listen(2233, () => {
+  console.log('Server is running on http://localhost:2233');
+});
+
+app.onServerRequest(proxyRoute);

package/src/utils/is-engine.ts

@@ -0,0 +1,15 @@
+export const isNode = typeof process !== 'undefined' && process.versions != null && process.versions.node != null;
+export const isBrowser = typeof window !== 'undefined' && typeof document !== 'undefined' && typeof document.createElement === 'function';
+// @ts-ignore
+export const isDeno = typeof Deno !== 'undefined' && typeof Deno.version === 'object' && typeof Deno.version.deno === 'string';
+
+export const getEngine = () => {
+  if (isNode) {
+    return 'node';
+  } else if (isBrowser) {
+    return 'browser';
+  } else if (isDeno) {
+    return 'deno';
+  }
+  return 'unknown';
+};

package/src/validator/index.ts

@@ -1 +1,3 @@
-export * from './rule.ts';
+export { schemaFormRule, createSchema, createSchemaList } from './rule.ts';
+
+export type { Rule, Schema } from './rule.ts';

package/src/connect.ts

@@ -1,67 +0,0 @@
-import { nanoid } from 'nanoid';
-import { RouteContext } from './route.ts';
-
-export class Connect {
-  path: string;
-  key?: string;
-  _fn?: (ctx?: RouteContext) => Promise<RouteContext>;
-  description?: string;
-  connects: { path: string; key?: string }[];
-  share = false;
-
-  constructor(path: string) {
-    this.path = path;
-    this.key = nanoid();
-  }
-  use(path: string) {
-    this.connects.push({ path });
-  }
-  useList(paths: string[]) {
-    paths.forEach((path) => {
-      this.connects.push({ path });
-    });
-  }
-  useConnect(connect: Connect) {
-    this.connects.push({ path: connect.path, key: connect.key });
-  }
-  useConnectList(connects: Connect[]) {
-    connects.forEach((connect) => {
-      this.connects.push({ path: connect.path, key: connect.key });
-    });
-  }
-  getPathList() {
-    return this.connects.map((c) => c.path).filter(Boolean);
-  }
-  set fn(fn: (ctx?: RouteContext) => Promise<RouteContext>) {
-    this._fn = fn;
-  }
-  get fn() {
-    return this._fn;
-  }
-}
-export class QueryConnect {
-  connects: Connect[];
-  constructor() {
-    this.connects = [];
-  }
-  add(connect: Connect) {
-    const has = this.connects.find((c) => c.path === connect.path && c.key === connect.key);
-    if (has) {
-      // remove the old connect
-      console.log('[replace connect]:', connect.path, connect.key);
-      this.connects = this.connects.filter((c) => c.path !== connect.path && c.key !== connect.key);
-    }
-    this.connects.push(connect);
-  }
-  remove(connect: Connect) {
-    this.connects = this.connects.filter((c) => c.path !== connect.path && c.key !== connect.key);
-  }
-  getList() {
-    return this.connects.map((c) => {
-      return {
-        path: c.path,
-        key: c.key,
-      };
-    });
-  }
-}