js-routes 2.0.7 → 2.1.2

data/lib/routes.ts

@@ -3,15 +3,51 @@
  * Based on Rails RubyVariables.RAILS_VERSION routes of RubyVariables.APP_CLASS
  */
 
-type RouteParameter = unknown;
-type RouteParameters = Record<string, RouteParameter>;
-type Serializer = (value: unknown) => string;
-type RouteHelper = {
-  (...args: RouteParameter[]): string;
+type Optional<T> = { [P in keyof T]?: T[P] | null };
+type BaseRouteParameter = string | boolean | Date | number;
+type MethodRouteParameter = BaseRouteParameter | (() => BaseRouteParameter);
+type ModelRouteParameter =
+  | { id: MethodRouteParameter }
+  | { to_param: MethodRouteParameter }
+  | { toParam: MethodRouteParameter };
+type RequiredRouteParameter = BaseRouteParameter | ModelRouteParameter;
+type OptionalRouteParameter = undefined | null | RequiredRouteParameter;
+type QueryRouteParameter =
+  | OptionalRouteParameter
+  | QueryRouteParameter[]
+  | { [k: string]: QueryRouteParameter };
+type RouteParameters = Record<string, QueryRouteParameter>;
+
+type Serializable = Record<string, unknown>;
+type Serializer = (value: Serializable) => string;
+type RouteHelperExtras = {
   requiredParams(): string[];
   toString(): string;
 };
 
+type RequiredParameters<T extends number> = T extends 1
+  ? [RequiredRouteParameter]
+  : T extends 2
+  ? [RequiredRouteParameter, RequiredRouteParameter]
+  : T extends 3
+  ? [RequiredRouteParameter, RequiredRouteParameter, RequiredRouteParameter]
+  : T extends 4
+  ? [
+      RequiredRouteParameter,
+      RequiredRouteParameter,
+      RequiredRouteParameter,
+      RequiredRouteParameter
+    ]
+  : RequiredRouteParameter[];
+
+type RouteHelperOptions<T extends string> = RouteOptions &
+  Optional<Record<T, OptionalRouteParameter>>;
+
+type RouteHelper<T extends number = number, U extends string = string> = ((
+  ...args: [...RequiredParameters<T>, RouteHelperOptions<U>]
+) => string) &
+  RouteHelperExtras;
+
 type RouteHelpers = Record<string, RouteHelper>;
 
 type Configuration = {
@@ -21,7 +57,6 @@ type Configuration = {
   serializer: Serializer;
 };
 
-type Optional<T> = { [P in keyof T]?: T[P] | null };
 interface RouterExposedMethods {
   config(): Configuration;
   configure(arg: Partial<Configuration>): Configuration;
@@ -32,14 +67,16 @@ type KeywordUrlOptions = Optional<{
   host: string;
   protocol: string;
   subdomain: string;
-  port: string;
+  port: string | number;
   anchor: string;
   trailing_slash: boolean;
 }>;
 
-type PartsTable = Record<string, { r?: boolean; d?: unknown }>;
+type RouteOptions = KeywordUrlOptions & RouteParameters;
 
-type ModuleType = "CJS" | "AMD" | "UMD" | "ESM";
+type PartsTable = Record<string, { r?: boolean; d?: OptionalRouteParameter }>;
+
+type ModuleType = "CJS" | "AMD" | "UMD" | "ESM" | "DTS" | "NIL";
 
 declare const RubyVariables: {
   PREFIX: string;
@@ -49,7 +86,7 @@ declare const RubyVariables: {
   SERIALIZER: Serializer;
   NAMESPACE: string;
   ROUTES_OBJECT: RouteHelpers;
-  MODULE_TYPE: ModuleType | null;
+  MODULE_TYPE: ModuleType;
   WRAPPER: <T>(callback: T) => T;
 };
 
@@ -92,30 +129,38 @@ RubyVariables.WRAPPER(
     }[keyof RouteNodes];
 
     const Root = that;
+    const isBroswer = typeof window !== "undefined";
     type ModuleDefinition = {
-      define: (routes: unknown) => void;
-      support: () => boolean;
+      define: (routes: RouterExposedMethods) => void;
+      isSupported: () => boolean;
     };
     const ModuleReferences: Record<ModuleType, ModuleDefinition> = {
       CJS: {
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        define: (routes) => (module!.exports = routes),
-        support: () => typeof module === "object",
+        define(routes) {
+          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+          module!.exports = routes;
+        },
+        isSupported() {
+          return typeof module === "object";
+        },
       },
       AMD: {
-        define: (routes) =>
+        define(routes) {
           // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
           define!([], function () {
             return routes;
-          }),
-        support: () => typeof define === "function" && !!define.amd,
+          });
+        },
+        isSupported() {
+          return typeof define === "function" && !!define.amd;
+        },
       },
       UMD: {
-        define: (routes) => {
-          if (ModuleReferences.AMD.support()) {
+        define(routes) {
+          if (ModuleReferences.AMD.isSupported()) {
             ModuleReferences.AMD.define(routes);
           } else {
-            if (ModuleReferences.CJS.support()) {
+            if (ModuleReferences.CJS.isSupported()) {
               try {
                 ModuleReferences.CJS.define(routes);
               } catch (error) {
@@ -124,12 +169,38 @@ RubyVariables.WRAPPER(
             }
           }
         },
-        support: () =>
-          ModuleReferences.AMD.support() || ModuleReferences.CJS.support(),
+        isSupported() {
+          return (
+            ModuleReferences.AMD.isSupported() ||
+            ModuleReferences.CJS.isSupported()
+          );
+        },
       },
       ESM: {
-        define: () => null,
-        support: () => true,
+        define() {
+          // Module can only be defined using ruby code generation
+        },
+        isSupported() {
+          // Its impossible to check if "export" keyword is supported
+          return true;
+        },
+      },
+      NIL: {
+        define(routes) {
+          Utils.namespace(Root, RubyVariables.NAMESPACE, routes);
+        },
+        isSupported() {
+          return !!Root;
+        },
+      },
+      DTS: {
+        // Acts the same as ESM
+        define(routes) {
+          ModuleReferences.ESM.define(routes);
+        },
+        isSupported() {
+          return ModuleReferences.ESM.isSupported();
+        },
       },
     };
 
@@ -143,9 +214,6 @@ RubyVariables.WRAPPER(
       }
     }
 
-    const DeprecatedGlobbingBehavior =
-      RubyVariables.DEPRECATED_GLOBBING_BEHAVIOR;
-
     const UriEncoderSegmentRegex = /[^a-zA-Z0-9\-._~!$&'()*+,;=:@]/g;
 
     const ReservedOptions = [
@@ -204,16 +272,16 @@ RubyVariables.WRAPPER(
         return result.join("&");
       }
 
-      serialize(object: unknown): string {
+      serialize(object: Serializable): string {
         return this.configuration.serializer(object);
       }
 
       extract_options(
         number_of_params: number,
-        args: RouteParameter[]
+        args: OptionalRouteParameter[]
       ): {
-        args: RouteParameter[];
-        options: KeywordUrlOptions & RouteParameters;
+        args: OptionalRouteParameter[];
+        options: RouteOptions;
       } {
         const last_el = args[args.length - 1];
         if (
@@ -226,32 +294,27 @@ RubyVariables.WRAPPER(
           }
           return {
             args: args.slice(0, args.length - 1),
-            options: last_el as KeywordUrlOptions & RouteParameters,
+            options: (last_el as any) as RouteOptions,
           };
         } else {
           return { args, options: {} };
         }
       }
 
-      looks_like_serialized_model(
-        object: any
-      ): object is
-        | { id: unknown }
-        | { to_param: unknown }
-        | { toParam: unknown } {
+      looks_like_serialized_model(object: any): object is ModelRouteParameter {
         return (
           this.is_object(object) &&
-          !object[this.configuration.special_options_key] &&
+          !(this.configuration.special_options_key in object) &&
           ("id" in object || "to_param" in object || "toParam" in object)
         );
       }
 
-      path_identifier(object: unknown): string {
+      path_identifier(object: QueryRouteParameter): string {
         const result = this.unwrap_path_identifier(object);
         return this.is_nullable(result) || result === false ? "" : "" + result;
       }
 
-      unwrap_path_identifier(object: any): unknown {
+      unwrap_path_identifier(object: QueryRouteParameter): unknown {
         let result: any = object;
         if (!this.is_object(object)) {
           return object;
@@ -272,7 +335,7 @@ RubyVariables.WRAPPER(
         parts: string[],
         required_params: string[],
         default_options: RouteParameters,
-        call_arguments: RouteParameter[]
+        call_arguments: OptionalRouteParameter[]
       ): {
         keyword_parameters: KeywordUrlOptions;
         query_parameters: RouteParameters;
@@ -336,7 +399,7 @@ RubyVariables.WRAPPER(
         default_options: RouteParameters,
         route: RouteTree,
         absolute: boolean,
-        args: RouteParameter[]
+        args: OptionalRouteParameter[]
       ): string {
         const {
           keyword_parameters,
@@ -446,9 +509,9 @@ RubyVariables.WRAPPER(
       }
 
       encode_segment(segment: string): string {
-        return segment.replace(UriEncoderSegmentRegex, function (str) {
-          return encodeURIComponent(str);
-        });
+        return segment.replace(UriEncoderSegmentRegex, (str) =>
+          encodeURIComponent(str)
+        );
       }
 
       is_optional_node(node: NodeTypes): boolean {
@@ -498,7 +561,9 @@ RubyVariables.WRAPPER(
           value = value.join("/");
         }
         const result = this.path_identifier(value as any);
-        return DeprecatedGlobbingBehavior ? result : encodeURI(result);
+        return RubyVariables.DEPRECATED_GLOBBING_BEHAVIOR
+          ? result
+          : encodeURI(result);
       }
 
       get_prefix(): string {
@@ -527,7 +592,7 @@ RubyVariables.WRAPPER(
             default_options[part] = value;
           }
         }
-        const result = (...args: RouteParameter[]): string => {
+        const result = (...args: OptionalRouteParameter[]): string => {
           return this.build_route(
             parts,
             required_params,
@@ -541,7 +606,7 @@ RubyVariables.WRAPPER(
         result.toString = () => {
           return this.build_path_spec(route_spec);
         };
-        return result;
+        return result as any;
       }
 
       route_url(route_defaults: KeywordUrlOptions): string {
@@ -560,31 +625,18 @@ RubyVariables.WRAPPER(
         return protocol + "://" + subdomain + hostname + port;
       }
 
-      has_location(): boolean {
-        return this.is_not_nullable(window) && !!window.location;
-      }
-
-      current_host(): string | null {
-        if (this.has_location()) {
-          return window.location.hostname;
-        } else {
-          return null;
-        }
+      current_host(): string {
+        return (isBroswer && window?.location?.hostname) || "";
       }
 
       current_protocol(): string {
-        if (this.has_location() && window.location.protocol !== "") {
-          return window.location.protocol.replace(/:$/, "");
-        } else {
-          return "http";
-        }
+        return (
+          (isBroswer && window?.location?.protocol?.replace(/:$/, "")) || "http"
+        );
       }
+
       current_port(): string {
-        if (this.has_location() && window.location.port !== "") {
-          return window.location.port;
-        } else {
-          return "";
-        }
+        return (isBroswer && window?.location?.port) || "";
       }
 
       is_object(value: unknown): value is Record<string, unknown> {
@@ -635,7 +687,7 @@ RubyVariables.WRAPPER(
       }
 
       is_module_supported(name: ModuleType): boolean {
-        return ModuleReferences[name].support();
+        return ModuleReferences[name].isSupported();
       }
 
       ensure_module_supported(name: ModuleType): void {
@@ -644,13 +696,7 @@ RubyVariables.WRAPPER(
         }
       }
 
-      define_module(
-        name: ModuleType | null,
-        module: RouterExposedMethods
-      ): void {
-        if (!name) {
-          return;
-        }
+      define_module(name: ModuleType, module: RouterExposedMethods): void {
         this.ensure_module_supported(name);
         ModuleReferences[name].define(module);
       }
@@ -677,17 +723,13 @@ RubyVariables.WRAPPER(
       config: (): Configuration => {
         return Utils.config();
       },
-      serialize: (object: unknown): string => {
+      serialize: (object: Serializable): string => {
         return Utils.serialize(object);
       },
       ...RubyVariables.ROUTES_OBJECT,
     };
 
-    Utils.namespace(Root, RubyVariables.NAMESPACE, result);
-
-    if (RubyVariables.MODULE_TYPE) {
-      Utils.define_module(RubyVariables.MODULE_TYPE, result);
-    }
+    Utils.define_module(RubyVariables.MODULE_TYPE, result);
     return result;
   }
 )(this);

data/lib/tasks/js_routes.rake

@@ -1,8 +1,14 @@
 namespace :js do
-  desc "Make a js file that will have functions that will return restful routes/urls."
+  desc "Make a js file with all rails route URL helpers"
   task routes: :environment do
     require "js-routes"
-
     JsRoutes.generate!
   end
+
+  namespace :routes do
+    desc "Make a js file with all rails route URL helpers and typescript definitions for them"
+    task typescript: "js:routes" do
+      JsRoutes.definitions!
+    end
+  end
 end

data/lib/templates/erb.js

@@ -0,0 +1,11 @@
+module.exports = {
+  module: {
+    rules: [
+      {
+        test: /\.erb$/,
+        enforce: 'pre',
+        loader: 'rails-erb-loader'
+      },
+    ]
+  }
+};

data/lib/templates/initializer.rb

@@ -0,0 +1,5 @@
+JsRoutes.setup do |c|
+  # Setup your JS module system:
+  # ESM, CJS, AMD, UMD or nil
+  # c.module_type = "ESM"
+end

data/lib/templates/routes.js.erb

@@ -0,0 +1 @@
+<%= JsRoutes.generate %>

data/spec/js_routes/module_types/dts/routes.spec.d.ts

@@ -0,0 +1,114 @@
+/**
+ * File generated by js-routes RubyVariables.GEM_VERSION
+ * Based on Rails RubyVariables.RAILS_VERSION routes of RubyVariables.APP_CLASS
+ */
+declare type Optional<T> = {
+    [P in keyof T]?: T[P] | null;
+};
+declare type BaseRouteParameter = string | boolean | Date | number;
+declare type MethodRouteParameter = BaseRouteParameter | (() => BaseRouteParameter);
+declare type ModelRouteParameter = {
+    id: MethodRouteParameter;
+} | {
+    to_param: MethodRouteParameter;
+} | {
+    toParam: MethodRouteParameter;
+};
+declare type RequiredRouteParameter = BaseRouteParameter | ModelRouteParameter;
+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 Serializer = (value: Serializable) => string;
+declare type RouteHelperExtras = {
+    requiredParams(): string[];
+    toString(): string;
+};
+declare type RequiredParameters<T extends number> = T extends 1 ? [RequiredRouteParameter] : T extends 2 ? [RequiredRouteParameter, RequiredRouteParameter] : T extends 3 ? [RequiredRouteParameter, RequiredRouteParameter, RequiredRouteParameter] : T extends 4 ? [
+    RequiredRouteParameter,
+    RequiredRouteParameter,
+    RequiredRouteParameter,
+    RequiredRouteParameter
+] : RequiredRouteParameter[];
+declare type RouteHelperOptions<T extends string> = RouteOptions & Optional<Record<T, OptionalRouteParameter>>;
+declare type RouteHelper<T extends number = number, U extends string = string> = ((...args: [...RequiredParameters<T>, RouteHelperOptions<U>]) => string) & RouteHelperExtras;
+declare type RouteHelpers = Record<string, RouteHelper>;
+declare type Configuration = {
+    prefix: string;
+    default_url_options: RouteParameters;
+    special_options_key: string;
+    serializer: Serializer;
+};
+interface RouterExposedMethods {
+    config(): Configuration;
+    configure(arg: Partial<Configuration>): Configuration;
+    serialize: Serializer;
+}
+declare type KeywordUrlOptions = Optional<{
+    host: string;
+    protocol: string;
+    subdomain: string;
+    port: string | number;
+    anchor: string;
+    trailing_slash: boolean;
+}>;
+declare type RouteOptions = KeywordUrlOptions & RouteParameters;
+declare type PartsTable = Record<string, {
+    r?: boolean;
+    d?: OptionalRouteParameter;
+}>;
+declare type ModuleType = "CJS" | "AMD" | "UMD" | "ESM" | "DTS" | "NIL";
+declare const RubyVariables: {
+    PREFIX: string;
+    DEPRECATED_GLOBBING_BEHAVIOR: boolean;
+    SPECIAL_OPTIONS_KEY: string;
+    DEFAULT_URL_OPTIONS: RouteParameters;
+    SERIALIZER: Serializer;
+    NAMESPACE: string;
+    ROUTES_OBJECT: RouteHelpers;
+    MODULE_TYPE: ModuleType;
+    WRAPPER: <T>(callback: T) => T;
+};
+declare const define: undefined | (((arg: unknown[], callback: () => unknown) => void) & {
+    amd?: unknown;
+});
+declare const module: {
+    exports: any;
+} | undefined;
+export const configure: RouterExposedMethods['configure'];
+
+export const config: RouterExposedMethods['config'];
+
+export const serialize: RouterExposedMethods['serialize'];
+
+/**
+ * Generates rails route to
+ * /inboxes/:inbox_id/messages/:message_id/attachments/:id(.:format)
+ * @param {any} inbox_id
+ * @param {any} message_id
+ * @param {any} id
+ * @param {object | undefined} options
+ * @returns {string} route path
+ */
+export const inbox_message_attachment_path: ((
+  inbox_id: RequiredRouteParameter,
+  message_id: RequiredRouteParameter,
+  id: RequiredRouteParameter,
+  options?: {format?: OptionalRouteParameter} & RouteOptions
+) => string) & RouteHelperExtras;
+
+/**
+ * Generates rails route to
+ * /inboxes(.:format)
+ * @param {object | undefined} options
+ * @returns {string} route path
+ */
+export const inboxes_path: ((
+  options?: {format?: OptionalRouteParameter} & RouteOptions
+) => string) & RouteHelperExtras;
+
+// By some reason this line prevents all types in a file
+// from being automatically exported
+export {};

data/spec/js_routes/module_types/dts/test.spec.ts

@@ -0,0 +1,56 @@
+import {
+  inbox_message_attachment_path,
+  inboxes_path,
+  serialize,
+  configure,
+  config,
+} from "./routes.spec";
+
+// Route Helpers
+inboxes_path();
+inboxes_path({
+  locale: "en",
+  search: {
+    q: "ukraine",
+    page: 3,
+    keywords: ["large", "small", { advanced: true }],
+  },
+});
+
+inbox_message_attachment_path(1, "2", true);
+inbox_message_attachment_path(
+  { id: 1 },
+  { to_param: () => "2" },
+  { toParam: () => true }
+);
+inbox_message_attachment_path(1, "2", true, { format: "json" });
+inboxes_path.toString();
+inboxes_path.requiredParams();
+
+// serialize test
+const SerializerArgument = {
+  locale: "en",
+  search: {
+    q: "ukraine",
+    page: 3,
+    keywords: ["large", "small", { advanced: true }],
+  },
+};
+serialize(SerializerArgument);
+config().serializer(SerializerArgument);
+
+// configure test
+configure({
+  default_url_options: { port: 1, host: null },
+  prefix: "",
+  special_options_key: "_options",
+  serializer: (value) => JSON.stringify(value),
+});
+
+// config tests
+const Config = config();
+console.log(
+  Config.prefix,
+  Config.default_url_options,
+  Config.special_options_key
+);