js-routes 1.4.14 → 2.0.4

data/lib/js_routes.rb

@@ -3,6 +3,7 @@ if defined?(::Rails) && defined?(::Sprockets::Railtie)
   require 'js_routes/engine'
 end
 require 'js_routes/version'
+require 'active_support/core_ext/string/indent'
 
 class JsRoutes
 
@@ -19,7 +20,7 @@ class JsRoutes
       sprockets_dir = Rails.root.join('app','assets','javascripts')
       sprockets_file = sprockets_dir.join('routes.js')
       webpacker_file = webpacker_dir.join('routes.js')
-      !Dir.exists?(webpacker_dir) && defined?(::Sprockets) ? sprockets_file : webpacker_file
+      !Dir.exist?(webpacker_dir) && defined?(::Sprockets) ? sprockets_file : webpacker_file
     end,
     prefix: -> { Rails.application.config.relative_url_root || "" },
     url_links: false,
@@ -28,7 +29,9 @@ class JsRoutes
     compact: false,
     serializer: nil,
     special_options_key: "_options",
-    application: -> { Rails.application }
+    application: -> { Rails.application },
+    module_type: 'ESM',
+    documentation: true,
   } #:nodoc:
 
   NODE_TYPES = {
@@ -42,7 +45,6 @@ class JsRoutes
     DOT: 8
   } #:nodoc:
 
-  LAST_OPTIONS_KEY = "options".freeze #:nodoc:
   FILTERED_DEFAULT_PARTS = [:controller, :action] #:nodoc:
   URL_OPTIONS = [:protocol, :domain, :host, :port, :subdomain] #:nodoc:
 
@@ -72,6 +74,10 @@ class JsRoutes
     def to_hash
       Hash[*members.zip(values).flatten(1)].symbolize_keys
     end
+
+    def esm?
+      self.module_type === 'ESM'
+    end
   end
 
   #
@@ -83,11 +89,6 @@ class JsRoutes
       configuration.tap(&block) if block
     end
 
-    def options
-      ActiveSupport::Deprecation.warn('JsRoutes.options method is deprecated use JsRoutes.configuration instead')
-      configuration
-    end
-
     def configuration
       @configuration ||= Configuration.new
     end
@@ -125,8 +126,7 @@ class JsRoutes
 
     {
       'GEM_VERSION'         => JsRoutes::VERSION,
-      'ROUTES'              => js_routes,
-      'NODE_TYPES'          => json(NODE_TYPES),
+      'ROUTES_OBJECT'              => routes_object,
       'RAILS_VERSION'       => ActionPack.version,
       'DEPRECATED_GLOBBING_BEHAVIOR' => ActionPack::VERSION::MAJOR == 4 && ActionPack::VERSION::MINOR == 0,
 
@@ -136,9 +136,12 @@ class JsRoutes
       'PREFIX'              => json(@configuration.prefix),
       'SPECIAL_OPTIONS_KEY' => json(@configuration.special_options_key),
       'SERIALIZER'          => @configuration.serializer || json(nil),
+      'MODULE_TYPE'         => json(@configuration.module_type),
+      'WRAPPER'             => @configuration.esm? ? 'const __jsr = ' : '',
     }.inject(File.read(File.dirname(__FILE__) + "/routes.js")) do |js, (key, value)|
-      js.gsub!(key, value.to_s)
-    end
+      js.gsub!("RubyVariables.#{key}", value.to_s) ||
+        raise("Missing key #{key} in JS template")
+    end + routes_export
   end
 
   def generate!(file_name = nil)
@@ -166,23 +169,45 @@ class JsRoutes
     @configuration.application
   end
 
+  def json(string)
+    self.class.json(string)
+  end
+
   def named_routes
     application.routes.named_routes.to_a
   end
 
-  def js_routes
-    js_routes = named_routes.sort_by(&:first).flat_map do |_, route|
-      [build_route_if_match(route)] + mounted_app_routes(route)
+  def routes_object
+    return json({}) if @configuration.esm?
+    properties = routes_list.map do |comment, name, body|
+      "#{comment}#{name}: #{body}".indent(2)
+    end
+    "{\n" + properties.join(",\n\n") + "}\n"
+  end
+
+  STATIC_EXPORTS = [:configure, :config, :serialize].map do |name|
+    ["", name, "__jsr.#{name}"]
+  end
+
+  def routes_export
+    return "" unless @configuration.esm?
+    [*STATIC_EXPORTS, *routes_list].map do |comment, name, body|
+      "#{comment}export const #{name} = #{body};"
+    end.join("\n\n")
+  end
+
+  def routes_list
+    named_routes.sort_by(&:first).flat_map do |_, route|
+      route_helpers_if_match(route) + mounted_app_routes(route)
     end.compact
-    "{\n" + js_routes.join(",\n") + "}\n"
   end
 
   def mounted_app_routes(route)
     rails_engine_app = get_app_from_route(route)
     if rails_engine_app.respond_to?(:superclass) &&
        rails_engine_app.superclass == Rails::Engine && !route.path.anchored
-      rails_engine_app.routes.named_routes.map do |_, engine_route|
-        build_route_if_match(engine_route, route)
+      rails_engine_app.routes.named_routes.flat_map do |_, engine_route|
+        route_helpers_if_match(engine_route, route)
       end
     else
       []
@@ -199,104 +224,149 @@ class JsRoutes
     end
   end
 
-  def build_route_if_match(route, parent_route = nil)
-    if any_match?(route, parent_route, @configuration[:exclude]) ||
-       !any_match?(route, parent_route, @configuration[:include])
-      nil
-    else
-      build_js(route, parent_route)
-    end
+  def route_helpers_if_match(route, parent_route = nil)
+    JsRoute.new(@configuration, route, parent_route).helpers
   end
 
-  def any_match?(route, parent_route, matchers)
-    full_route = [parent_route.try(:name), route.name].compact.join('_')
+  class JsRoute #:nodoc:
+    attr_reader :configuration, :route, :parent_route
 
-    matchers = Array(matchers)
-    matchers.any? { |regex| full_route =~ regex }
-  end
+    def initialize(configuration, route, parent_route = nil)
+      @configuration = configuration
+      @route = route
+      @parent_route = parent_route
+    end
 
-  def build_js(route, parent_route)
-    name = [parent_route.try(:name), route.name].compact
-    route_name = generate_route_name(name, (:path unless @configuration[:compact]))
-    parent_spec = parent_route.try(:path).try(:spec)
-    route_arguments = route_js_arguments(route, parent_spec)
-    url_link = generate_url_link(name, route_arguments)
-    <<-JS.strip!
-  // #{name.join('.')} => #{parent_spec}#{route.path.spec}
-  // function(#{build_params(route.required_parts)})
-  #{route_name}: Utils.route(#{route_arguments})#{",\n" + url_link if url_link.length > 0}
-  JS
-  end
+    def helpers
+      unless match_configuration?
+        []
+      else
+        [false, true].map do |absolute|
+          absolute && !@configuration[:url_links] ?
+            nil : [ documentation, helper_name(absolute), body(absolute) ]
+        end
+      end
+    end
 
-  def route_js_arguments(route, parent_spec)
-    required_parts = route.required_parts
-    parts_table = route.parts.each_with_object({}) do |part, hash|
-      hash[part] = required_parts.include?(part)
-    end
-    default_options = route.defaults.select do |part, _|
-      FILTERED_DEFAULT_PARTS.exclude?(part) &&
-        URL_OPTIONS.include?(part) || parts_table[part]
-    end
-    [
-      # JS objects don't preserve the order of properties which is crucial,
-      # so array is a better choice.
-      parts_table.to_a,
-      default_options,
-      serialize(route.path.spec, parent_spec)
-    ].map do |argument|
-      json(argument)
-    end.join(', ')
-  end
+    def body(absolute)
+      "__jsr.r(#{arguments(absolute).join(', ')})"
+    end
 
-  def generate_url_link(name, route_arguments)
-    return '' unless @configuration[:url_links]
+    def arguments(absolute)
+      absolute ? base_arguments + [json(true)] : base_arguments
+    end
 
-    <<-JS.strip!
-    #{generate_route_name(name, :url)}: Utils.route(#{route_arguments}, true)
-    JS
-  end
+    def match_configuration?
+      !match?(@configuration[:exclude]) && match?(@configuration[:include])
+    end
 
-  def generate_route_name(*parts)
-    route_name = parts.compact.join('_')
-    @configuration[:camel_case] ? route_name.camelize(:lower) : route_name
-  end
+    def base_name
+      @base_name ||= apply_case(parent_route&.name, route.name)
+    end
 
-  def json(string)
-    self.class.json(string)
-  end
+    def parent_spec
+      parent_route&.path&.spec
+    end
 
-  def build_params(required_parts)
-    params = required_parts + [LAST_OPTIONS_KEY]
-    params.join(', ')
-  end
+    def spec
+      route.path.spec
+    end
 
-  # This function serializes Journey route into JSON structure
-  # We do not use Hash for human readable serialization
-  # And preffer Array serialization because it is shorter.
-  # Routes.js file will be smaller.
-  def serialize(spec, parent_spec=nil)
-    return nil unless spec
-    # Rails 4 globbing requires * removal
-    return spec.tr(':*', '') if spec.is_a?(String)
-
-    result = serialize_spec(spec, parent_spec)
-    if parent_spec && result[1].is_a?(String)
-      result = [
-        # We encode node symbols as integer
-        # to reduce the routes.js file size
-        NODE_TYPES[:CAT],
-        serialize_spec(parent_spec),
-        result
-      ]
-    end
-    result
-  end
+    def json(value)
+      JsRoutes.json(value)
+    end
 
-  def serialize_spec(spec, parent_spec = nil)
-    [
-      NODE_TYPES[spec.type],
-      serialize(spec.left, parent_spec),
-      spec.respond_to?(:right) && serialize(spec.right)
-    ]
+    def helper_name(absolute)
+      suffix = absolute ? :url : @configuration[:compact] ? nil : :path
+      suffix ? apply_case(base_name, suffix) : base_name
+    end
+
+    def documentation
+      return nil unless @configuration[:documentation]
+      <<-JS
+/**
+ * Generates rails route to
+ * #{parent_spec}#{spec}#{documentation_params}
+ * @param {object | undefined} options
+ * @returns {string} route path
+ */
+JS
+    end
+
+    def required_parts
+      route.required_parts
+    end
+
+    protected
+
+    def base_arguments
+      return @base_arguments if defined?(@base_arguments)
+      parts_table = {}
+      route.parts.each do |part, hash|
+        parts_table[part] ||= {}
+        if required_parts.include?(part)
+          # Using shortened keys to reduce js file size
+          parts_table[part][:r] = true
+        end
+      end
+      route.defaults.each do |part, value|
+        if FILTERED_DEFAULT_PARTS.exclude?(part) &&
+          URL_OPTIONS.include?(part) || parts_table[part]
+          parts_table[part] ||= {}
+          # Using shortened keys to reduce js file size
+          parts_table[part][:d] = value
+        end
+      end
+      @base_arguments = [
+        parts_table, serialize(spec, parent_spec)
+      ].map do |argument|
+        json(argument)
+      end
+    end
+
+    def documentation_params
+      required_parts.map do |param|
+        "\n * @param {any} #{apply_case(param)}"
+      end.join
+    end
+
+    def match?(matchers)
+      Array(matchers).any? { |regex| base_name =~ regex }
+    end
+
+    def apply_case(*values)
+      value = values.compact.map(&:to_s).join('_')
+      @configuration[:camel_case] ? value.camelize(:lower) : value
+    end
+
+    # This function serializes Journey route into JSON structure
+    # We do not use Hash for human readable serialization
+    # And preffer Array serialization because it is shorter.
+    # Routes.js file will be smaller.
+    def serialize(spec, parent_spec=nil)
+      return nil unless spec
+      # Rails 4 globbing requires * removal
+      return spec.tr(':*', '') if spec.is_a?(String)
+
+      result = serialize_spec(spec, parent_spec)
+      if parent_spec && result[1].is_a?(String) && parent_spec.type != :SLASH
+        result = [
+          # We encode node symbols as integer
+          # to reduce the routes.js file size
+          NODE_TYPES[:CAT],
+          serialize_spec(parent_spec),
+          result
+        ]
+      end
+      result
+    end
+
+    def serialize_spec(spec, parent_spec = nil)
+      [
+        NODE_TYPES[spec.type],
+        serialize(spec.left, parent_spec),
+        spec.respond_to?(:right) ? serialize(spec.right) : nil
+      ].compact
+    end
   end
 end

data/lib/js_routes/version.rb

@@ -1,3 +1,3 @@
 class JsRoutes
-  VERSION = "1.4.14"
+  VERSION = "2.0.4"
 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,493 @@
-/*
-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 === false ? "" : "" + 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 keyword_parameters = {};
+            const query_parameters = {};
+            for (const key in options) {
+                if (!hasProp(options, key))
+                    continue;
+                const value = options[key];
+                if (this.is_reserved_option(key)) {
+                    keyword_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) {
+                    const value = args[i];
+                    if (!hasProp(parts_options, part)) {
+                        query_parameters[part] = value;
+                        ++i;
+                    }
+                }
+            }
+            return { keyword_parameters, query_parameters };
+        }
+        build_route(parts, required_params, default_options, route, absolute, args) {
+            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, 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);
+            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], 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("/");
+            }
+            const result = this.path_identifier(value);
+            return DeprecatedGlobbingBehavior ? result : encodeURI(result);
+        }
+        get_prefix() {
+            const prefix = this.configuration.prefix;
+            return prefix.match("/$")
+                ? prefix.substring(0, prefix.length - 1)
+                : prefix;
+        }
+        route(parts_table, route_spec, absolute = 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, absolute, 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
+    const __jsr = {
+        r(parts_table, route_spec, absolute) {
+            return Utils.route(parts_table, route_spec, absolute);
+        },
+    };
+    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