discord-embed-router 0.1.0 → 0.2.2

package/dist/index.mjs

@@ -1,10 +1,28 @@
 // src/EmbedRouter.ts
 import path from "path";
+import { createHash } from "crypto";
 import { match } from "path-to-regexp";
 
 // src/consts.ts
 var ID_PREFIX = "der";
-var BASE_URL = "x://x";
+var METHOD_TO_ENCODING = {
+  GET: "G",
+  POST: "P",
+  PUT: "U",
+  PATCH: "A",
+  DELETE: "D"
+};
+var ENCODING_TO_METHOD = {
+  G: "GET",
+  P: "POST",
+  U: "PUT",
+  A: "PATCH",
+  D: "DELETE"
+};
+var BASE_URL = "discord://embed.router";
+var PUA_START = 57344;
+var PUA_END = 63743;
+var PUA_RANGE = PUA_END - PUA_START + 1;
 
 // src/helpers/pathToString.ts
 import { parse, stringify, TokenData } from "path-to-regexp";
@@ -15,36 +33,127 @@ var pathToString = (path2, checkValidity = true) => {
   return typeof path2 === "string" ? path2 : stringify(path2);
 };
 
+// src/helpers/decodePath.ts
+import { compile } from "path-to-regexp";
+var decodePath = ({
+  idPrefix,
+  interaction
+}) => {
+  const customId = interaction.customId;
+  if (!customId.startsWith(idPrefix)) return false;
+  if (interaction.isButton()) {
+    return parseMethodAndPath(customId.slice(idPrefix.length));
+  } else if (interaction.isAnySelectMenu()) {
+    if (interaction.values.length === 0) return false;
+    const res = parseMethodAndPath(customId.slice(idPrefix.length));
+    if (!res) return false;
+    const { method, path: path2 } = res;
+    return {
+      method,
+      path: fillParams(path2, {
+        [interaction.isStringSelectMenu() ? "to" : interaction.isChannelSelectMenu() ? "channelId" : interaction.isRoleSelectMenu() ? "roleId" : "userId"]: interaction.values[0].split("/").slice(1)
+      })
+    };
+  }
+  return false;
+};
+var parseMethodAndPath = (pathWithMethod) => {
+  const firstSlash = pathWithMethod.indexOf("/");
+  if (firstSlash <= 0) return false;
+  const method = ENCODING_TO_METHOD[pathWithMethod.slice(0, firstSlash)];
+  if (method === void 0) return false;
+  return {
+    method,
+    path: pathWithMethod.slice(firstSlash)
+  };
+};
+var fillParams = (path2, params = {}) => {
+  const url = new URL(path2, BASE_URL);
+  const toPath = compile(url.pathname);
+  url.pathname = toPath(params);
+  for (const [key, value] of url.searchParams) {
+    if (value.startsWith(":") && key.slice(1) in params) {
+      const paramValue = params?.[key.slice(1)];
+      if (paramValue) {
+        url.searchParams.set(
+          key,
+          Array.isArray(paramValue) ? paramValue.join("/") : paramValue
+        );
+      } else {
+        url.searchParams.delete(key);
+      }
+    }
+  }
+  return `${url.pathname}${url.search}`;
+};
+
 // src/EmbedRouter.ts
 var EmbedRouter = class _EmbedRouter {
-  static usedIdentifiers = /* @__PURE__ */ new Set();
-  static generateUniqueIdentifier() {
-    const PUA_START = 57344;
-    const PUA_END = 63743;
-    let char;
-    do {
-      const codepoint = PUA_START + Math.floor(Math.random() * (PUA_END - PUA_START + 1));
-      char = String.fromCodePoint(codepoint);
-    } while (_EmbedRouter.usedIdentifiers.has(char));
-    _EmbedRouter.usedIdentifiers.add(char);
-    return char;
-  }
+  // identifier -> embedRouter
+  static #usedIdentifiers = /* @__PURE__ */ new Map();
+  // Name used to generate prefixes
+  #name = "";
   // Prefix for customIds of RouteButtonBuilders
-  idPrefix;
+  #idPrefix;
+  #identifier = "";
   getIdPrefix() {
-    return this.idPrefix;
+    return `${this.#idPrefix}${this.#identifier}`;
   }
   // All added routes
-  routes = [];
+  #routes = /* @__PURE__ */ new Map();
   /**
    *
+   * @param name the name to give the router. ensures buttons stay connected across restarts
    * @param idPrefix the prefix for RouteButtonBuilder customIds
    */
-  constructor(idPrefix = ID_PREFIX) {
+  constructor({
+    name = "",
+    idPrefix = ID_PREFIX
+  } = {}) {
+    if (_EmbedRouter.#usedIdentifiers.size >= PUA_RANGE) {
+      throw new Error(`You can not have more than ${PUA_RANGE} routers`);
+    }
     if (idPrefix.includes("/")) {
       throw new Error(`Prefix can't contain "/": ${idPrefix}`);
     }
-    this.idPrefix = `${idPrefix}${_EmbedRouter.generateUniqueIdentifier()}`;
+    this.#idPrefix = idPrefix;
+    this.#name = name;
+    this.#updateIdentifier();
+  }
+  #updateIdentifier() {
+    const hash = createHash("sha256").update(this.#name).digest();
+    let raw = hash.readUint32BE(0);
+    let char;
+    const nameCollisions = [];
+    while (true) {
+      const codepoint = PUA_START + raw++ % PUA_RANGE;
+      char = String.fromCodePoint(codepoint);
+      const collisionRouter = _EmbedRouter.#usedIdentifiers.get(char);
+      if (collisionRouter === void 0) break;
+      if (this.#name.length > 0 && collisionRouter.#name.length === 0) {
+        collisionRouter.#updateIdentifier();
+        break;
+      }
+      nameCollisions.push(collisionRouter);
+    }
+    _EmbedRouter.#usedIdentifiers.set(char, this);
+    if (nameCollisions.length > 0 && this.#name.length > 0) {
+      process.emitWarning(
+        `EmbedRouter identifier collision for name "${this.#name}" with ${nameCollisions.map((c) => `"${c.#name}"`).join(", ")}`,
+        "EmbedRouterWarning"
+      );
+    }
+    this.#identifier = char;
+  }
+  #addRoute(method, routePath, handler) {
+    const methodRoutes = this.#routes.get(method) ?? [];
+    methodRoutes.push({
+      method,
+      path: Array.isArray(routePath) ? routePath : [routePath],
+      matchFunction: match(routePath),
+      handler
+    });
+    this.#routes.set(method, methodRoutes);
   }
   /**
    * Registers a path with the router
@@ -52,12 +161,44 @@ var EmbedRouter = class _EmbedRouter {
    * @param routePath path to match with
    * @param handler function that generates the message when a path is matched
    */
-  on(routePath, handler) {
-    this.routes.push({
-      path: Array.isArray(routePath) ? routePath : [routePath],
-      matchFunction: match(routePath),
-      handler
-    });
+  get(routePath, handler) {
+    this.#addRoute("GET", routePath, handler);
+  }
+  /**
+   * Registers a path with the router
+   *
+   * @param routePath path to match with
+   * @param handler function that generates the message when a path is matched
+   */
+  post(routePath, handler) {
+    this.#addRoute("POST", routePath, handler);
+  }
+  /**
+   * Registers a path with the router
+   *
+   * @param routePath path to match with
+   * @param handler function that generates the message when a path is matched
+   */
+  put(routePath, handler) {
+    this.#addRoute("PUT", routePath, handler);
+  }
+  /**
+   * Registers a path with the router
+   *
+   * @param routePath path to match with
+   * @param handler function that generates the message when a path is matched
+   */
+  patch(routePath, handler) {
+    this.#addRoute("PATCH", routePath, handler);
+  }
+  /**
+   * Registers a path with the router
+   *
+   * @param routePath path to match with
+   * @param handler function that generates the message when a path is matched
+   */
+  delete(routePath, handler) {
+    this.#addRoute("DELETE", routePath, handler);
   }
   /**
    * Adds a subrouter to the router
@@ -67,11 +208,14 @@ var EmbedRouter = class _EmbedRouter {
    */
   use(routePath, embedRouter) {
     const pathString = pathToString(routePath);
-    for (const route of embedRouter.routes) {
-      this.on(
-        route.path.map((p) => path.posix.join(pathString, pathToString(p))),
-        route.handler
-      );
+    for (const [method, routes] of embedRouter.#routes) {
+      for (const route of routes) {
+        this.#addRoute(
+          method,
+          route.path.map((p) => path.posix.join(pathString, pathToString(p))),
+          route.handler
+        );
+      }
     }
   }
   /**
@@ -79,30 +223,36 @@ var EmbedRouter = class _EmbedRouter {
    *
    * @param interaction interactions from "interactionCreate" (filter for ButtonInteractions)
    */
-  async listener(interaction) {
-    if (!interaction.isButton()) return;
-    const customId = interaction.customId;
-    if (!customId.startsWith(this.idPrefix)) return;
-    const path2 = customId.slice(this.idPrefix.length);
-    this.dispatch(interaction, path2);
+  async listener(interaction, locals) {
+    const res = decodePath({ idPrefix: this.getIdPrefix(), interaction });
+    if (!res)
+      throw new Error(`Invalid component found: id ${interaction.customId}`);
+    this.dispatch({ interaction, method: res.method, path: res.path, locals });
   }
   /**
    * Connect or update an interaction message to a path
    *
    * @param interaction interaction to connect to
    * @param path path to route the interaction to
+   * @param method method to send to route
    * @param flags optional discord flags to send with message (only allowed on first reply)
    */
-  async dispatch(interaction, path2, flags) {
+  async dispatch({
+    interaction,
+    method = "GET",
+    path: path2,
+    flags,
+    locals
+  }) {
     if (interaction.isAutocomplete())
       throw new Error("Autocomplete Interactions aren't supported");
-    const resolvedRoute = this.resolve(pathToString(path2, false));
+    const resolvedRoute = this.#resolve(method, pathToString(path2, false));
     if (!resolvedRoute)
       throw new Error(`No route found for ${pathToString(path2, false)}`);
-    const routeResponse = resolvedRoute.handler(
-      interaction,
-      resolvedRoute.state
-    );
+    const routeResponse = await resolvedRoute.handler(interaction, {
+      ...resolvedRoute.state,
+      locals
+    });
     if (interaction.replied || interaction.deferred) {
       if (flags)
         throw new Error(
@@ -122,27 +272,61 @@ var EmbedRouter = class _EmbedRouter {
       });
     }
   }
-  resolve(routePath) {
+  #resolve(method, routePath) {
     const url = new URL(routePath, BASE_URL);
-    for (const route of this.routes) {
+    for (const route of this.#routes.get(method) ?? []) {
       const result = route.matchFunction(url.pathname);
       if (result) {
         return {
           state: {
             ...result,
-            searchParams: url.searchParams
+            query: url.searchParams,
+            embedRouter: this
           },
           handler: route.handler
         };
       }
     }
-    return null;
+    return false;
   }
 };
 
-// src/RouteButtonBuilder.ts
+// src/componentBuilders/RouteButtonBuilder.ts
 import { ButtonBuilder } from "discord.js";
+
+// src/helpers/encodePath.ts
+var encodePath = ({
+  idPrefix,
+  method,
+  path: path2,
+  query
+}) => {
+  const url = new URL(pathToString(path2), BASE_URL);
+  if (query) {
+    for (const [key, value] of new URLSearchParams(query)) {
+      url.searchParams.set(key, value);
+    }
+  }
+  return `${idPrefix}${METHOD_TO_ENCODING[method]}${url.pathname}${url.search}`;
+};
+
+// src/types/componentBuilders.ts
+var isSetOptions = (u) => {
+  return typeof u === "object" && u !== null && (!("method" in u) || "method" in u && typeof u.method === "string" || u.method === void 0) && "path" in u && typeof u.path === "string" && (!("query" in u) || "query" in u && typeof u.query in ["object", "string"] || u.query === void 0);
+};
+
+// src/componentBuilders/RouteButtonBuilder.ts
 var RouteButtonBuilder = class extends ButtonBuilder {
+  #embedRouter;
+  /**
+   *
+   * @param embedRouter the router you want to route with
+   * @param data the data to construct a component out of
+   */
+  constructor(embedRouter, data) {
+    super(data);
+    this.#embedRouter = embedRouter;
+  }
   /**
    * Not supported for RouteButtonBuilder
    *
@@ -153,7 +337,7 @@ var RouteButtonBuilder = class extends ButtonBuilder {
     throw new Error("setURL is not supported on RouteButtonBuilder");
   }
   /**
-   * Not supported for RouteButtonBuilder (setTo uses customId)
+   * Not supported for RouteButtonBuilder (use setTo)
    *
    * @remarks
    * @param
@@ -161,21 +345,300 @@ var RouteButtonBuilder = class extends ButtonBuilder {
   setCustomId() {
     throw new Error("setCustomId is not supported on RouteButtonBuilder");
   }
+  setTo(arg) {
+    const {
+      method = "GET",
+      path: path2,
+      query
+    } = isSetOptions(arg) ? arg : { path: arg };
+    super.setCustomId(
+      encodePath({
+        idPrefix: this.#embedRouter.getIdPrefix(),
+        method,
+        path: path2,
+        query
+      })
+    );
+    return this;
+  }
+};
+
+// src/componentBuilders/RouteStringSelectMenuBuilder.ts
+import {
+  normalizeArray,
+  StringSelectMenuBuilder
+} from "discord.js";
+
+// src/componentBuilders/RouteStringMenuOptionBuilder.ts
+import { StringSelectMenuOptionBuilder } from "discord.js";
+var RouteStringSelectMenuOptionBuilder = class extends StringSelectMenuOptionBuilder {
+  /**
+   * Not supported for RouteStringSelectMenuOptionBuilder (use setTo)
+   *
+   * @remarks
+   * @param
+   */
+  setValue() {
+    throw new Error(
+      "setValue is not supported on RouteStringSelectMenuOptionBuilder"
+    );
+  }
+  setTo(arg) {
+    const {
+      method = "GET",
+      path: path2,
+      query
+    } = isSetOptions(arg) ? arg : { path: arg };
+    super.setValue(
+      encodePath({
+        idPrefix: "",
+        method,
+        path: path2,
+        query
+      })
+    );
+    return this;
+  }
+};
+
+// src/componentBuilders/RouteStringSelectMenuBuilder.ts
+var RouteStringSelectMenuBuilder = class extends StringSelectMenuBuilder {
+  #embedRouter;
+  /**
+   *
+   * @param embedRouter the router you want to route with
+   * @param path the path to redirect to, :to or *to in path will be replaced with the selected user's id
+   * @param query any query parameters you want to add, :to will be replaced with the selected user's id
+   * @param data the data to construct a component out of
+   */
+  constructor(embedRouter, data) {
+    super(data);
+    this.#embedRouter = embedRouter;
+    super.setCustomId(
+      encodePath({
+        idPrefix: this.#embedRouter.getIdPrefix(),
+        method: "GET",
+        path: "/*to"
+      })
+    );
+  }
+  /**
+   * Not supported for RouteStringSelectMenuBuilder (customId set from embedRouter)
+   *
+   * @remarks
+   * @param
+   */
+  setCustomId() {
+    throw new Error(
+      "setCustomId is not supported on RouteStringSelectMenuBuilder"
+    );
+  }
+  /**
+   * Not supported for RouteStringSelectMenuBuilder (use addTos)
+   *
+   * @remarks
+   * @param
+   */
+  addOptions() {
+    throw new Error(
+      "addOptions is not supported on RouteStringSelectMenuBuilder"
+    );
+  }
+  /**
+   * Not supported for RouteStringSelectMenuBuilder (use setTos)
+   *
+   * @remarks
+   * @param
+   */
+  setOptions() {
+    throw new Error(
+      "setOptions is not supported on RouteStringSelectMenuBuilder"
+    );
+  }
+  /**
+   * Adds route select menu options to builder
+   *
+   * @param tos the list of route select menu options
+   */
+  addTos(...tos) {
+    const resolved = normalizeArray(tos);
+    super.addOptions(
+      resolved.map(
+        (o) => o instanceof RouteStringSelectMenuOptionBuilder ? o : new RouteStringSelectMenuOptionBuilder(o)
+      )
+    );
+    return this;
+  }
   /**
-   * Sets the path to route to when clicked
+   * Sets route select menu options to builder
    *
-   * @param path the path to route to
-   * @param idPrefix the prefix to add before the custom_id
+   * @param tos the list of route select menu options
    */
-  setTo(embedRouter, path2) {
-    const idPrefix = embedRouter.getIdPrefix();
-    const url = new URL(pathToString(path2, false), BASE_URL);
-    const customId = `${idPrefix}${url.pathname}${url.search}`;
-    super.setCustomId(customId);
+  setTos(...tos) {
+    const resolved = normalizeArray(tos);
+    super.setOptions(
+      resolved.map(
+        (o) => o instanceof RouteStringSelectMenuOptionBuilder ? o : new RouteStringSelectMenuOptionBuilder(o)
+      )
+    );
+    return this;
+  }
+  setPattern(arg) {
+    const {
+      method = "GET",
+      path: path2,
+      query
+    } = isSetOptions(arg) ? arg : { path: arg };
+    super.setCustomId(
+      encodePath({
+        idPrefix: this.#embedRouter.getIdPrefix(),
+        method,
+        path: path2,
+        query
+      })
+    );
+    return this;
+  }
+};
+
+// src/componentBuilders/RouteChannelSelectMenuBuilder.ts
+import {
+  ChannelSelectMenuBuilder
+} from "discord.js";
+var RouteChannelSelectMenuBuilder = class extends ChannelSelectMenuBuilder {
+  #embedRouter;
+  /**
+   *
+   * @param embedRouter the router you want to route with
+   * @param data the data to construct a component out of
+   */
+  constructor(embedRouter, data) {
+    super(data);
+    this.#embedRouter = embedRouter;
+  }
+  /**
+   * Not supported for RouteChannelSelectMenuBuilder (customId set from embedRouter)
+   *
+   * @remarks
+   * @param
+   */
+  setCustomId() {
+    throw new Error(
+      "setCustomId is not supported on RouteChannelSelectMenuBuilder"
+    );
+  }
+  setPattern(arg) {
+    const {
+      method = "GET",
+      path: path2,
+      query
+    } = isSetOptions(arg) ? arg : { path: arg };
+    super.setCustomId(
+      encodePath({
+        idPrefix: this.#embedRouter.getIdPrefix(),
+        method,
+        path: path2,
+        query
+      })
+    );
+    return this;
+  }
+};
+
+// src/componentBuilders/RouteRoleSelectMenuBuilder.ts
+import {
+  RoleSelectMenuBuilder
+} from "discord.js";
+var RouteRoleSelectMenuBuilder = class extends RoleSelectMenuBuilder {
+  #embedRouter;
+  /**
+   *
+   * @param embedRouter the router you want to route with
+   * @param data the data to construct a component out of
+   */
+  constructor(embedRouter, data) {
+    super(data);
+    this.#embedRouter = embedRouter;
+  }
+  /**
+   * Not supported for RouteRoleSelectMenuBuilder (customId set from embedRouter)
+   *
+   * @remarks
+   * @param
+   */
+  setCustomId() {
+    throw new Error(
+      "setCustomId is not supported on RouteRoleSelectMenuBuilder"
+    );
+  }
+  setPattern(arg) {
+    const {
+      method = "GET",
+      path: path2,
+      query
+    } = isSetOptions(arg) ? arg : { path: arg };
+    super.setCustomId(
+      encodePath({
+        idPrefix: this.#embedRouter.getIdPrefix(),
+        method,
+        path: path2,
+        query
+      })
+    );
+    return this;
+  }
+};
+
+// src/componentBuilders/RouteUserSelectMenuBuilder.ts
+import {
+  UserSelectMenuBuilder
+} from "discord.js";
+var RouteUserSelectMenuBuilder = class extends UserSelectMenuBuilder {
+  #embedRouter;
+  /**
+   *
+   * @param embedRouter the router you want to route with
+   * @param data the data to construct a component out of
+   */
+  constructor(embedRouter, data) {
+    super(data);
+    this.#embedRouter = embedRouter;
+  }
+  /**
+   * Not supported for RouteUserSelectMenuBuilder (customId set from embedRouter)
+   *
+   * @remarks
+   * @param
+   */
+  setCustomId() {
+    throw new Error(
+      "setCustomId is not supported on RouteUserSelectMenuBuilder"
+    );
+  }
+  setPattern(arg) {
+    const {
+      method = "GET",
+      path: path2,
+      query
+    } = isSetOptions(arg) ? arg : { path: arg };
+    super.setCustomId(
+      encodePath({
+        idPrefix: this.#embedRouter.getIdPrefix(),
+        method,
+        path: path2,
+        query
+      })
+    );
+    return this;
   }
 };
 export {
   EmbedRouter,
-  RouteButtonBuilder
+  RouteButtonBuilder,
+  RouteChannelSelectMenuBuilder,
+  RouteRoleSelectMenuBuilder,
+  RouteStringSelectMenuBuilder,
+  RouteStringSelectMenuOptionBuilder,
+  RouteUserSelectMenuBuilder
 };
 //# sourceMappingURL=index.mjs.map