feat: allow exporting/importing matchers

README.md

@@ -127,6 +127,23 @@ const matches = matcher.matchAll('/foo/bar/baz')
 // ]
 ```
 
+### Route Matcher Export
+
+It is also possible to export and then rehydrate a matcher from pre-compiled rules.
+
+```ts
+import { exportMatcher, createMatcherFromExport } from 'radix3'
+
+// Assuming you already have a matcher
+// you can export this to a JSON-type object
+const json = exportMatcher(matcher)
+
+// and then rehydrate this later
+const newMatcher = createMatcherFromExport(json)
+
+const matches = newMatcher.matchAll('/foo/bar/baz')
+```
+
 ## Performance
 
 See [benchmark](./benchmark).

src/matcher.ts

@@ -1,4 +1,10 @@
-import { RadixNode, RadixRouter, RadixNodeData, NODE_TYPES } from "./types";
+import {
+  RadixNode,
+  RadixRouter,
+  RadixNodeData,
+  NODE_TYPES,
+  MatcherExport,
+} from "./types";
 
 export interface RouteTable {
   static: Map<string, RadixNodeData>;
@@ -17,10 +23,10 @@ export function toRouteMatcher(router: RadixRouter): RouteMatcher {
 }
 
 function _createMatcher(table: RouteTable): RouteMatcher {
-  return <RouteMatcher>{
+  return {
     ctx: { table },
     matchAll: (path) => _matchRoutes(path, table),
-  };
+  } satisfies RouteMatcher;
 }
 
 function _createRouteTable(): RouteTable {
@@ -31,6 +37,50 @@ function _createRouteTable(): RouteTable {
   };
 }
 
+function _exportMatcherFromTable(table: RouteTable): MatcherExport {
+  const obj = Object.create(null);
+
+  for (const property in table) {
+    obj[property] =
+      property === "dynamic"
+        ? Object.fromEntries(
+            [...table[property].entries()].map(([key, value]) => [
+              key,
+              _exportMatcherFromTable(value),
+            ])
+          )
+        : Object.fromEntries(table[property].entries());
+  }
+
+  return obj;
+}
+
+export function exportMatcher(matcher: RouteMatcher): MatcherExport {
+  return _exportMatcherFromTable(matcher.ctx.table);
+}
+
+function _createTableFromExport(matcherExport: MatcherExport): RouteTable {
+  const table: Partial<RouteTable> = {};
+  for (const property in matcherExport) {
+    table[property] =
+      property === "dynamic"
+        ? new Map(
+            Object.entries(matcherExport[property]).map(([key, value]) => [
+              key,
+              _createTableFromExport(value as any),
+            ])
+          )
+        : new Map(Object.entries(matcherExport[property]));
+  }
+  return table as RouteTable;
+}
+
+export function createMatcherFromExport(
+  matcherExport: MatcherExport
+): RouteMatcher {
+  return _createMatcher(_createTableFromExport(matcherExport));
+}
+
 function _matchRoutes(path: string, table: RouteTable): RadixNodeData[] {
   // Order should be from less specific to most specific
   const matches = [];

src/types.ts

@@ -64,3 +64,9 @@ export interface RadixRouter<T extends RadixNodeData = RadixNodeData> {
    */
   remove(path: string): boolean;
 }
+
+export interface MatcherExport {
+  dynamic: Map<string, MatcherExport>;
+  wildcard: Map<string, { pattern: string }>;
+  static: Map<string, { pattern: string }>;
+}

tests/matcher.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect } from "vitest";
-import { createRouter, toRouteMatcher } from "../src";
+import { createRouter, exportMatcher, toRouteMatcher } from "../src";
 
 export function createRoutes(paths) {
   return Object.fromEntries(paths.map((path) => [path, { pattern: path }]));
@@ -141,4 +141,48 @@ describe("Route matcher", function () {
       ]
     `);
   });
+
+  it("can be exported", () => {
+    const jsonData = exportMatcher(matcher);
+    expect(jsonData).toMatchInlineSnapshot(`
+      {
+        "dynamic": {
+          "/foo": {
+            "dynamic": {},
+            "static": {
+              "/": {
+                "pattern": "/foo/*",
+              },
+              "/sub": {
+                "pattern": "/foo/*/sub",
+              },
+            },
+            "wildcard": {},
+          },
+        },
+        "static": {
+          "/": {
+            "pattern": "/",
+          },
+          "/foo": {
+            "pattern": "/foo",
+          },
+          "/foo/bar": {
+            "pattern": "/foo/bar",
+          },
+          "/foo/baz": {
+            "pattern": "/foo/baz",
+          },
+        },
+        "wildcard": {
+          "/foo": {
+            "pattern": "/foo/**",
+          },
+          "/foo/baz": {
+            "pattern": "/foo/baz/**",
+          },
+        },
+      }
+    `);
+  });
 });