@uxf/router 10.0.0-beta.3 → 10.0.0

package/README.md

@@ -119,13 +119,13 @@ Create sitemap items
 ```tsx
 // sitemap-items.ts in @app-routes
 
-import { sitemapGenerator } from "@app-routes";
+import { createSitemapGenerator, routeToUrl } from "@app-routes";
 
-export const sitemapItems = sitemapGenerator
-    .add("index", async () => ({ loc: "http://localhost", lastmod: "2021-01-01", priority: 1 }))
-    .add("blog/detail", async () => [
-        { loc: "http://localhost/bolg/1", priority: 2 },
-        { loc: "http://localhost/bolg/2", priority: 2 },
+export const sitemapItems = createSitemapGenerator({baseUrl: 'http://localhost:3000', defaultPriority: 1})
+    .add("index", async (route) => ({ loc: routeToUrl(route) }))
+    .add("blog/detail", async (route) => [
+        { loc: routeToUrl(route, {id: 1}), priority: 2 },
+        { loc: routeToUrl(route, {id: 2}), priority: 2 },
     ])
     .skip("admin/index")
     .exhaustive();

package/index.d.ts

@@ -1,3 +1,3 @@
+export * from "./helper";
 export * from "./router";
 export * from "./types";
-export * from "./helper";

package/index.js

@@ -14,6 +14,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./helper"), exports);
 __exportStar(require("./router"), exports);
 __exportStar(require("./types"), exports);
-__exportStar(require("./helper"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uxf/router",
-  "version": "10.0.0-beta.3",
+  "version": "10.0.0",
   "description": "UXF Router",
   "author": "UXFans <dev@uxf.cz>",
   "homepage": "https://gitlab.com/uxf-npm/router#readme",
@@ -23,10 +23,13 @@
     "url": "https://gitlab.com/uxf-npm/router/issues"
   },
   "dependencies": {
-    "qs": "^6.10.1"
+    "qs": "6.11.2"
   },
   "peerDependencies": {
-    "react": "17 - 18",
-    "react-dom": "17 - 18"
+    "next": ">= 12"
+  },
+  "devDependencies": {
+    "@types/qs": "6.9.8",
+    "next": "13.5.4"
   }
 }

package/router.d.ts

@@ -1,5 +1,5 @@
 import { LinkProps } from "next/link";
-import { SitemapGeneratorType } from "./sitemapGenerator";
+import { SitemapGeneratorOptions, SitemapGeneratorType } from "./sitemapGenerator";
 import { QueryParams } from "./types";
 export type FunctionParametersGenerator<RouteList> = {
     [K in keyof RouteList]: RouteList[K] extends null ? [K] : [K, RouteList[K]];
@@ -9,7 +9,7 @@ type RouteToUrlFunction<RouteList> = (...args: FunctionParametersGenerator<Route
 type Router<RouteList> = {
     route: RouteFunction<RouteList>;
     routeToUrl: RouteToUrlFunction<RouteList>;
-    sitemapGenerator: SitemapGeneratorType<RouteList>;
+    createSitemapGenerator: (options?: SitemapGeneratorOptions) => SitemapGeneratorType<RouteList>;
     routes: {
         [key in keyof RouteList]: string;
     };

package/router.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createRouter = void 0;
+const router_1 = require("next/router");
 const qs_1 = require("qs");
 const sitemapGenerator_1 = require("./sitemapGenerator");
-const router_1 = require("next/router");
 function createRouter(routes) {
     return {
         route: (route, params = undefined) => ({
@@ -20,8 +20,38 @@ function createRouter(routes) {
             // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
             Object.keys(params !== null && params !== void 0 ? params : {}).forEach((key) => {
                 const value = params[key];
-                if (pathname.includes(`[${key}]`)) {
-                    pathname = pathname.replace(`[${key}]`, value);
+                const segment = `[${key}]`;
+                const catchAllSegments = `[...${key}]`;
+                const catchAllSegmentsOptional = `[[...${key}]]`;
+                if (pathname.includes(segment)) {
+                    pathname = pathname.replace(segment, value);
+                }
+                else if (pathname.includes(catchAllSegmentsOptional)) {
+                    if ((Array.isArray(value) && value.length === 0) ||
+                        value === null ||
+                        value === undefined ||
+                        value === "") {
+                        pathname = pathname.replace(`/${catchAllSegmentsOptional}`, "");
+                    }
+                    else if (Array.isArray(value)) {
+                        // catch all segments optional
+                        pathname = pathname.replace(catchAllSegmentsOptional, value.join("/"));
+                    }
+                    else {
+                        pathname = pathname.replace(catchAllSegmentsOptional, value);
+                    }
+                }
+                else if (pathname.includes(catchAllSegments)) {
+                    // catch all segments
+                    if (Array.isArray(value)) {
+                        if (value.length === 0) {
+                            throw new Error(`Parameter '${key}' can not be empty array for route '${String(route)}'`);
+                        }
+                        pathname = pathname.replace(catchAllSegments, value.join("/"));
+                    }
+                    else {
+                        pathname = pathname.replace(catchAllSegments, value);
+                    }
                 }
                 else {
                     restParams[key] = value;
@@ -40,7 +70,7 @@ function createRouter(routes) {
             }
             return activeRoute;
         },
-        sitemapGenerator: (0, sitemapGenerator_1.createSitemapGenerator)(),
+        createSitemapGenerator: sitemapGenerator_1.createSitemapGenerator,
         routes,
         useQueryParams: () => (0, router_1.useRouter)().query,
     };

package/router.test.d.ts

@@ -0,0 +1 @@
+export {};

package/router.test.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const router_1 = require("./router");
+const { routeToUrl } = (0, router_1.createRouter)({
+    index: "/",
+    catchAllSegments: "/catch-all/[...pathParams]",
+    optionalCatchAllSegments: "/catch-all-optional/[[...pathParams]]",
+});
+test("routeToUrl", () => {
+    expect(routeToUrl("index", {})).toBe("/");
+    expect(routeToUrl("index", { queryParam: "value" })).toBe("/?queryParam=value");
+    expect(routeToUrl("catchAllSegments", { pathParams: ["param1", "param2"] })).toBe("/catch-all/param1/param2");
+    expect(routeToUrl("catchAllSegments", { pathParams: ["param1", "param2"], queryParam: "value" })).toBe("/catch-all/param1/param2?queryParam=value");
+    expect(routeToUrl("optionalCatchAllSegments", { pathParams: ["param1", "param2"], queryParam: "value" })).toBe("/catch-all-optional/param1/param2?queryParam=value");
+    expect(routeToUrl("optionalCatchAllSegments", { pathParams: [] })).toBe("/catch-all-optional");
+    expect(routeToUrl("optionalCatchAllSegments", { pathParams: null })).toBe("/catch-all-optional");
+    expect(routeToUrl("optionalCatchAllSegments", { pathParams: undefined })).toBe("/catch-all-optional");
+    expect(routeToUrl("optionalCatchAllSegments", { pathParams: "" })).toBe("/catch-all-optional");
+    expect(routeToUrl("optionalCatchAllSegments", { pathParams: "", queryParam: "value" })).toBe("/catch-all-optional?queryParam=value");
+});

package/sitemapGenerator.d.ts

@@ -1,9 +1,11 @@
+type ChangeFrequency = "always" | "hourly" | "daily" | "weekly" | "monthly" | "yearly" | "never";
 export type SitemapItem = {
     loc: string;
-    priority: number;
+    priority?: number;
     lastmod?: string | null;
+    changefreq?: ChangeFrequency;
 };
-type RouteResolverResult = SitemapItem | SitemapItem[];
+type RouteResolverResult = null | undefined | SitemapItem | Array<SitemapItem | null | undefined>;
 type RouteResolver<Route> = (route: Route) => Promise<RouteResolverResult>;
 type MissingRoutesError<Routes> = {
     __nonExhaustive: never;
@@ -16,5 +18,10 @@ export type SitemapGeneratorType<RouteList> = {
     toXml: keyof RouteList extends never ? () => Promise<string> : MissingRoutesError<keyof RouteList>;
     toJson: keyof RouteList extends never ? () => Promise<any> : MissingRoutesError<keyof RouteList>;
 };
-export declare const createSitemapGenerator: <RouteList>() => SitemapGeneratorType<RouteList>;
+export type SitemapGeneratorOptions = {
+    baseUrl?: string;
+    defaultPriority?: number;
+    defaultChangeFreq?: ChangeFrequency;
+};
+export declare const createSitemapGenerator: <RouteList>(options?: SitemapGeneratorOptions) => SitemapGeneratorType<RouteList>;
 export {};

package/sitemapGenerator.js

@@ -1,42 +1,59 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createSitemapGenerator = void 0;
+function filterNullish(val) {
+    return val.filter((item) => item !== null && item !== undefined);
+}
 class SitemapGenerator {
-    constructor() {
+    constructor(options) {
         this.routeResolvers = {};
+        this.options = null;
         this.exhaustive = () => this;
         this.toXml = () => {
             return this.getSitemapItems().then((sitemapItems) => {
                 return `<?xml version="1.0" encoding="UTF-8"?>
         <urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.sitemaps.org/schemas/sitemap/0.9 http://www.sitemaps.org/schemas/sitemap/0.9/sitemap.xsd">
             ${sitemapItems
-                    .map((item) => `<url>
-                        <loc>${item.loc}</loc>
-                            <priority>${item.priority}</priority>
-                            ${item.lastmod ? `<lastmod>${item.lastmod}</lastmod>` : "<changefreq>monthly</changefreq>"}
-                        </url>`)
+                    .map((item) => {
+                    var _a, _b;
+                    return `<url>
+                        <loc>${(_b = (_a = this.options) === null || _a === void 0 ? void 0 : _a.baseUrl) !== null && _b !== void 0 ? _b : ""}${item.loc}</loc>
+                            ${item.priority ? `<priority>${item.priority}</priority>` : ""}
+                            ${item.lastmod ? `<lastmod>${item.lastmod}</lastmod>` : ""}
+                            ${item.changefreq ? `<changefreq>${item.changefreq}</changefreq>` : ""}
+                        </url>`;
+                })
                     .join("")}
         </urlset>`;
             });
         };
         this.toJson = () => this.getSitemapItems().then(JSON.stringify);
+        this.options = options !== null && options !== void 0 ? options : null;
     }
     async getSitemapItems() {
         const routes = Object.keys(this.routeResolvers);
-        return Promise.all(routes.map((route) => { var _a, _b; return (_b = (_a = this.routeResolvers)[route]) === null || _b === void 0 ? void 0 : _b.call(_a, route); })).then((resolverResults) => {
+        const allSitemapItems = await Promise.all(routes.map((route) => { var _a, _b; return (_b = (_a = this.routeResolvers)[route]) === null || _b === void 0 ? void 0 : _b.call(_a, route); })).then((resolverResults) => {
             const sitemapItems = [];
             resolverResults.forEach((result) => {
                 if (!result) {
                     return;
                 }
                 if (Array.isArray(result)) {
-                    sitemapItems.push(...result);
+                    sitemapItems.push(...filterNullish(result));
                     return;
                 }
                 sitemapItems.push(result);
             });
             return sitemapItems;
         });
+        return allSitemapItems.map((sitemapItem) => {
+            var _a, _b;
+            return ({
+                ...sitemapItem,
+                changefreq: sitemapItem.changefreq !== undefined ? sitemapItem.changefreq : (_a = this.options) === null || _a === void 0 ? void 0 : _a.defaultChangeFreq,
+                priority: sitemapItem.priority !== undefined ? sitemapItem.priority : (_b = this.options) === null || _b === void 0 ? void 0 : _b.defaultPriority,
+            });
+        });
     }
     add(route, resolver) {
         this.routeResolvers[route] = resolver;
@@ -46,5 +63,5 @@ class SitemapGenerator {
         return this;
     }
 }
-const createSitemapGenerator = () => new SitemapGenerator();
+const createSitemapGenerator = (options) => new SitemapGenerator(options);
 exports.createSitemapGenerator = createSitemapGenerator;

package/types.d.ts

@@ -1,4 +1,4 @@
-import { GetStaticProps, GetServerSideProps, PreviewData as NextPreviewData } from "next";
+import { GetServerSideProps, GetStaticProps, PreviewData as NextPreviewData } from "next";
 export type QueryParams<RouteList, Route extends keyof RouteList> = RouteList[Route] extends null ? never : {
     [key in keyof RouteList[Route]]: string | string[] | undefined;
 };