js-routes 1.4.14 → 2.0.1

data/lib/js_routes/version.rb

@@ -1,3 +1,3 @@
 class JsRoutes
-  VERSION = "1.4.14"
+  VERSION = "2.0.1"
 end

data/lib/routes.d.ts

@@ -0,0 +1,64 @@
+/**
+ * File generated by js-routes RubyVariables.GEM_VERSION
+ * Based on Rails RubyVariables.RAILS_VERSION routes of RubyVariables.APP_CLASS
+ */
+declare type RouteParameter = unknown;
+declare type RouteParameters = Record<string, RouteParameter>;
+declare type Serializer = (value: unknown) => string;
+declare type RouteHelper = {
+  (...args: RouteParameter[]): string;
+  requiredParams(): string[];
+  toString(): string;
+};
+declare type RouteHelpers = Record<string, RouteHelper>;
+declare type Configuration = {
+  prefix: string;
+  default_url_options: RouteParameters;
+  special_options_key: string;
+  serializer: Serializer;
+};
+declare type Optional<T> = {
+  [P in keyof T]?: T[P] | null;
+};
+interface RouterExposedMethods {
+  config(): Configuration;
+  configure(arg: Partial<Configuration>): Configuration;
+  serialize: Serializer;
+}
+declare type KeywordUrlOptions = Optional<{
+  host: string;
+  protocol: string;
+  subdomain: string;
+  port: string;
+  anchor: string;
+  trailing_slash: boolean;
+}>;
+declare type PartsTable = Record<
+  string,
+  {
+    r?: boolean;
+    d?: unknown;
+  }
+>;
+declare type ModuleType = "CJS" | "AMD" | "UMD" | "ESM";
+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 | null;
+  WRAPPER: <T>(callback: T) => T;
+};
+declare const define:
+  | undefined
+  | (((arg: unknown[], callback: () => unknown) => void) & {
+      amd?: unknown;
+    });
+declare const module:
+  | {
+      exports: any;
+    }
+  | undefined;

data/lib/routes.js

@@ -1,528 +1,484 @@
-/*
-File generated by js-routes GEM_VERSION
-Based on Rails RAILS_VERSION routes of APP_CLASS
+/**
+ * File generated by js-routes RubyVariables.GEM_VERSION
+ * Based on Rails RubyVariables.RAILS_VERSION routes of RubyVariables.APP_CLASS
  */
-
-(function() {
-  var DeprecatedGlobbingBehavior, NodeTypes, ParameterMissing, ReservedOptions, SpecialOptionsKey, UriEncoderSegmentRegex, Utils, error, result,
-    hasProp = {}.hasOwnProperty,
-    slice = [].slice;
-
-  ParameterMissing = function(message, fileName, lineNumber) {
-    var instance;
-    instance = new Error(message, fileName, lineNumber);
-    if (Object.setPrototypeOf) {
-      Object.setPrototypeOf(instance, Object.getPrototypeOf(this));
-    } else {
-      instance.__proto__ = this.__proto__;
-    }
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(instance, ParameterMissing);
-    }
-    return instance;
-  };
-
-  ParameterMissing.prototype = Object.create(Error.prototype, {
-    constructor: {
-      value: Error,
-      enumerable: false,
-      writable: true,
-      configurable: true
+RubyVariables.WRAPPER((that) => {
+    const hasProp = (value, key) => Object.prototype.hasOwnProperty.call(value, key);
+    let NodeTypes;
+    (function (NodeTypes) {
+        NodeTypes[NodeTypes["GROUP"] = 1] = "GROUP";
+        NodeTypes[NodeTypes["CAT"] = 2] = "CAT";
+        NodeTypes[NodeTypes["SYMBOL"] = 3] = "SYMBOL";
+        NodeTypes[NodeTypes["OR"] = 4] = "OR";
+        NodeTypes[NodeTypes["STAR"] = 5] = "STAR";
+        NodeTypes[NodeTypes["LITERAL"] = 6] = "LITERAL";
+        NodeTypes[NodeTypes["SLASH"] = 7] = "SLASH";
+        NodeTypes[NodeTypes["DOT"] = 8] = "DOT";
+    })(NodeTypes || (NodeTypes = {}));
+    const Root = that;
+    const ModuleReferences = {
+        CJS: {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            define: (routes) => (module.exports = routes),
+            support: () => typeof module === "object",
+        },
+        AMD: {
+            define: (routes) => 
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            define([], function () {
+                return routes;
+            }),
+            support: () => typeof define === "function" && !!define.amd,
+        },
+        UMD: {
+            define: (routes) => {
+                if (ModuleReferences.AMD.support()) {
+                    ModuleReferences.AMD.define(routes);
+                }
+                else {
+                    if (ModuleReferences.CJS.support()) {
+                        try {
+                            ModuleReferences.CJS.define(routes);
+                        }
+                        catch (error) {
+                            if (error.name !== "TypeError")
+                                throw error;
+                        }
+                    }
+                }
+            },
+            support: () => ModuleReferences.AMD.support() || ModuleReferences.CJS.support(),
+        },
+        ESM: {
+            define: () => null,
+            support: () => true,
+        },
+    };
+    class ParametersMissing extends Error {
+        constructor(...keys) {
+            super(`Route missing required keys: ${keys.join(", ")}`);
+            this.keys = keys;
+            Object.setPrototypeOf(this, Object.getPrototypeOf(this));
+            this.name = ParametersMissing.name;
+        }
     }
-  });
-
-  if (Object.setPrototypeOf) {
-    Object.setPrototypeOf(ParameterMissing, Error);
-  } else {
-    ParameterMissing.__proto__ = Error;
-  }
-
-  NodeTypes = NODE_TYPES;
-
-  DeprecatedGlobbingBehavior = DEPRECATED_GLOBBING_BEHAVIOR;
-
-  SpecialOptionsKey = SPECIAL_OPTIONS_KEY;
-
-  UriEncoderSegmentRegex = /[^a-zA-Z0-9\-\._~!\$&'\(\)\*\+,;=:@]/g;
-
-  ReservedOptions = ['anchor', 'trailing_slash', 'subdomain', 'host', 'port', 'protocol'];
-
-  Utils = {
-    configuration: {
-      prefix: PREFIX,
-      default_url_options: DEFAULT_URL_OPTIONS,
-      special_options_key: SPECIAL_OPTIONS_KEY,
-      serializer: SERIALIZER
-    },
-    default_serializer: function(object, prefix) {
-      var element, i, j, key, len, prop, s;
-      if (prefix == null) {
-        prefix = null;
-      }
-      if (object == null) {
-        return "";
-      }
-      if (!prefix && !(this.get_object_type(object) === "object")) {
-        throw new Error("Url parameters should be a javascript hash");
-      }
-      s = [];
-      switch (this.get_object_type(object)) {
-        case "array":
-          for (i = j = 0, len = object.length; j < len; i = ++j) {
-            element = object[i];
-            s.push(this.default_serializer(element, prefix + "[]"));
-          }
-          break;
-        case "object":
-          for (key in object) {
-            if (!hasProp.call(object, key)) continue;
-            prop = object[key];
-            if ((prop == null) && (prefix != null)) {
-              prop = "";
-            }
-            if (prop != null) {
-              if (prefix != null) {
-                key = prefix + "[" + key + "]";
-              }
-              s.push(this.default_serializer(prop, key));
-            }
-          }
-          break;
-        default:
-          if (object != null) {
-            s.push((encodeURIComponent(prefix.toString())) + "=" + (encodeURIComponent(object.toString())));
-          }
-      }
-      if (!s.length) {
-        return "";
-      }
-      return s.join("&");
-    },
-    serialize: function(object) {
-      var custom_serializer;
-      custom_serializer = this.configuration.serializer;
-      if ((custom_serializer != null) && this.get_object_type(custom_serializer) === "function") {
-        return custom_serializer(object);
-      } else {
-        return this.default_serializer(object);
-      }
-    },
-    clean_path: function(path) {
-      var last_index;
-      path = path.split("://");
-      last_index = path.length - 1;
-      path[last_index] = path[last_index].replace(/\/+/g, "/");
-      return path.join("://");
-    },
-    extract_options: function(number_of_params, args) {
-      var last_el, options;
-      last_el = args[args.length - 1];
-      if ((args.length > number_of_params && last_el === void 0) || ((last_el != null) && "object" === this.get_object_type(last_el) && !this.looks_like_serialized_model(last_el))) {
-        options = args.pop() || {};
-        delete options[this.configuration.special_options_key];
-        return options;
-      } else {
-        return {};
-      }
-    },
-    looks_like_serialized_model: function(object) {
-      return !object[this.configuration.special_options_key] && ("id" in object || "to_param" in object);
-    },
-    path_identifier: function(object) {
-      var property;
-      if (object === 0) {
-        return "0";
-      }
-      if (!object) {
-        return "";
-      }
-      property = object;
-      if (this.get_object_type(object) === "object") {
-        if ("to_param" in object) {
-          if (object.to_param == null) {
-            throw new ParameterMissing("Route parameter missing: to_param");
-          }
-          property = object.to_param;
-        } else if ("id" in object) {
-          if (object.id == null) {
-            throw new ParameterMissing("Route parameter missing: id");
-          }
-          property = object.id;
-        } else {
-          property = object;
-        }
-        if (this.get_object_type(property) === "function") {
-          property = property.call(object);
-        }
-      }
-      return property.toString();
-    },
-    clone: function(obj) {
-      var attr, copy, key;
-      if ((obj == null) || "object" !== this.get_object_type(obj)) {
-        return obj;
-      }
-      copy = obj.constructor();
-      for (key in obj) {
-        if (!hasProp.call(obj, key)) continue;
-        attr = obj[key];
-        copy[key] = attr;
-      }
-      return copy;
-    },
-    merge: function() {
-      var tap, xs;
-      xs = 1 <= arguments.length ? slice.call(arguments, 0) : [];
-      tap = function(o, fn) {
-        fn(o);
-        return o;
-      };
-      if ((xs != null ? xs.length : void 0) > 0) {
-        return tap({}, function(m) {
-          var j, k, len, results, v, x;
-          results = [];
-          for (j = 0, len = xs.length; j < len; j++) {
-            x = xs[j];
-            results.push((function() {
-              var results1;
-              results1 = [];
-              for (k in x) {
-                v = x[k];
-                results1.push(m[k] = v);
-              }
-              return results1;
-            })());
-          }
-          return results;
-        });
-      }
-    },
-    normalize_options: function(parts, required_parts, default_options, actual_parameters) {
-      var i, j, key, len, options, part, parts_options, result, route_parts, url_parameters, use_all_parts, value;
-      options = this.extract_options(parts.length, actual_parameters);
-      if (actual_parameters.length > parts.length) {
-        throw new Error("Too many parameters provided for path");
-      }
-      use_all_parts = actual_parameters.length > required_parts.length;
-      parts_options = {};
-      for (key in options) {
-        if (!hasProp.call(options, key)) continue;
-        use_all_parts = true;
-        if (this.indexOf(parts, key) >= 0) {
-          parts_options[key] = value;
-        }
-      }
-      options = this.merge(this.configuration.default_url_options, default_options, options);
-      result = {};
-      url_parameters = {};
-      result['url_parameters'] = url_parameters;
-      for (key in options) {
-        if (!hasProp.call(options, key)) continue;
-        value = options[key];
-        if (this.indexOf(ReservedOptions, key) >= 0) {
-          result[key] = value;
-        } else {
-          url_parameters[key] = value;
-        }
-      }
-      route_parts = use_all_parts ? parts : required_parts;
-      i = 0;
-      for (j = 0, len = route_parts.length; j < len; j++) {
-        part = route_parts[j];
-        if (i < actual_parameters.length) {
-          if (!parts_options.hasOwnProperty(part)) {
-            url_parameters[part] = actual_parameters[i];
-            ++i;
-          }
-        }
-      }
-      return result;
-    },
-    build_route: function(parts, required_parts, default_options, route, full_url, args) {
-      var options, parameters, result, url, url_params;
-      args = Array.prototype.slice.call(args);
-      options = this.normalize_options(parts, required_parts, default_options, args);
-      parameters = options['url_parameters'];
-      result = "" + (this.get_prefix()) + (this.visit(route, parameters));
-      url = Utils.clean_path(result);
-      if (options['trailing_slash'] === true) {
-        url = url.replace(/(.*?)[\/]?$/, "$1/");
-      }
-      if ((url_params = this.serialize(parameters)).length) {
-        url += "?" + url_params;
-      }
-      url += options.anchor ? "#" + options.anchor : "";
-      if (full_url) {
-        url = this.route_url(options) + url;
-      }
-      return url;
-    },
-    visit: function(route, parameters, optional) {
-      var left, left_part, right, right_part, type, value;
-      if (optional == null) {
-        optional = false;
-      }
-      type = route[0], left = route[1], right = route[2];
-      switch (type) {
-        case NodeTypes.GROUP:
-          return this.visit(left, parameters, true);
-        case NodeTypes.STAR:
-          return this.visit_globbing(left, parameters, true);
-        case NodeTypes.LITERAL:
-        case NodeTypes.SLASH:
-        case NodeTypes.DOT:
-          return left;
-        case NodeTypes.CAT:
-          left_part = this.visit(left, parameters, optional);
-          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 "";
-          }
-          return "" + left_part + right_part;
-        case NodeTypes.SYMBOL:
-          value = parameters[left];
-          delete parameters[left];
-          if (value != null) {
-            return this.encode_segment(this.path_identifier(value));
-          }
-          if (optional) {
-            return "";
-          } else {
-            throw new ParameterMissing("Route parameter missing: " + left);
-          }
-          break;
-        default:
-          throw new Error("Unknown Rails node type");
-      }
-    },
-    encode_segment: function(segment) {
-      return segment.replace(UriEncoderSegmentRegex, function(str) {
-        return encodeURIComponent(str);
-      });
-    },
-    is_optional_node: function(node) {
-      return this.indexOf([NodeTypes.STAR, NodeTypes.SYMBOL, NodeTypes.CAT], node) >= 0;
-    },
-    build_path_spec: function(route, wildcard) {
-      var left, right, type;
-      if (wildcard == null) {
-        wildcard = false;
-      }
-      type = route[0], left = route[1], right = route[2];
-      switch (type) {
-        case NodeTypes.GROUP:
-          return "(" + (this.build_path_spec(left)) + ")";
-        case NodeTypes.CAT:
-          return "" + (this.build_path_spec(left)) + (this.build_path_spec(right));
-        case NodeTypes.STAR:
-          return this.build_path_spec(left, true);
-        case NodeTypes.SYMBOL:
-          if (wildcard === true) {
-            return "" + (left[0] === '*' ? '' : '*') + left;
-          } else {
-            return ":" + left;
-          }
-          break;
-        case NodeTypes.SLASH:
-        case NodeTypes.DOT:
-        case NodeTypes.LITERAL:
-          return left;
-        default:
-          throw new Error("Unknown Rails node type");
-      }
-    },
-    visit_globbing: function(route, parameters, optional) {
-      var left, right, type, value;
-      type = route[0], left = route[1], right = route[2];
-      value = parameters[left];
-      delete parameters[left];
-      if (value == null) {
-        return this.visit(route, parameters, optional);
-      }
-      value = (function() {
-        switch (this.get_object_type(value)) {
-          case "array":
-            return value.join("/");
-          default:
-            return value;
-        }
-      }).call(this);
-      if (DeprecatedGlobbingBehavior) {
-        return this.path_identifier(value);
-      } else {
-        return encodeURI(this.path_identifier(value));
-      }
-    },
-    get_prefix: function() {
-      var prefix;
-      prefix = this.configuration.prefix;
-      if (prefix !== "") {
-        prefix = (prefix.match("/$") ? prefix : prefix + "/");
-      }
-      return prefix;
-    },
-    route: function(parts_table, default_options, route_spec, full_url) {
-      var j, len, part, parts, path_fn, ref, required, required_parts;
-      required_parts = [];
-      parts = [];
-      for (j = 0, len = parts_table.length; j < len; j++) {
-        ref = parts_table[j], part = ref[0], required = ref[1];
-        parts.push(part);
-        if (required) {
-          required_parts.push(part);
-        }
-      }
-      path_fn = function() {
-        return Utils.build_route(parts, required_parts, default_options, route_spec, full_url, arguments);
-      };
-      path_fn.required_params = required_parts;
-      path_fn.toString = function() {
-        return Utils.build_path_spec(route_spec);
-      };
-      return path_fn;
-    },
-    route_url: function(route_defaults) {
-      var hostname, port, protocol, subdomain;
-      if (typeof route_defaults === 'string') {
-        return route_defaults;
-      }
-      hostname = route_defaults.host || Utils.current_host();
-      if (!hostname) {
-        return '';
-      }
-      subdomain = route_defaults.subdomain ? route_defaults.subdomain + '.' : '';
-      protocol = route_defaults.protocol || Utils.current_protocol();
-      port = route_defaults.port || (!route_defaults.host ? Utils.current_port() : void 0);
-      port = port ? ":" + port : '';
-      return protocol + "://" + subdomain + hostname + port;
-    },
-    has_location: function() {
-      return (typeof window !== "undefined" && window !== null ? window.location : void 0) != null;
-    },
-    current_host: function() {
-      if (this.has_location()) {
-        return window.location.hostname;
-      } else {
-        return null;
-      }
-    },
-    current_protocol: function() {
-      if (this.has_location() && window.location.protocol !== '') {
-        return window.location.protocol.replace(/:$/, '');
-      } else {
-        return 'http';
-      }
-    },
-    current_port: function() {
-      if (this.has_location() && window.location.port !== '') {
-        return window.location.port;
-      } else {
-        return '';
-      }
-    },
-    _classToTypeCache: null,
-    _classToType: function() {
-      var j, len, name, ref;
-      if (this._classToTypeCache != null) {
-        return this._classToTypeCache;
-      }
-      this._classToTypeCache = {};
-      ref = "Boolean Number String Function Array Date RegExp Object Error".split(" ");
-      for (j = 0, len = ref.length; j < len; j++) {
-        name = ref[j];
-        this._classToTypeCache["[object " + name + "]"] = name.toLowerCase();
-      }
-      return this._classToTypeCache;
-    },
-    get_object_type: function(obj) {
-      if (this.jQuery && (this.jQuery.type != null)) {
-        return this.jQuery.type(obj);
-      }
-      if (obj == null) {
-        return "" + obj;
-      }
-      if (typeof obj === "object" || typeof obj === "function") {
-        return this._classToType()[Object.prototype.toString.call(obj)] || "object";
-      } else {
-        return typeof obj;
-      }
-    },
-    indexOf: function(array, element) {
-      if (Array.prototype.indexOf) {
-        return array.indexOf(element);
-      } else {
-        return this.indexOfImplementation(array, element);
-      }
-    },
-    indexOfImplementation: function(array, element) {
-      var el, i, j, len, result;
-      result = -1;
-      for (i = j = 0, len = array.length; j < len; i = ++j) {
-        el = array[i];
-        if (el === element) {
-          result = i;
-        }
-      }
-      return result;
-    },
-    namespace: function(root, namespace, routes) {
-      var index, j, len, part, parts;
-      parts = namespace ? namespace.split(".") : [];
-      if (parts.length === 0) {
-        return routes;
-      }
-      for (index = j = 0, len = parts.length; j < len; index = ++j) {
-        part = parts[index];
-        if (index < parts.length - 1) {
-          root = (root[part] || (root[part] = {}));
-        } else {
-          return root[part] = routes;
-        }
-      }
-    },
-    configure: function(new_config) {
-      return this.configuration = this.merge(this.configuration, new_config);
-    },
-    config: function() {
-      return this.clone(this.configuration);
-    },
-    make: function() {
-      var routes;
-      routes = ROUTES;
-      routes.configure = function(config) {
-        return Utils.configure(config);
-      };
-      routes.config = function() {
-        return Utils.config();
-      };
-      routes.default_serializer = function(object, prefix) {
-        return Utils.default_serializer(object, prefix);
-      };
-      return Object.assign({
-        "default": routes
-      }, routes);
+    const DeprecatedGlobbingBehavior = RubyVariables.DEPRECATED_GLOBBING_BEHAVIOR;
+    const UriEncoderSegmentRegex = /[^a-zA-Z0-9\-._~!$&'()*+,;=:@]/g;
+    const ReservedOptions = [
+        "anchor",
+        "trailing_slash",
+        "subdomain",
+        "host",
+        "port",
+        "protocol",
+    ];
+    class UtilsClass {
+        constructor() {
+            this.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, prefix) {
+            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 = [];
+            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) {
+            return this.configuration.serializer(object);
+        }
+        extract_options(number_of_params, args) {
+            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,
+                };
+            }
+            else {
+                return { args, options: {} };
+            }
+        }
+        looks_like_serialized_model(object) {
+            return (this.is_object(object) &&
+                !object[this.configuration.special_options_key] &&
+                ("id" in object || "to_param" in object || "toParam" in object));
+        }
+        path_identifier(object) {
+            const result = this.unwrap_path_identifier(object);
+            return this.is_nullable(result) ? "" : "" + result;
+        }
+        unwrap_path_identifier(object) {
+            let result = 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, required_params, default_options, call_arguments) {
+            // 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 = {};
+            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 url_parameters = {};
+            const query_parameters = {};
+            for (const key in options) {
+                if (!hasProp(options, key))
+                    continue;
+                const value = options[key];
+                if (this.is_reserved_option(key)) {
+                    url_parameters[key] = value;
+                }
+                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) {
+                    if (!hasProp(parts_options, part)) {
+                        query_parameters[part] = args[i];
+                        ++i;
+                    }
+                }
+            }
+            return { url_parameters, query_parameters };
+        }
+        build_route(parts, required_params, default_options, route, full_url, args) {
+            const { url_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 (url_parameters.trailing_slash) {
+                result = result.replace(/(.*?)[/]?$/, "$1/");
+            }
+            const url_params = this.serialize(query_parameters);
+            if (url_params.length) {
+                result += "?" + url_params;
+            }
+            result += url_parameters.anchor ? "#" + url_parameters.anchor : "";
+            if (full_url) {
+                result = this.route_url(url_parameters) + result;
+            }
+            return result;
+        }
+        visit(route, parameters, optional = false) {
+            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(object) {
+            return !this.is_nullable(object);
+        }
+        is_nullable(object) {
+            return object === undefined || object === null;
+        }
+        visit_cat(
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        [_type, left, right], parameters, optional) {
+            const left_part = this.visit(left, parameters, optional);
+            const 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 "";
+            }
+            return left_part + right_part;
+        }
+        visit_symbol(
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        [_type, key], parameters, optional) {
+            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) {
+            return segment.replace(UriEncoderSegmentRegex, function (str) {
+                return encodeURIComponent(str);
+            });
+        }
+        is_optional_node(node) {
+            return [NodeTypes.STAR, NodeTypes.SYMBOL, NodeTypes.CAT].includes(node);
+        }
+        build_path_spec(route, wildcard = false) {
+            let key;
+            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, parameters, optional) {
+            const key = route[1];
+            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("/");
+            }
+            value = this.path_identifier(value);
+            return DeprecatedGlobbingBehavior ? "" + value : encodeURI("" + value);
+        }
+        get_prefix() {
+            const prefix = this.configuration.prefix;
+            return prefix.match("/$")
+                ? prefix.substring(0, prefix.length - 1)
+                : prefix;
+        }
+        route(parts_table, route_spec, full_url = false) {
+            const required_params = [];
+            const parts = [];
+            const default_options = {};
+            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) => {
+                return this.build_route(parts, required_params, default_options, route_spec, full_url, args);
+            };
+            result.requiredParams = () => required_params;
+            result.toString = () => {
+                return this.build_path_spec(route_spec);
+            };
+            return result;
+        }
+        route_url(route_defaults) {
+            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;
+        }
+        has_location() {
+            return this.is_not_nullable(window) && !!window.location;
+        }
+        current_host() {
+            if (this.has_location()) {
+                return window.location.hostname;
+            }
+            else {
+                return null;
+            }
+        }
+        current_protocol() {
+            if (this.has_location() && window.location.protocol !== "") {
+                return window.location.protocol.replace(/:$/, "");
+            }
+            else {
+                return "http";
+            }
+        }
+        current_port() {
+            if (this.has_location() && window.location.port !== "") {
+                return window.location.port;
+            }
+            else {
+                return "";
+            }
+        }
+        is_object(value) {
+            return (typeof value === "object" &&
+                Object.prototype.toString.call(value) === "[object Object]");
+        }
+        is_array(object) {
+            return object instanceof Array;
+        }
+        is_callable(object) {
+            return typeof object === "function" && !!object.call;
+        }
+        is_reserved_option(key) {
+            return ReservedOptions.includes(key);
+        }
+        namespace(object, namespace, routes) {
+            const parts = (namespace === null || namespace === void 0 ? void 0 : namespace.split(".")) || [];
+            if (parts.length === 0) {
+                return routes;
+            }
+            for (let index = 0; index < parts.length; index++) {
+                const part = parts[index];
+                if (index < parts.length - 1) {
+                    object = object[part] || (object[part] = {});
+                }
+                else {
+                    return (object[part] = routes);
+                }
+            }
+        }
+        configure(new_config) {
+            this.configuration = { ...this.configuration, ...new_config };
+            return this.configuration;
+        }
+        config() {
+            return { ...this.configuration };
+        }
+        is_module_supported(name) {
+            return ModuleReferences[name].support();
+        }
+        ensure_module_supported(name) {
+            if (!this.is_module_supported(name)) {
+                throw new Error(`${name} is not supported by runtime`);
+            }
+        }
+        define_module(name, module) {
+            if (!name) {
+                return;
+            }
+            this.ensure_module_supported(name);
+            ModuleReferences[name].define(module);
+        }
     }
-  };
-
-  result = Utils.make();
-
-  if (typeof define === "function" && define.amd) {
-    define([], function() {
-      return result;
-    });
-  } else if (typeof module !== "undefined" && module !== null) {
-    try {
-      module.exports = result;
-    } catch (error1) {
-      error = error1;
-      if (error.name !== 'TypeError') {
-        throw error;
-      }
+    const Utils = new UtilsClass();
+    // We want this helper name to be short
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const __jsr = {
+        r(parts_table, route_spec, full_url) {
+            return Utils.route(parts_table, route_spec, full_url);
+        },
+    };
+    const result = {
+        ...__jsr,
+        configure: (config) => {
+            return Utils.configure(config);
+        },
+        config: () => {
+            return Utils.config();
+        },
+        serialize: (object) => {
+            return Utils.serialize(object);
+        },
+        ...RubyVariables.ROUTES_OBJECT,
+    };
+    Utils.namespace(Root, RubyVariables.NAMESPACE, result);
+    if (RubyVariables.MODULE_TYPE) {
+        Utils.define_module(RubyVariables.MODULE_TYPE, result);
     }
-  } else {
-    Utils.namespace(this, NAMESPACE, result);
-  }
-
-  return result;
-
-}).call(this);
+    return result;
+})(this);
+//# sourceMappingURL=routes.js.map