js-routes 2.2.9 → 2.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d890e17e32f816311de89a16506fca4b8ff905ea773c7a8d198343e0270eb50a
-  data.tar.gz: 934c79a8b93e7129778e07789f93ac90d4183bd39ea578551f4ea9ca6cab22d2
+  metadata.gz: 8030ebf1b79303bfad35b2003ced97e6ec398b8bab459bf0f867006c9bc5d763
+  data.tar.gz: 4d84acaa15dacc791f26e059cb620d5c08d90891103fa5d73750d4bae3973e8b
 SHA512:
-  metadata.gz: 6adcfbfefbbf13c8f46198f9bf2ca47efdac35aa8d28a8b17be7b8af65d321a3ba0da30dd26e40c4a329c359f1a02b865adb74a1d5e3d024b61bae7fd6f8d9e0
-  data.tar.gz: 9cc86f32f79975aace5a264ef94d7bbe1afb41a7a141c738969c762479789fa74b1fb752139320f8ddd7c25b2eb164fe14cbcc3c6eb1a40046549538c3a6eb33
+  metadata.gz: 24e4500fcf1f799633343366f84d619060cd57979edc25a9f83ec17baf6a505e3fbbd838f66b6ec70618bf7d991a0f0614a3c6ad02ce85a90931e4a047f168a6
+  data.tar.gz: 7cab5ccd03712368ea32d43604381b32491ada2a933bf656b6efa0002132e638653f250e5a5037487e36c6ecfed01454d6df359e2e308b5fc7cd237c7af2fca2

data/CHANGELOG.md

@@ -1,15 +1,27 @@
 # Changelog
 
-## master
+## v2.3.0
+
+* Drop support of Rails 4.x
+* Fix support of shakapacker [#321](https://github.com/railsware/js-routes/issue/321).
+* Fix support for Rails 8 [#319](https://github.com/railsware/js-routes/issue/319)
+* Deprecated `rake js:routes:typescript`.
+  `rake js:routes` now automatically detects if types support can be used on not.
 
 ## v2.2.10
 
-* Fix middleware error for non-modern setup.
+* Remove sorbet files from repo
+* Clearly define files included in gem
+* Fix Middleware and Middleware generator bugs [#316](https://github.com/railsware/js-routes/issue/316)
+* Remove empty object linter warning on DTS module
+* Generators: Add `.ts` extension when searching for main JS file of the project
 
 ## v2.2.9
 
+* Fix middleware error for non-modern setup.
 * Added [Sorbet](https://sorbet.org/) method signatures.
-* Always use DTS module type when calling JsRoutes.definitions or .definitions!. [#313](https://github.com/railsware/js-routes/issues/313)
+* Always use DTS module type when calling JsRoutes.definitions or .definitions!.
+  [#313](https://github.com/railsware/js-routes/issues/313)
 
 ## v2.2.8
 

data/Readme.md

@@ -2,7 +2,16 @@
 
 [![CI](https://github.com/railsware/js-routes/actions/workflows/ci.yml/badge.svg)](https://github.com/railsware/js-routes/actions/workflows/ci.yml)
 
-Generates javascript file that defines all Rails named routes as javascript helpers
+Generates javascript file that defines all Rails named routes as javascript helpers:
+
+``` js
+import { root_path, api_user_path } from './routes';
+
+root_path() # => /
+api_user_path(25, include_profile: true, format: 'json') // => /api/users/25.json?include_profile=true
+```
+
+[More Examples](#usage)
 
 ## Intallation
 
@@ -348,7 +357,7 @@ Configuration above will create a nice javascript file with `Routes` object that
 ``` js
 import {
   user_path, user_project_path, company_path
-} as Routes from 'routes';
+} from 'routes';
 
 users_path() 
   // => "/users"
@@ -459,15 +468,13 @@ console.log(routes.inbox_path); // OK, only `inbox_path` is included in the bund
 console.log(Object.keys(routes)); // forces bundler to include all exports, breaking tree shaking
 ```
 
-### Exclude option
+### Exclude/Include options
 
 Split your routes into multiple files related to each section of your website like:
 
-``` javascript
-// admin-routes.js.erb
-<%= JsRoutes.generate(include: /^admin_/) %>
-// app-routes.js.erb
-<%= JsRoutes.generate(exclude: /^admin_/) %>
+``` ruby
+JsRoutes.generate!('app/javascript/admin-routes.js', include: /^admin_/) %>
+JsRoutes.generate!('app/javascript/app-routes.js', exclude: /^admin_/) %>
 ```
 
 ## Advantages over alternatives
@@ -475,17 +482,11 @@ Split your routes into multiple files related to each section of your website li
 There are some alternatives available. Most of them has only basic feature and don't reach the level of quality I accept.
 Advantages of this one are:
 
-* Rails 4,5,6 support
+* Actively maintained
 * [ESM Tree shaking](https://webpack.js.org/guides/tree-shaking/) support
 * Rich options set
 * Full rails compatibility
 * Support Rails `#to_param` convention for seo optimized paths
 * Well tested
 
-#### Thanks to [contributors](https://github.com/railsware/js-routes/contributors)
-
-#### Have fun
-
 
-## License
-[![FOSSA Status](https://app.fossa.io/api/projects/git%2Bgithub.com%2Frailsware%2Fjs-routes.svg?type=large)](https://app.fossa.io/projects/git%2Bgithub.com%2Frailsware%2Fjs-routes?ref=badge_large)

data/lib/js_routes/configuration.rb

@@ -1,6 +1,8 @@
 # typed: strict
+
 require "pathname"
 require "js_routes/types"
+require 'js_routes/utils'
 
 module JsRoutes
   class Configuration
@@ -114,14 +116,14 @@ module JsRoutes
 
     sig { returns(Pathname) }
     def output_file
-      webpacker_dir = defined?(::Webpacker) ?
-        T.unsafe(::Webpacker).config.source_path :
-        pathname('app', 'javascript')
+      shakapacker = JsRoutes::Utils.shakapacker
+      shakapacker_dir = shakapacker ?
+        shakapacker.config.source_path : pathname('app', 'javascript')
       sprockets_dir = pathname('app','assets','javascripts')
       file_name = file || default_file_name
       sprockets_file = sprockets_dir.join(file_name)
-      webpacker_file = webpacker_dir.join(file_name)
-      !Dir.exist?(webpacker_dir) && defined?(::Sprockets) ? sprockets_file : webpacker_file
+      webpacker_file = shakapacker_dir.join(file_name)
+      !Dir.exist?(shakapacker_dir) && defined?(::Sprockets) ? sprockets_file : webpacker_file
     end
 
     protected

data/lib/js_routes/generators/base.rb

@@ -3,13 +3,18 @@ require "rails/generators"
 
 class JsRoutes::Generators::Base < Rails::Generators::Base
 
-  source_root File.expand_path(__FILE__ + "/../../../templates")
+  def self.inherited(subclass)
+    super
+    subclass.source_root(File.expand_path(__FILE__ + "/../../../templates"))
+  end
 
   protected
 
   def application_js_path
     [
+      "app/javascript/packs/application.ts",
       "app/javascript/packs/application.js",
+      "app/javascript/controllers/application.ts",
       "app/javascript/controllers/application.js",
     ].find do |path|
       File.exist?(Rails.root.join(path))

data/lib/js_routes/generators/middleware.rb

@@ -10,8 +10,7 @@ class JsRoutes::Generators::Middleware < JsRoutes::Generators::Base
     if path = application_js_path
       inject_into_file path, pack_content
     end
-    JsRoutes.generate!
-    JsRoutes.definitions!
+    JsRoutes.generate!(typed: true)
   end
 
   protected
@@ -36,7 +35,7 @@ alert(`JsRoutes installed.\\nYour root path is ${root_path()}`)
     enhanced_task = depends_on_js_bundling? ? "javascript:build" : "assets:precompile"
     <<-RB
 # Update js-routes file before javascript build
-task "#{enhanced_task}" => "js:routes:typescript"
+task "#{enhanced_task}" => "js:routes"
     RB
   end
 

data/lib/js_routes/generators/webpacker.rb

@@ -1,11 +1,12 @@
 require "rails/generators"
+require 'js_routes/utils'
 
 class JsRoutes::Generators::Webpacker < Rails::Generators::Base
 
   def create_webpack
     copy_file "initializer.rb", "config/initializers/js_routes.rb"
     copy_file "erb.js", "config/webpack/loaders/erb.js"
-    copy_file "routes.js.erb", "#{Webpacker.config.source_path}/routes.js.erb"
+    copy_file "routes.js.erb", "#{JsRoutes::Utils.shakapacker.config.source_path}/routes.js.erb"
     inject_into_file "config/webpack/environment.js", loader_content
     if path = application_js_path
       inject_into_file path, pack_content

data/lib/js_routes/instance.rb

@@ -2,6 +2,7 @@
 require "js_routes/configuration"
 require "js_routes/route"
 require "js_routes/types"
+require 'fileutils'
 
 module JsRoutes
   class Instance # :nodoc:
@@ -23,9 +24,16 @@ module JsRoutes
     sig {returns(String)}
     def generate
       # Ensure routes are loaded. If they're not, load them.
+
       application = T.unsafe(self.application)
-      if named_routes.empty? && application.respond_to?(:reload_routes!, true)
-        application.reload_routes!
+      if named_routes.empty?
+        if application.is_a?(Rails::Application)
+          if Rails.version >= "8.0.0"
+            application.reload_routes_unless_loaded
+          else
+            application.reload_routes!
+          end
+        end
       end
       content = File.read(@configuration.source_file)
 
@@ -57,6 +65,13 @@ module JsRoutes
       end
     end
 
+    sig { void }
+    def remove!
+      path = Rails.root.join(@configuration.output_file)
+      FileUtils.rm_rf(path)
+      FileUtils.rm_rf(path.sub(%r{\.js\z}, '.d.ts'))
+    end
+
     protected
 
     sig { returns(T::Hash[String, String]) }
@@ -170,8 +185,8 @@ export {};
     sig { params(route: JourneyRoute).returns(T::Array[StringArray]) }
     def mounted_app_routes(route)
       rails_engine_app = T.unsafe(app_from_route(route))
-      if rails_engine_app.respond_to?(:superclass) &&
-          rails_engine_app.superclass == Rails::Engine && !route.path.anchored
+      if rails_engine_app.is_a?(Class) &&
+          rails_engine_app < Rails::Engine && !route.path.anchored
         rails_engine_app.routes.named_routes.flat_map do |_, engine_route|
           route_helpers_if_match(engine_route, route)
         end
@@ -183,9 +198,9 @@ export {};
     sig { params(route: JourneyRoute).returns(T.untyped) }
     def app_from_route(route)
       app = route.app
-      # rails engine in Rails 4.2 use additional
+      # Rails Engine can use additional
       # ActionDispatch::Routing::Mapper::Constraints, which contain app
-      if app.respond_to?(:app) && app.respond_to?(:constraints)
+      if app.is_a?(ActionDispatch::Routing::Mapper::Constraints)
         app.app
       else
         app

data/lib/js_routes/middleware.rb

@@ -9,16 +9,18 @@ module JsRoutes
   # https://github.com/fnando/i18n-js/blob/main/lib/i18n/js/middleware.rb
   class Middleware
     include JsRoutes::Types
+    include RackApp
+
     extend T::Sig
 
-    sig { params(app: T.proc.params(a0: StringHash).returns(UntypedArray)).void }
+    sig { params(app: T.untyped).void }
     def initialize(app)
       @app = app
       @routes_file = T.let(Rails.root.join("config/routes.rb"), Pathname)
       @mtime = T.let(nil, T.nilable(Time))
     end
 
-    sig { params(env: StringHash).returns(UntypedArray) }
+    sig { override.params(env: StringHash).returns(UntypedArray) }
     def call(env)
       update_js_routes
       @app.call(env)
@@ -37,8 +39,7 @@ module JsRoutes
 
     sig { void }
     def regenerate
-      JsRoutes.generate!
-      JsRoutes.definitions! if JsRoutes.configuration.modern?
+      JsRoutes.generate!(typed: true)
     end
 
     sig { returns(T.nilable(Time)) }

data/lib/js_routes/route.rb

@@ -65,13 +65,15 @@ module JsRoutes
 
     sig { returns(String) }
     def definition_body
+      options_type = optional_parts_type ? "#{optional_parts_type} & RouteOptions" : "RouteOptions"
       args = required_parts.map{|p| "#{apply_case(p)}: RequiredRouteParameter"}
-      args << "options?: #{optional_parts_type} & RouteOptions"
+      args << "options?: #{options_type}"
       "((\n#{args.join(",\n").indent(2)}\n) => string) & RouteHelperExtras"
     end
 
-    sig { returns(String) }
+    sig { returns(T.nilable(String)) }
     def optional_parts_type
+      return nil if optional_parts.empty?
       @optional_parts_type ||= T.let(
         "{" + optional_parts.map {|p| "#{p}?: OptionalRouteParameter"}.join(', ') + "}",
         T.nilable(String)
@@ -192,7 +194,9 @@ JS
     sig { params(spec: SpecNode, parent_spec: T.nilable(RouteSpec)).returns(T.nilable(T.any(UntypedArray, String))) }
     def serialize(spec, parent_spec=nil)
       return nil unless spec
-      # Rails 4 globbing requires * removal
+      # Removing special character prefix from route variable name
+      # * for globbing
+      # : for common parameter
       return spec.tr(':*', '') if spec.is_a?(String)
 
       result = serialize_spec(spec, parent_spec)

data/lib/js_routes/types.rb

@@ -24,5 +24,15 @@ module JsRoutes
     Prefix = T.type_alias do
       T.any(T.proc.returns(String), String, NilClass)
     end
+
+    module RackApp
+      extend T::Sig
+      extend T::Helpers
+
+      interface!
+
+      sig { abstract.params(input: StringHash).returns(UntypedArray) }
+      def call(input); end
+    end
   end
 end

data/lib/js_routes/utils.rb

@@ -0,0 +1,18 @@
+# typed: strict
+
+module JsRoutes
+  module Utils
+    extend T::Sig
+    sig {returns(T.untyped)}
+    def self.shakapacker
+      if defined?(::Shakapacker)
+        ::Shakapacker
+      elsif defined?(::Webpacker)
+        ::Webpacker
+      else
+        nil
+      end
+    end
+  end
+
+end

data/lib/js_routes/version.rb

@@ -1,4 +1,4 @@
 # typed: strict
 module JsRoutes
-  VERSION = "2.2.9"
+  VERSION = "2.3.0"
 end

data/lib/js_routes.rb

@@ -34,19 +34,27 @@ module JsRoutes
       Instance.new(**opts).generate
     end
 
-    sig { params(file_name: FileName, opts: T.untyped).void }
-    def generate!(file_name = configuration.file, **opts)
+    sig { params(file_name: FileName, typed: T::Boolean, opts: T.untyped).void }
+    def generate!(file_name = configuration.file, typed: false, **opts)
       Instance.new(file: file_name, **opts).generate!
+      definitions!(file_name, **opts) if typed
+    end
+
+    sig { params(file_name: FileName, opts: T.untyped).void }
+    def remove!(file_name = configuration.file, **opts)
+      Instance.new(file: file_name, **opts).remove!
     end
 
     sig { params(opts: T.untyped).returns(String) }
     def definitions(**opts)
-      generate(**opts, module_type: 'DTS',)
+      generate(**opts, module_type: 'DTS')
     end
 
     sig { params(file_name: FileName, opts: T.untyped).void }
     def definitions!(file_name = nil, **opts)
-      file_name ||= configuration.file&.sub(%r{(\.d)?\.(j|t)s\Z}, ".d.ts")
+      file_name ||= configuration.file
+
+      file_name = file_name&.sub(%r{(\.d)?\.(j|t)s\Z}, ".d.ts")
       generate!(file_name, **opts, module_type: 'DTS')
     end
 

data/lib/routes.d.ts

@@ -5,6 +5,7 @@
 declare type Optional<T> = {
     [P in keyof T]?: T[P] | null;
 };
+declare type Collection<T> = Record<string, T>;
 declare type BaseRouteParameter = string | boolean | Date | number;
 declare type MethodRouteParameter = BaseRouteParameter | (() => BaseRouteParameter);
 declare type ModelRouteParameter = {
@@ -19,8 +20,8 @@ declare type OptionalRouteParameter = undefined | null | RequiredRouteParameter;
 declare type QueryRouteParameter = OptionalRouteParameter | QueryRouteParameter[] | {
     [k: string]: QueryRouteParameter;
 };
-declare type RouteParameters = Record<string, QueryRouteParameter>;
-declare type Serializable = Record<string, unknown>;
+declare type RouteParameters = Collection<QueryRouteParameter>;
+declare type Serializable = Collection<unknown>;
 declare type Serializer = (value: Serializable) => string;
 declare type RouteHelperExtras = {
     requiredParams(): string[];
@@ -32,9 +33,9 @@ declare type RequiredParameters<T extends number> = T extends 1 ? [RequiredRoute
     RequiredRouteParameter,
     RequiredRouteParameter
 ] : RequiredRouteParameter[];
-declare type RouteHelperOptions = RouteOptions & Record<string, OptionalRouteParameter>;
+declare type RouteHelperOptions = RouteOptions & Collection<OptionalRouteParameter>;
 declare type RouteHelper<T extends number = number> = ((...args: [...RequiredParameters<T>, RouteHelperOptions]) => string) & RouteHelperExtras;
-declare type RouteHelpers = Record<string, RouteHelper>;
+declare type RouteHelpers = Collection<RouteHelper>;
 declare type Configuration = {
     prefix: string;
     default_url_options: RouteParameters;
@@ -56,7 +57,7 @@ declare type KeywordUrlOptions = Optional<{
     params: RouteParameters;
 }>;
 declare type RouteOptions = KeywordUrlOptions & RouteParameters;
-declare type PartsTable = Record<string, {
+declare type PartsTable = Collection<{
     r?: boolean;
     d?: OptionalRouteParameter;
 }>;
@@ -76,5 +77,5 @@ declare const define: undefined | (((arg: unknown[], callback: () => unknown) =>
     amd?: unknown;
 });
 declare const module: {
-    exports: any;
+    exports: unknown;
 } | undefined;

data/lib/routes.js

@@ -30,8 +30,9 @@ RubyVariables.WRAPPER(
     const ModuleReferences = {
         CJS: {
             define(routes) {
-                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                module.exports = routes;
+                if (module) {
+                    module.exports = routes;
+                }
             },
             isSupported() {
                 return typeof module === "object";
@@ -39,10 +40,11 @@ RubyVariables.WRAPPER(
         },
         AMD: {
             define(routes) {
-                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                define([], function () {
-                    return routes;
-                });
+                if (define) {
+                    define([], function () {
+                        return routes;
+                    });
+                }
             },
             isSupported() {
                 return typeof define === "function" && !!define.amd;
@@ -290,9 +292,9 @@ RubyVariables.WRAPPER(
             if (url_params.length) {
                 result += "?" + url_params;
             }
-            result += keyword_parameters.anchor
-                ? "#" + keyword_parameters.anchor
-                : "";
+            if (keyword_parameters.anchor) {
+                result += "#" + keyword_parameters.anchor;
+            }
             if (absolute) {
                 result = this.route_url(keyword_parameters) + result;
             }
@@ -502,28 +504,27 @@ RubyVariables.WRAPPER(
         define_module(name, module) {
             this.ensure_module_supported(name);
             ModuleReferences[name].define(module);
+            return module;
         }
     }
-    const Utils = new UtilsClass();
+    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);
+            return utils.route(parts_table, route_spec, absolute);
         },
     };
-    const result = {
+    return utils.define_module(RubyVariables.MODULE_TYPE, {
         ...__jsr,
         configure: (config) => {
-            return Utils.configure(config);
+            return utils.configure(config);
         },
         config: () => {
-            return Utils.config();
+            return utils.config();
         },
         serialize: (object) => {
-            return Utils.serialize(object);
+            return utils.serialize(object);
         },
         ...RubyVariables.ROUTES_OBJECT,
-    };
-    Utils.define_module(RubyVariables.MODULE_TYPE, result);
-    return result;
+    });
 })();