js-routes 1.4.9 → 2.2.0

data/lib/routes.ts

@@ -0,0 +1,737 @@
+/**
+ * File generated by js-routes RubyVariables.GEM_VERSION
+ * Based on Rails RubyVariables.RAILS_VERSION routes of RubyVariables.APP_CLASS
+ */
+
+type Optional<T> = { [P in keyof T]?: T[P] | null };
+type BaseRouteParameter = string | boolean | Date | number;
+type MethodRouteParameter = BaseRouteParameter | (() => BaseRouteParameter);
+type ModelRouteParameter =
+  | { id: MethodRouteParameter }
+  | { to_param: MethodRouteParameter }
+  | { toParam: MethodRouteParameter };
+type RequiredRouteParameter = BaseRouteParameter | ModelRouteParameter;
+type OptionalRouteParameter = undefined | null | RequiredRouteParameter;
+type QueryRouteParameter =
+  | OptionalRouteParameter
+  | QueryRouteParameter[]
+  | { [k: string]: QueryRouteParameter };
+type RouteParameters = Record<string, QueryRouteParameter>;
+
+type Serializable = Record<string, unknown>;
+type Serializer = (value: Serializable) => string;
+type RouteHelperExtras = {
+  requiredParams(): string[];
+  toString(): string;
+};
+
+type RequiredParameters<T extends number> = T extends 1
+  ? [RequiredRouteParameter]
+  : T extends 2
+  ? [RequiredRouteParameter, RequiredRouteParameter]
+  : T extends 3
+  ? [RequiredRouteParameter, RequiredRouteParameter, RequiredRouteParameter]
+  : T extends 4
+  ? [
+      RequiredRouteParameter,
+      RequiredRouteParameter,
+      RequiredRouteParameter,
+      RequiredRouteParameter
+    ]
+  : RequiredRouteParameter[];
+
+type RouteHelperOptions<T extends string> = RouteOptions &
+  Optional<Record<T, OptionalRouteParameter>>;
+
+type RouteHelper<T extends number = number, U extends string = string> = ((
+  ...args: [...RequiredParameters<T>, RouteHelperOptions<U>]
+) => string) &
+  RouteHelperExtras;
+
+type RouteHelpers = Record<string, RouteHelper>;
+
+type Configuration = {
+  prefix: string;
+  default_url_options: RouteParameters;
+  special_options_key: string;
+  serializer: Serializer;
+};
+
+interface RouterExposedMethods {
+  config(): Configuration;
+  configure(arg: Partial<Configuration>): Configuration;
+  serialize: Serializer;
+}
+
+type KeywordUrlOptions = Optional<{
+  host: string;
+  protocol: string;
+  subdomain: string;
+  port: string | number;
+  anchor: string;
+  trailing_slash: boolean;
+}>;
+
+type RouteOptions = KeywordUrlOptions & RouteParameters;
+
+type PartsTable = Record<string, { r?: boolean; d?: OptionalRouteParameter }>;
+
+type ModuleType = "CJS" | "AMD" | "UMD" | "ESM" | "DTS" | "NIL";
+
+declare const RubyVariables: {
+  PREFIX: string;
+  DEPRECATED_GLOBBING_BEHAVIOR: boolean;
+  SPECIAL_OPTIONS_KEY: string;
+  DEFAULT_URL_OPTIONS: RouteParameters;
+  SERIALIZER: Serializer;
+  NAMESPACE: string;
+  ROUTES_OBJECT: RouteHelpers;
+  MODULE_TYPE: ModuleType;
+  WRAPPER: <T>(callback: T) => T;
+};
+
+declare const define:
+  | undefined
+  | (((arg: unknown[], callback: () => unknown) => void) & { amd?: unknown });
+
+declare const module: { exports: any } | undefined;
+
+RubyVariables.WRAPPER(
+  (that: unknown): RouterExposedMethods => {
+    const hasProp = (value: unknown, key: string) =>
+      Object.prototype.hasOwnProperty.call(value, key);
+    enum NodeTypes {
+      GROUP = 1,
+      CAT = 2,
+      SYMBOL = 3,
+      OR = 4,
+      STAR = 5,
+      LITERAL = 6,
+      SLASH = 7,
+      DOT = 8,
+    }
+    type RouteNodes = {
+      [NodeTypes.GROUP]: { left: RouteTree; right: never };
+      [NodeTypes.STAR]: { left: RouteTree; right: never };
+      [NodeTypes.LITERAL]: { left: string; right: never };
+      [NodeTypes.SLASH]: { left: "/"; right: never };
+      [NodeTypes.DOT]: { left: "."; right: never };
+      [NodeTypes.CAT]: { left: RouteTree; right: RouteTree };
+      [NodeTypes.SYMBOL]: { left: string; right: never };
+    };
+    type RouteNode<T extends keyof RouteNodes> = [
+      T,
+      RouteNodes[T]["left"],
+      RouteNodes[T]["right"]
+    ];
+    type RouteTree = {
+      [T in keyof RouteNodes]: RouteNode<T>;
+    }[keyof RouteNodes];
+
+    const Root = that;
+    const isBroswer = typeof window !== "undefined";
+    type ModuleDefinition = {
+      define: (routes: RouterExposedMethods) => void;
+      isSupported: () => boolean;
+    };
+    const ModuleReferences: Record<ModuleType, ModuleDefinition> = {
+      CJS: {
+        define(routes) {
+          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+          module!.exports = routes;
+        },
+        isSupported() {
+          return typeof module === "object";
+        },
+      },
+      AMD: {
+        define(routes) {
+          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+          define!([], function () {
+            return routes;
+          });
+        },
+        isSupported() {
+          return typeof define === "function" && !!define.amd;
+        },
+      },
+      UMD: {
+        define(routes) {
+          if (ModuleReferences.AMD.isSupported()) {
+            ModuleReferences.AMD.define(routes);
+          } else {
+            if (ModuleReferences.CJS.isSupported()) {
+              try {
+                ModuleReferences.CJS.define(routes);
+              } catch (error) {
+                if (error.name !== "TypeError") throw error;
+              }
+            }
+          }
+        },
+        isSupported() {
+          return (
+            ModuleReferences.AMD.isSupported() ||
+            ModuleReferences.CJS.isSupported()
+          );
+        },
+      },
+      ESM: {
+        define() {
+          // Module can only be defined using ruby code generation
+        },
+        isSupported() {
+          // Its impossible to check if "export" keyword is supported
+          return true;
+        },
+      },
+      NIL: {
+        define(routes) {
+          Utils.namespace(Root, RubyVariables.NAMESPACE, routes);
+        },
+        isSupported() {
+          return !RubyVariables.NAMESPACE || !!Root;
+        },
+      },
+      DTS: {
+        // Acts the same as ESM
+        define(routes) {
+          ModuleReferences.ESM.define(routes);
+        },
+        isSupported() {
+          return ModuleReferences.ESM.isSupported();
+        },
+      },
+    };
+
+    class ParametersMissing extends Error {
+      readonly keys: string[];
+      constructor(...keys: string[]) {
+        super(`Route missing required keys: ${keys.join(", ")}`);
+        this.keys = keys;
+        Object.setPrototypeOf(this, Object.getPrototypeOf(this));
+        this.name = ParametersMissing.name;
+      }
+    }
+
+    const UriEncoderSegmentRegex = /[^a-zA-Z0-9\-._~!$&'()*+,;=:@]/g;
+
+    const ReservedOptions = [
+      "anchor",
+      "trailing_slash",
+      "subdomain",
+      "host",
+      "port",
+      "protocol",
+    ] as const;
+    type ReservedOption = typeof ReservedOptions[any];
+
+    class UtilsClass {
+      configuration: Configuration = {
+        prefix: RubyVariables.PREFIX,
+        default_url_options: RubyVariables.DEFAULT_URL_OPTIONS,
+        special_options_key: RubyVariables.SPECIAL_OPTIONS_KEY,
+        serializer:
+          RubyVariables.SERIALIZER || this.default_serializer.bind(this),
+      };
+
+      default_serializer(value: any, prefix?: string | null): string {
+        if (this.is_nullable(value)) {
+          return "";
+        }
+        if (!prefix && !this.is_object(value)) {
+          throw new Error("Url parameters should be a javascript hash");
+        }
+        prefix = prefix || "";
+        const result: string[] = [];
+        if (this.is_array(value)) {
+          for (const element of value) {
+            result.push(this.default_serializer(element, prefix + "[]"));
+          }
+        } else if (this.is_object(value)) {
+          for (let key in value) {
+            if (!hasProp(value, key)) continue;
+            let prop = value[key];
+            if (this.is_nullable(prop) && prefix) {
+              prop = "";
+            }
+            if (this.is_not_nullable(prop)) {
+              if (prefix) {
+                key = prefix + "[" + key + "]";
+              }
+              result.push(this.default_serializer(prop, key));
+            }
+          }
+        } else {
+          if (this.is_not_nullable(value)) {
+            result.push(
+              encodeURIComponent(prefix) + "=" + encodeURIComponent("" + value)
+            );
+          }
+        }
+        return result.join("&");
+      }
+
+      serialize(object: Serializable): string {
+        return this.configuration.serializer(object);
+      }
+
+      extract_options(
+        number_of_params: number,
+        args: OptionalRouteParameter[]
+      ): {
+        args: OptionalRouteParameter[];
+        options: RouteOptions;
+      } {
+        const last_el = args[args.length - 1];
+        if (
+          (args.length > number_of_params && last_el === 0) ||
+          (this.is_object(last_el) &&
+            !this.looks_like_serialized_model(last_el))
+        ) {
+          if (this.is_object(last_el)) {
+            delete last_el[this.configuration.special_options_key];
+          }
+          return {
+            args: args.slice(0, args.length - 1),
+            options: (last_el as any) as RouteOptions,
+          };
+        } else {
+          return { args, options: {} };
+        }
+      }
+
+      looks_like_serialized_model(object: any): object is ModelRouteParameter {
+        return (
+          this.is_object(object) &&
+          !(this.configuration.special_options_key in object) &&
+          ("id" in object || "to_param" in object || "toParam" in object)
+        );
+      }
+
+      path_identifier(object: QueryRouteParameter): string {
+        const result = this.unwrap_path_identifier(object);
+        return this.is_nullable(result) || result === false ? "" : "" + result;
+      }
+
+      unwrap_path_identifier(object: QueryRouteParameter): unknown {
+        let result: any = object;
+        if (!this.is_object(object)) {
+          return object;
+        }
+        if ("to_param" in object) {
+          result = object.to_param;
+        } else if ("toParam" in object) {
+          result = object.toParam;
+        } else if ("id" in object) {
+          result = object.id;
+        } else {
+          result = object;
+        }
+        return this.is_callable(result) ? result.call(object) : result;
+      }
+
+      partition_parameters(
+        parts: string[],
+        required_params: string[],
+        default_options: RouteParameters,
+        call_arguments: OptionalRouteParameter[]
+      ): {
+        keyword_parameters: KeywordUrlOptions;
+        query_parameters: RouteParameters;
+      } {
+        // eslint-disable-next-line prefer-const
+        let { args, options } = this.extract_options(
+          parts.length,
+          call_arguments
+        );
+        if (args.length > parts.length) {
+          throw new Error("Too many parameters provided for path");
+        }
+        let use_all_parts = args.length > required_params.length;
+        const parts_options: RouteParameters = {
+          ...this.configuration.default_url_options,
+        };
+        for (const key in options) {
+          const value = options[key];
+          if (!hasProp(options, key)) continue;
+          use_all_parts = true;
+          if (parts.includes(key)) {
+            parts_options[key] = value;
+          }
+        }
+        options = {
+          ...this.configuration.default_url_options,
+          ...default_options,
+          ...options,
+        };
+
+        const keyword_parameters: KeywordUrlOptions = {};
+        const query_parameters: RouteParameters = {};
+        for (const key in options) {
+          if (!hasProp(options, key)) continue;
+          const value = options[key];
+          if (this.is_reserved_option(key)) {
+            keyword_parameters[key] = value as any;
+          } else {
+            if (
+              !this.is_nullable(value) &&
+              (value !== default_options[key] || required_params.includes(key))
+            ) {
+              query_parameters[key] = value;
+            }
+          }
+        }
+        const route_parts = use_all_parts ? parts : required_params;
+        let i = 0;
+        for (const part of route_parts) {
+          if (i < args.length) {
+            const value = args[i];
+            if (!hasProp(parts_options, part)) {
+              query_parameters[part] = value;
+              ++i;
+            }
+          }
+        }
+        return { keyword_parameters, query_parameters };
+      }
+      build_route(
+        parts: string[],
+        required_params: string[],
+        default_options: RouteParameters,
+        route: RouteTree,
+        absolute: boolean,
+        args: OptionalRouteParameter[]
+      ): string {
+        const {
+          keyword_parameters,
+          query_parameters,
+        } = this.partition_parameters(
+          parts,
+          required_params,
+          default_options,
+          args
+        );
+        const missing_params = required_params.filter(
+          (param) =>
+            !hasProp(query_parameters, param) ||
+            this.is_nullable(query_parameters[param])
+        );
+        if (missing_params.length) {
+          throw new ParametersMissing(...missing_params);
+        }
+        let result = this.get_prefix() + this.visit(route, query_parameters);
+        if (keyword_parameters.trailing_slash) {
+          result = result.replace(/(.*?)[/]?$/, "$1/");
+        }
+        const url_params = this.serialize(query_parameters);
+        if (url_params.length) {
+          result += "?" + url_params;
+        }
+        result += keyword_parameters.anchor
+          ? "#" + keyword_parameters.anchor
+          : "";
+        if (absolute) {
+          result = this.route_url(keyword_parameters) + result;
+        }
+        return result;
+      }
+
+      visit(
+        route: RouteTree,
+        parameters: RouteParameters,
+        optional = false
+      ): string {
+        switch (route[0]) {
+          case NodeTypes.GROUP:
+            return this.visit(route[1], parameters, true);
+          case NodeTypes.CAT:
+            return this.visit_cat(route, parameters, optional);
+          case NodeTypes.SYMBOL:
+            return this.visit_symbol(route, parameters, optional);
+          case NodeTypes.STAR:
+            return this.visit_globbing(route[1], parameters, true);
+          case NodeTypes.LITERAL:
+          case NodeTypes.SLASH:
+          case NodeTypes.DOT:
+            return route[1];
+          default:
+            throw new Error("Unknown Rails node type");
+        }
+      }
+
+      is_not_nullable<T>(object: T): object is NonNullable<T> {
+        return !this.is_nullable(object);
+      }
+
+      is_nullable(object: unknown): object is null | undefined {
+        return object === undefined || object === null;
+      }
+
+      visit_cat(
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        [_type, left, right]: RouteNode<NodeTypes.CAT>,
+        parameters: RouteParameters,
+        optional: boolean
+      ): string {
+        const left_part = this.visit(left, parameters, optional);
+        let right_part = this.visit(right, parameters, optional);
+        if (
+          optional &&
+          ((this.is_optional_node(left[0]) && !left_part) ||
+            (this.is_optional_node(right[0]) && !right_part))
+        ) {
+          return "";
+        }
+        // if left_part ends on '/' and right_part starts on '/'
+        if (left_part[left_part.length - 1] === "/" && right_part[0] === "/") {
+          // strip slash from right_part
+          // to prevent double slash
+          right_part = right_part.substring(1);
+        }
+        return left_part + right_part;
+      }
+
+      visit_symbol(
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        [_type, key]: RouteNode<NodeTypes.SYMBOL>,
+        parameters: RouteParameters,
+        optional: boolean
+      ): string {
+        const value = this.path_identifier(parameters[key]);
+        delete parameters[key];
+        if (value.length) {
+          return this.encode_segment(value);
+        }
+        if (optional) {
+          return "";
+        } else {
+          throw new ParametersMissing(key);
+        }
+      }
+
+      encode_segment(segment: string): string {
+        return segment.replace(UriEncoderSegmentRegex, (str) =>
+          encodeURIComponent(str)
+        );
+      }
+
+      is_optional_node(node: NodeTypes): boolean {
+        return [NodeTypes.STAR, NodeTypes.SYMBOL, NodeTypes.CAT].includes(node);
+      }
+
+      build_path_spec(route: RouteTree, wildcard = false): string {
+        let key: string;
+        switch (route[0]) {
+          case NodeTypes.GROUP:
+            return "(" + this.build_path_spec(route[1]) + ")";
+          case NodeTypes.CAT:
+            return (
+              this.build_path_spec(route[1]) + this.build_path_spec(route[2])
+            );
+          case NodeTypes.STAR:
+            return this.build_path_spec(route[1], true);
+          case NodeTypes.SYMBOL:
+            key = route[1];
+            if (wildcard) {
+              return (key.startsWith("*") ? "" : "*") + key;
+            } else {
+              return ":" + key;
+            }
+            break;
+          case NodeTypes.SLASH:
+          case NodeTypes.DOT:
+          case NodeTypes.LITERAL:
+            return route[1];
+          default:
+            throw new Error("Unknown Rails node type");
+        }
+      }
+
+      visit_globbing(
+        route: RouteTree,
+        parameters: RouteParameters,
+        optional: boolean
+      ): string {
+        const key = route[1] as string;
+        let value = parameters[key];
+        delete parameters[key];
+        if (this.is_nullable(value)) {
+          return this.visit(route, parameters, optional);
+        }
+        if (this.is_array(value)) {
+          value = value.join("/");
+        }
+        const result = this.path_identifier(value as any);
+        return RubyVariables.DEPRECATED_GLOBBING_BEHAVIOR
+          ? result
+          : encodeURI(result);
+      }
+
+      get_prefix(): string {
+        const prefix = this.configuration.prefix;
+        return prefix.match("/$")
+          ? prefix.substring(0, prefix.length - 1)
+          : prefix;
+      }
+
+      route(
+        parts_table: PartsTable,
+        route_spec: RouteTree,
+        absolute = false
+      ): RouteHelper {
+        const required_params: string[] = [];
+        const parts: string[] = [];
+        const default_options: RouteParameters = {};
+        for (const [part, { r: required, d: value }] of Object.entries(
+          parts_table
+        )) {
+          parts.push(part);
+          if (required) {
+            required_params.push(part);
+          }
+          if (this.is_not_nullable(value)) {
+            default_options[part] = value;
+          }
+        }
+        const result = (...args: OptionalRouteParameter[]): string => {
+          return this.build_route(
+            parts,
+            required_params,
+            default_options,
+            route_spec,
+            absolute,
+            args
+          );
+        };
+        result.requiredParams = () => required_params;
+        result.toString = () => {
+          return this.build_path_spec(route_spec);
+        };
+        return result as any;
+      }
+
+      route_url(route_defaults: KeywordUrlOptions): string {
+        const hostname = route_defaults.host || this.current_host();
+        if (!hostname) {
+          return "";
+        }
+        const subdomain = route_defaults.subdomain
+          ? route_defaults.subdomain + "."
+          : "";
+        const protocol = route_defaults.protocol || this.current_protocol();
+        let port =
+          route_defaults.port ||
+          (!route_defaults.host ? this.current_port() : undefined);
+        port = port ? ":" + port : "";
+        return protocol + "://" + subdomain + hostname + port;
+      }
+
+      current_host(): string {
+        return (isBroswer && window?.location?.hostname) || "";
+      }
+
+      current_protocol(): string {
+        return (
+          (isBroswer && window?.location?.protocol?.replace(/:$/, "")) || "http"
+        );
+      }
+
+      current_port(): string {
+        return (isBroswer && window?.location?.port) || "";
+      }
+
+      is_object(value: unknown): value is Record<string, unknown> {
+        return (
+          typeof value === "object" &&
+          Object.prototype.toString.call(value) === "[object Object]"
+        );
+      }
+
+      is_array<T>(object: unknown | T[]): object is T[] {
+        return object instanceof Array;
+      }
+
+      is_callable(object: unknown): object is Function {
+        return typeof object === "function" && !!object.call;
+      }
+
+      is_reserved_option(key: unknown): key is ReservedOption {
+        return ReservedOptions.includes(key as any);
+      }
+
+      namespace(
+        object: any,
+        namespace: string | null | undefined,
+        routes: unknown
+      ): void {
+        const parts = namespace?.split(".") || [];
+        if (parts.length === 0) {
+          return;
+        }
+        for (let index = 0; index < parts.length; index++) {
+          const part = parts[index];
+          if (index < parts.length - 1) {
+            object = object[part] || (object[part] = {});
+          } else {
+            object[part] = routes;
+          }
+        }
+      }
+
+      configure(new_config: Partial<Configuration>): Configuration {
+        this.configuration = { ...this.configuration, ...new_config };
+        return this.configuration;
+      }
+
+      config(): Configuration {
+        return { ...this.configuration };
+      }
+
+      is_module_supported(name: ModuleType): boolean {
+        return ModuleReferences[name].isSupported();
+      }
+
+      ensure_module_supported(name: ModuleType): void {
+        if (!this.is_module_supported(name)) {
+          throw new Error(`${name} is not supported by runtime`);
+        }
+      }
+
+      define_module(name: ModuleType, module: RouterExposedMethods): void {
+        this.ensure_module_supported(name);
+        ModuleReferences[name].define(module);
+      }
+    }
+
+    const Utils = new UtilsClass();
+
+    // We want this helper name to be short
+    const __jsr = {
+      r(
+        parts_table: PartsTable,
+        route_spec: RouteTree,
+        absolute?: boolean
+      ): RouteHelper {
+        return Utils.route(parts_table, route_spec, absolute);
+      },
+    };
+
+    const result = {
+      ...__jsr,
+      configure: (config: Partial<Configuration>) => {
+        return Utils.configure(config);
+      },
+      config: (): Configuration => {
+        return Utils.config();
+      },
+      serialize: (object: Serializable): string => {
+        return Utils.serialize(object);
+      },
+      ...RubyVariables.ROUTES_OBJECT,
+    };
+
+    Utils.define_module(RubyVariables.MODULE_TYPE, result);
+    return result;
+  }
+)(this);