@kevisual/router 0.2.3 → 0.2.5

package/dist/router-simple.js

@@ -0,0 +1,749 @@
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+
+// ../../node_modules/.pnpm/path-to-regexp@8.4.0/node_modules/path-to-regexp/dist/index.js
+var require_dist = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.PathError = exports.TokenData = undefined;
+  exports.parse = parse;
+  exports.compile = compile;
+  exports.match = match;
+  exports.pathToRegexp = pathToRegexp;
+  exports.stringify = stringify;
+  var DEFAULT_DELIMITER = "/";
+  var NOOP_VALUE = (value) => value;
+  var ID_START = /^[$_\p{ID_Start}]$/u;
+  var ID_CONTINUE = /^[$\u200c\u200d\p{ID_Continue}]$/u;
+  var ID = /^[$_\p{ID_Start}][$\u200c\u200d\p{ID_Continue}]*$/u;
+  var SIMPLE_TOKENS = "{}()[]+?!";
+  function escapeText(str) {
+    return str.replace(/[{}()\[\]+?!:*\\]/g, "\\$&");
+  }
+  function escape(str) {
+    return str.replace(/[.+*?^${}()[\]|/\\]/g, "\\$&");
+  }
+
+  class TokenData {
+    constructor(tokens, originalPath) {
+      this.tokens = tokens;
+      this.originalPath = originalPath;
+    }
+  }
+  exports.TokenData = TokenData;
+
+  class PathError extends TypeError {
+    constructor(message, originalPath) {
+      let text = message;
+      if (originalPath)
+        text += `: ${originalPath}`;
+      text += `; visit https://git.new/pathToRegexpError for info`;
+      super(text);
+      this.originalPath = originalPath;
+    }
+  }
+  exports.PathError = PathError;
+  function parse(str, options = {}) {
+    const { encodePath = NOOP_VALUE } = options;
+    const chars = [...str];
+    const tokens = [];
+    let index = 0;
+    let pos = 0;
+    function name() {
+      let value = "";
+      if (ID_START.test(chars[index])) {
+        do {
+          value += chars[index++];
+        } while (ID_CONTINUE.test(chars[index]));
+      } else if (chars[index] === '"') {
+        let quoteStart = index;
+        while (index < chars.length) {
+          if (chars[++index] === '"') {
+            index++;
+            quoteStart = 0;
+            break;
+          }
+          if (chars[index] === "\\")
+            index++;
+          value += chars[index];
+        }
+        if (quoteStart) {
+          throw new PathError(`Unterminated quote at index ${quoteStart}`, str);
+        }
+      }
+      if (!value) {
+        throw new PathError(`Missing parameter name at index ${index}`, str);
+      }
+      return value;
+    }
+    while (index < chars.length) {
+      const value = chars[index++];
+      if (SIMPLE_TOKENS.includes(value)) {
+        tokens.push({ type: value, index, value });
+      } else if (value === "\\") {
+        tokens.push({ type: "escape", index, value: chars[index++] });
+      } else if (value === ":") {
+        tokens.push({ type: "param", index, value: name() });
+      } else if (value === "*") {
+        tokens.push({ type: "wildcard", index, value: name() });
+      } else {
+        tokens.push({ type: "char", index, value });
+      }
+    }
+    tokens.push({ type: "end", index, value: "" });
+    function consumeUntil(endType) {
+      const output = [];
+      while (true) {
+        const token = tokens[pos++];
+        if (token.type === endType)
+          break;
+        if (token.type === "char" || token.type === "escape") {
+          let path = token.value;
+          let cur = tokens[pos];
+          while (cur.type === "char" || cur.type === "escape") {
+            path += cur.value;
+            cur = tokens[++pos];
+          }
+          output.push({
+            type: "text",
+            value: encodePath(path)
+          });
+          continue;
+        }
+        if (token.type === "param" || token.type === "wildcard") {
+          output.push({
+            type: token.type,
+            name: token.value
+          });
+          continue;
+        }
+        if (token.type === "{") {
+          output.push({
+            type: "group",
+            tokens: consumeUntil("}")
+          });
+          continue;
+        }
+        throw new PathError(`Unexpected ${token.type} at index ${token.index}, expected ${endType}`, str);
+      }
+      return output;
+    }
+    return new TokenData(consumeUntil("end"), str);
+  }
+  function compile(path, options = {}) {
+    const { encode = encodeURIComponent, delimiter = DEFAULT_DELIMITER } = options;
+    const data = typeof path === "object" ? path : parse(path, options);
+    const fn = tokensToFunction(data.tokens, delimiter, encode);
+    return function path2(params = {}) {
+      const [path3, ...missing] = fn(params);
+      if (missing.length) {
+        throw new TypeError(`Missing parameters: ${missing.join(", ")}`);
+      }
+      return path3;
+    };
+  }
+  function tokensToFunction(tokens, delimiter, encode) {
+    const encoders = tokens.map((token) => tokenToFunction(token, delimiter, encode));
+    return (data) => {
+      const result = [""];
+      for (const encoder of encoders) {
+        const [value, ...extras] = encoder(data);
+        result[0] += value;
+        result.push(...extras);
+      }
+      return result;
+    };
+  }
+  function tokenToFunction(token, delimiter, encode) {
+    if (token.type === "text")
+      return () => [token.value];
+    if (token.type === "group") {
+      const fn = tokensToFunction(token.tokens, delimiter, encode);
+      return (data) => {
+        const [value, ...missing] = fn(data);
+        if (!missing.length)
+          return [value];
+        return [""];
+      };
+    }
+    const encodeValue = encode || NOOP_VALUE;
+    if (token.type === "wildcard" && encode !== false) {
+      return (data) => {
+        const value = data[token.name];
+        if (value == null)
+          return ["", token.name];
+        if (!Array.isArray(value) || value.length === 0) {
+          throw new TypeError(`Expected "${token.name}" to be a non-empty array`);
+        }
+        return [
+          value.map((value2, index) => {
+            if (typeof value2 !== "string") {
+              throw new TypeError(`Expected "${token.name}/${index}" to be a string`);
+            }
+            return encodeValue(value2);
+          }).join(delimiter)
+        ];
+      };
+    }
+    return (data) => {
+      const value = data[token.name];
+      if (value == null)
+        return ["", token.name];
+      if (typeof value !== "string") {
+        throw new TypeError(`Expected "${token.name}" to be a string`);
+      }
+      return [encodeValue(value)];
+    };
+  }
+  function match(path, options = {}) {
+    const { decode = decodeURIComponent, delimiter = DEFAULT_DELIMITER } = options;
+    const { regexp, keys } = pathToRegexp(path, options);
+    const decoders = keys.map((key) => {
+      if (decode === false)
+        return NOOP_VALUE;
+      if (key.type === "param")
+        return decode;
+      return (value) => value.split(delimiter).map(decode);
+    });
+    return function match2(input) {
+      const m = regexp.exec(input);
+      if (!m)
+        return false;
+      const path2 = m[0];
+      const params = Object.create(null);
+      for (let i = 1;i < m.length; i++) {
+        if (m[i] === undefined)
+          continue;
+        const key = keys[i - 1];
+        const decoder = decoders[i - 1];
+        params[key.name] = decoder(m[i]);
+      }
+      return { path: path2, params };
+    };
+  }
+  function pathToRegexp(path, options = {}) {
+    const { delimiter = DEFAULT_DELIMITER, end = true, sensitive = false, trailing = true } = options;
+    const root = new SourceNode("^");
+    const paths = [path];
+    let combinations = 0;
+    while (paths.length) {
+      const path2 = paths.shift();
+      if (Array.isArray(path2)) {
+        paths.push(...path2);
+        continue;
+      }
+      const data = typeof path2 === "object" ? path2 : parse(path2, options);
+      flatten(data.tokens, 0, [], (tokens) => {
+        if (combinations++ >= 256) {
+          throw new PathError("Too many path combinations", data.originalPath);
+        }
+        let node = root;
+        for (const part of toRegExpSource(tokens, delimiter, data.originalPath)) {
+          node = node.add(part.source, part.key);
+        }
+        node.add("");
+      });
+    }
+    const keys = [];
+    let pattern = toRegExp(root, keys);
+    if (trailing)
+      pattern += "(?:" + escape(delimiter) + "$)?";
+    pattern += end ? "$" : "(?=" + escape(delimiter) + "|$)";
+    return { regexp: new RegExp(pattern, sensitive ? "" : "i"), keys };
+  }
+  function toRegExp(node, keys) {
+    if (node.key)
+      keys.push(node.key);
+    const children = Object.keys(node.children);
+    const text = children.map((id) => toRegExp(node.children[id], keys)).join("|");
+    return node.source + (children.length < 2 ? text : `(?:${text})`);
+  }
+
+  class SourceNode {
+    constructor(source, key) {
+      this.source = source;
+      this.key = key;
+      this.children = Object.create(null);
+    }
+    add(source, key) {
+      var _a;
+      const id = source + ":" + (key ? key.name : "");
+      return (_a = this.children)[id] || (_a[id] = new SourceNode(source, key));
+    }
+  }
+  function flatten(tokens, index, result, callback) {
+    while (index < tokens.length) {
+      const token = tokens[index++];
+      if (token.type === "group") {
+        flatten(token.tokens, 0, result.slice(), (seq) => flatten(tokens, index, seq, callback));
+        continue;
+      }
+      result.push(token);
+    }
+    callback(result);
+  }
+  function toRegExpSource(tokens, delimiter, originalPath) {
+    let result = [];
+    let backtrack = "";
+    let wildcardBacktrack = "";
+    let prevCaptureType = 0;
+    let hasSegmentCapture = 0;
+    let index = 0;
+    function hasInSegment(index2, type) {
+      while (index2 < tokens.length) {
+        const token = tokens[index2++];
+        if (token.type === type)
+          return true;
+        if (token.type === "text") {
+          if (token.value.includes(delimiter))
+            break;
+        }
+      }
+      return false;
+    }
+    function peekText(index2) {
+      let result2 = "";
+      while (index2 < tokens.length) {
+        const token = tokens[index2++];
+        if (token.type !== "text")
+          break;
+        result2 += token.value;
+      }
+      return result2;
+    }
+    while (index < tokens.length) {
+      const token = tokens[index++];
+      if (token.type === "text") {
+        result.push({ source: escape(token.value) });
+        backtrack += token.value;
+        if (prevCaptureType === 2)
+          wildcardBacktrack += token.value;
+        if (token.value.includes(delimiter))
+          hasSegmentCapture = 0;
+        continue;
+      }
+      if (token.type === "param" || token.type === "wildcard") {
+        if (prevCaptureType && !backtrack) {
+          throw new PathError(`Missing text before "${token.name}" ${token.type}`, originalPath);
+        }
+        if (token.type === "param") {
+          result.push({
+            source: hasSegmentCapture ? `(${negate(delimiter, backtrack)}+?)` : hasInSegment(index, "wildcard") ? `(${negate(delimiter, peekText(index))}+?)` : `(${negate(delimiter, "")}+?)`,
+            key: token
+          });
+          hasSegmentCapture |= prevCaptureType = 1;
+        } else {
+          result.push({
+            source: hasSegmentCapture & 2 ? `(${negate(backtrack, "")}+?)` : hasSegmentCapture & 1 ? `(${negate(wildcardBacktrack, "")}+?)` : wildcardBacktrack ? `(${negate(wildcardBacktrack, "")}+?|${negate(delimiter, "")}+?)` : `([^]+?)`,
+            key: token
+          });
+          wildcardBacktrack = "";
+          hasSegmentCapture |= prevCaptureType = 2;
+        }
+        backtrack = "";
+        continue;
+      }
+      throw new TypeError(`Unknown token type: ${token.type}`);
+    }
+    return result;
+  }
+  function negate(a, b) {
+    if (b.length > a.length)
+      return negate(b, a);
+    if (a === b)
+      b = "";
+    if (b.length > 1)
+      return `(?:(?!${escape(a)}|${escape(b)})[^])`;
+    if (a.length > 1)
+      return `(?:(?!${escape(a)})[^${escape(b)}])`;
+    return `[^${escape(a + b)}]`;
+  }
+  function stringifyTokens(tokens, index) {
+    let value = "";
+    while (index < tokens.length) {
+      const token = tokens[index++];
+      if (token.type === "text") {
+        value += escapeText(token.value);
+        continue;
+      }
+      if (token.type === "group") {
+        value += "{" + stringifyTokens(token.tokens, 0) + "}";
+        continue;
+      }
+      if (token.type === "param") {
+        value += ":" + stringifyName(token.name, tokens[index]);
+        continue;
+      }
+      if (token.type === "wildcard") {
+        value += "*" + stringifyName(token.name, tokens[index]);
+        continue;
+      }
+      throw new TypeError(`Unknown token type: ${token.type}`);
+    }
+    return value;
+  }
+  function stringify(data) {
+    return stringifyTokens(data.tokens, 0);
+  }
+  function stringifyName(name, next) {
+    if (!ID.test(name))
+      return JSON.stringify(name);
+    if ((next === null || next === undefined ? undefined : next.type) === "text" && ID_CONTINUE.test(next.value[0])) {
+      return JSON.stringify(name);
+    }
+    return name;
+  }
+});
+
+// src/router-simple.ts
+var import_path_to_regexp = __toESM(require_dist(), 1);
+
+// src/server/parse-body.ts
+import url from "node:url";
+
+// src/utils/is-engine.ts
+var isNode = typeof process !== "undefined" && process.versions != null && process.versions.node != null;
+var isBrowser = typeof window !== "undefined" && typeof document !== "undefined" && typeof document.createElement === "function";
+var isDeno = typeof Deno !== "undefined" && typeof Deno.version === "object" && typeof Deno.version.deno === "string";
+var isBun = typeof Bun !== "undefined" && typeof Bun.version === "string";
+
+// src/server/parse-body.ts
+var parseBody = async (req) => {
+  const resolveBody = (body) => {
+    const contentType = req.headers["content-type"] || "";
+    const resolve = (data) => {
+      return data;
+    };
+    if (contentType.includes("application/json")) {
+      return resolve(JSON.parse(body));
+    }
+    if (contentType.includes("application/x-www-form-urlencoded")) {
+      const formData = new URLSearchParams(body);
+      const result = {};
+      formData.forEach((value, key) => {
+        try {
+          result[key] = JSON.parse(value);
+        } catch {
+          result[key] = value;
+        }
+      });
+      return resolve(result);
+    }
+    try {
+      return resolve(JSON.parse(body));
+    } catch {
+      return resolve({});
+    }
+  };
+  if (isBun) {
+    const body = req.body;
+    if (body) {
+      return resolveBody(body);
+    }
+    return {};
+  }
+  return new Promise((resolve, reject) => {
+    const arr = [];
+    req.on("data", (chunk) => {
+      arr.push(chunk);
+    });
+    req.on("end", () => {
+      try {
+        const body = Buffer.concat(arr).toString();
+        resolve(resolveBody(body));
+      } catch (e) {
+        resolve({});
+      }
+    });
+  });
+};
+var parseSearch = (req) => {
+  const parsedUrl = url.parse(req.url, true);
+  return parsedUrl.query;
+};
+var parseSearchValue = (value, opts) => {
+  if (!value)
+    return {};
+  const decode = opts?.decode ?? false;
+  if (decode) {
+    value = decodeURIComponent(value);
+  }
+  try {
+    return JSON.parse(value);
+  } catch (e) {
+    return {};
+  }
+};
+
+// src/router-simple.ts
+class SimpleRouter {
+  routes = [];
+  exclude = [];
+  constructor(opts) {
+    this.exclude = opts?.exclude || ["/api/router"];
+  }
+  getBody(req) {
+    return parseBody(req);
+  }
+  getSearch(req) {
+    return parseSearch(req);
+  }
+  parseSearchValue = parseSearchValue;
+  use(method, route, ...fns) {
+    const handlers = Array.isArray(fns) ? fns.flat() : [];
+    const pattern = import_path_to_regexp.pathToRegexp(route);
+    this.routes.push({ method: method.toLowerCase(), regexp: pattern.regexp, keys: pattern.keys, handlers });
+    return this;
+  }
+  get(route, ...fns) {
+    return this.use("get", route, ...fns);
+  }
+  post(route, ...fns) {
+    return this.use("post", route, ...fns);
+  }
+  sse(route, ...fns) {
+    return this.use("sse", route, ...fns);
+  }
+  all(route, ...fns) {
+    this.use("post", route, ...fns);
+    this.use("get", route, ...fns);
+    this.use("sse", route, ...fns);
+    return this;
+  }
+  getJson(v) {
+    if (typeof v === "object") {
+      return v;
+    }
+    try {
+      return JSON.parse(v);
+    } catch (e) {
+      return {};
+    }
+  }
+  isSse(req) {
+    const { headers } = req;
+    if (!headers)
+      return false;
+    if (headers["accept"] && headers["accept"].includes("text/event-stream")) {
+      return true;
+    }
+    if (headers["content-type"] && headers["content-type"].includes("text/event-stream")) {
+      return true;
+    }
+    return false;
+  }
+  parse(req, res) {
+    const { pathname } = new URL(req.url, "http://localhost");
+    let method = req.method.toLowerCase();
+    if (this.exclude.includes(pathname)) {
+      return "is_exclude";
+    }
+    const isSse = this.isSse(req);
+    if (isSse)
+      method = "sse";
+    const route = this.routes.find((route2) => {
+      const matchResult = route2.regexp.exec(pathname);
+      if (matchResult && route2.method === method) {
+        const params = {};
+        route2.keys.forEach((key, i) => {
+          params[key.name] = matchResult[i + 1];
+        });
+        req.params = params;
+        return true;
+      }
+    });
+    if (route) {
+      const { handlers } = route;
+      return handlers.reduce((promiseChain, handler) => promiseChain.then(() => Promise.resolve(handler(req, res))), Promise.resolve());
+    }
+    return "not_found";
+  }
+  chain(req, res) {
+    const chain = new HttpChain({ req, res, simpleRouter: this });
+    return chain;
+  }
+  static Chain(opts) {
+    return new HttpChain(opts);
+  }
+}
+
+class HttpChain {
+  req;
+  res;
+  simpleRouter;
+  server;
+  hasSetHeader = false;
+  isSseSet = false;
+  constructor(opts) {
+    if (opts?.res) {
+      this.res = opts.res;
+    }
+    if (opts?.req) {
+      this.req = opts.req;
+    }
+    this.simpleRouter = opts?.simpleRouter;
+  }
+  setReq(req) {
+    this.req = req;
+    return this;
+  }
+  setRes(res) {
+    this.res = res;
+    return this;
+  }
+  setRouter(router) {
+    this.simpleRouter = router;
+    return this;
+  }
+  setServer(server) {
+    this.server = server;
+    return this;
+  }
+  status(status) {
+    if (!this.res)
+      return this;
+    if (this.hasSetHeader) {
+      return this;
+    }
+    this.hasSetHeader = true;
+    this.res.writeHead(status);
+    return this;
+  }
+  writeHead(status) {
+    if (!this.res)
+      return this;
+    if (this.hasSetHeader) {
+      return this;
+    }
+    this.hasSetHeader = true;
+    this.res.writeHead(status);
+    return this;
+  }
+  json(data) {
+    if (!this.res)
+      return this;
+    this.res.end(JSON.stringify(data));
+    return this;
+  }
+  end(data) {
+    if (!this.res)
+      return this;
+    if (typeof data === "object") {
+      this.res.end(JSON.stringify(data));
+    } else if (typeof data === "string") {
+      this.res.end(data);
+    } else {
+      this.res.end("nothing");
+    }
+    return this;
+  }
+  listen(opts, callback) {
+    this.server.listen(opts, callback);
+    return this;
+  }
+  parse(opts) {
+    const { listenOptions, listenCallBack } = opts || {};
+    if (!this.server || !this.simpleRouter) {
+      throw new Error("Server and SimpleRouter must be set before calling parse");
+    }
+    const that = this;
+    const listener = (req, res) => {
+      try {
+        that.simpleRouter.parse(req, res);
+      } catch (error) {
+        console.error("Error parsing request:", error);
+        if (!res.headersSent) {
+          res.writeHead(500);
+          res.end(JSON.stringify({ code: 500, message: "Internal Server Error" }));
+        }
+      }
+    };
+    if (listenOptions) {
+      this.server.listen(listenOptions, listenCallBack);
+    }
+    this.server.on("request", listener);
+    return () => {
+      that.server.removeListener("request", listener);
+    };
+  }
+  getString(value) {
+    if (typeof value === "string") {
+      return value;
+    }
+    return JSON.stringify(value);
+  }
+  sse(value) {
+    const res = this.res;
+    const req = this.req;
+    if (!res || !req)
+      return;
+    const data = this.getString(value);
+    if (this.isSseSet) {
+      res.write(`data: ${data}
+
+`);
+      return this;
+    }
+    const headersMap = new Map([
+      ["Content-Type", "text/event-stream"],
+      ["Cache-Control", "no-cache"],
+      ["Connection", "keep-alive"]
+    ]);
+    this.isSseSet = true;
+    let intervalId;
+    if (!this.hasSetHeader) {
+      this.hasSetHeader = true;
+      res.setHeaders(headersMap);
+      setInterval(() => {
+        res.write(`
+`);
+      }, 3000);
+      req.on("close", () => {
+        clearInterval(intervalId);
+        res.end();
+      });
+    }
+    this.res.write(`data: ${data}
+
+`);
+    return this;
+  }
+  close() {
+    if (this.req?.destroy) {
+      this.req.destroy();
+    }
+    return this;
+  }
+}
+export {
+  SimpleRouter,
+  HttpChain
+};