@kevisual/router 0.1.2 → 0.1.4

package/dist/router-simple.js

@@ -1,708 +0,0 @@
-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.3.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 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];
-      const type = SIMPLE_TOKENS[value];
-      if (type) {
-        tokens.push({ type, index: index++, value });
-      } else if (value === "\\") {
-        tokens.push({ type: "escape", index: index++, value: chars[index++] });
-      } else if (value === ":") {
-        tokens.push({ type: "param", index: index++, value: name() });
-      } else if (value === "*") {
-        tokens.push({ type: "wildcard", index: index++, value: name() });
-      } else {
-        tokens.push({ type: "char", index: 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 keys = [];
-    const flags = sensitive ? "" : "i";
-    const sources = [];
-    for (const input of pathsToArray(path, [])) {
-      const data = typeof input === "object" ? input : parse(input, options);
-      for (const tokens of flatten(data.tokens, 0, [])) {
-        sources.push(toRegExpSource(tokens, delimiter, keys, data.originalPath));
-      }
-    }
-    let pattern = `^(?:${sources.join("|")})`;
-    if (trailing)
-      pattern += `(?:${escape(delimiter)}$)?`;
-    pattern += end ? "$" : `(?=${escape(delimiter)}|$)`;
-    const regexp = new RegExp(pattern, flags);
-    return { regexp, keys };
-  }
-  function pathsToArray(paths, init) {
-    if (Array.isArray(paths)) {
-      for (const p of paths)
-        pathsToArray(p, init);
-    } else {
-      init.push(paths);
-    }
-    return init;
-  }
-  function* flatten(tokens, index, init) {
-    if (index === tokens.length) {
-      return yield init;
-    }
-    const token = tokens[index];
-    if (token.type === "group") {
-      for (const seq of flatten(token.tokens, 0, init.slice())) {
-        yield* flatten(tokens, index + 1, seq);
-      }
-    } else {
-      init.push(token);
-    }
-    yield* flatten(tokens, index + 1, init);
-  }
-  function toRegExpSource(tokens, delimiter, keys, originalPath) {
-    let result = "";
-    let backtrack = "";
-    let isSafeSegmentParam = true;
-    for (const token of tokens) {
-      if (token.type === "text") {
-        result += escape(token.value);
-        backtrack += token.value;
-        isSafeSegmentParam || (isSafeSegmentParam = token.value.includes(delimiter));
-        continue;
-      }
-      if (token.type === "param" || token.type === "wildcard") {
-        if (!isSafeSegmentParam && !backtrack) {
-          throw new PathError(`Missing text before "${token.name}" ${token.type}`, originalPath);
-        }
-        if (token.type === "param") {
-          result += `(${negate(delimiter, isSafeSegmentParam ? "" : backtrack)}+)`;
-        } else {
-          result += `([\\s\\S]+)`;
-        }
-        keys.push(token);
-        backtrack = "";
-        isSafeSegmentParam = false;
-        continue;
-      }
-    }
-    return result;
-  }
-  function negate(delimiter, backtrack) {
-    if (backtrack.length < 2) {
-      if (delimiter.length < 2)
-        return `[^${escape(delimiter + backtrack)}]`;
-      return `(?:(?!${escape(delimiter)})[^${escape(backtrack)}])`;
-    }
-    if (delimiter.length < 2) {
-      return `(?:(?!${escape(backtrack)})[^${escape(delimiter)}])`;
-    }
-    return `(?:(?!${escape(backtrack)}|${escape(delimiter)})[\\s\\S])`;
-  }
-  function stringifyTokens(tokens) {
-    let value = "";
-    let i = 0;
-    function name(value2) {
-      const isSafe = isNameSafe(value2) && isNextNameSafe(tokens[i]);
-      return isSafe ? value2 : JSON.stringify(value2);
-    }
-    while (i < tokens.length) {
-      const token = tokens[i++];
-      if (token.type === "text") {
-        value += escapeText(token.value);
-        continue;
-      }
-      if (token.type === "group") {
-        value += `{${stringifyTokens(token.tokens)}}`;
-        continue;
-      }
-      if (token.type === "param") {
-        value += `:${name(token.name)}`;
-        continue;
-      }
-      if (token.type === "wildcard") {
-        value += `*${name(token.name)}`;
-        continue;
-      }
-      throw new TypeError(`Unknown token type: ${token.type}`);
-    }
-    return value;
-  }
-  function stringify(data) {
-    return stringifyTokens(data.tokens);
-  }
-  function isNameSafe(name) {
-    const [first, ...rest] = name;
-    return ID_START.test(first) && rest.every((char) => ID_CONTINUE.test(char));
-  }
-  function isNextNameSafe(token) {
-    if (token && token.type === "text")
-      return !ID_CONTINUE.test(token.value[0]);
-    return true;
-  }
-});
-
-// 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
-};