@uxf/router 11.72.0 → 11.72.2

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@uxf/router",
-    "version": "11.72.0",
+    "version": "11.72.2",
     "description": "UXF Router",
     "author": "UXFans <dev@uxf.cz>",
     "homepage": "https://gitlab.com/uxf-npm/router#readme",

package/router.d.ts

@@ -1,6 +1,6 @@
 import { LinkProps } from "next/link";
 import { Infer, Struct } from "superstruct";
-import { SitemapGeneratorOptions, SitemapGeneratorType } from "./sitemap-generator";
+import { SitemapGeneratorOptions, SitemapGeneratorType, SitemapRouteResolvers } from "./sitemap-generator";
 import { QueryParams, RoutesDefinition } from "./types";
 type ExtractSchema<T> = T extends {
     schema: Struct<infer U, any>;
@@ -12,11 +12,7 @@ type LocaleOptions<Locales extends string[]> = {
     locale: Locales[number];
 };
 export type FunctionParametersGenerator<Locales extends string[], RouteList extends RoutesDefinition<Locales>> = {
-    [K in keyof RouteList]: RouteList[K]["path"] extends string ? RouteList[K] extends {
-        schema: undefined;
-    } ? [K, null?, Options?] : [K, ExtractSchema<RouteList[K]>?, Options?] : RouteList[K] extends {
-        schema: undefined;
-    } ? [K, null, Options & LocaleOptions<Locales>] : [K, ExtractSchema<RouteList[K]>, Options & LocaleOptions<Locales>];
+    [K in keyof RouteList]: RouteList[K]["path"] extends string ? "schema" extends keyof RouteList[K] ? [K, ExtractSchema<RouteList[K]>, Options?] : [K, null?, Options?] : "schema" extends keyof RouteList[K] ? [K, ExtractSchema<RouteList[K]>, Options & LocaleOptions<Locales>] : [K, null, Options & LocaleOptions<Locales>];
 }[keyof RouteList];
 type RouteFunction<Locales extends string[], RouteList extends RoutesDefinition<Locales>> = (...args: FunctionParametersGenerator<Locales, RouteList>) => LinkProps["href"];
 type RouteToUrlFunction<Locales extends string[], RouteList extends RoutesDefinition<Locales>> = (...args: FunctionParametersGenerator<Locales, RouteList>) => string;
@@ -30,7 +26,7 @@ type QueryParamsResult<Nullable extends boolean, T extends keyof RouteList, Loca
 type Router<Locales extends string[], RouteList extends RoutesDefinition<Locales>> = {
     route: RouteFunction<Locales, RouteList>;
     routeToUrl: RouteToUrlFunction<Locales, RouteList>;
-    createSitemapGenerator: (options?: SitemapGeneratorOptions) => SitemapGeneratorType<Locales, RouteList>;
+    createSitemapGenerator: (resolvers: SitemapRouteResolvers<Locales, RouteList>, options?: SitemapGeneratorOptions) => SitemapGeneratorType;
     routes: RouteList;
     useActiveRoute: () => ActiveRoute<Locales, RouteList>;
     /**

package/router.js

@@ -97,7 +97,9 @@ function createRouter(routes, routerOptions) {
                 locale: ((_a = router.locale) !== null && _a !== void 0 ? _a : null),
             };
         },
-        createSitemapGenerator: sitemap_generator_1.createSitemapGenerator,
+        createSitemapGenerator(resolvers, options) {
+            return new sitemap_generator_1.SitemapGenerator(resolvers, options);
+        },
         routes,
         useQueryParamsDeprecated: () => (0, router_1.useRouter)().query,
         useQueryParams(routeName) {

package/routes-check.d.ts

@@ -1,2 +1,6 @@
 #!/usr/bin/env ts-node-script
-export declare function routesCheck(routes: Record<string, string>, shouldProcessExit?: boolean): void;
+import { RoutesDefinition } from "./types";
+export declare function routesCheck(routes: RoutesDefinition<any>, options?: {
+    shouldProcessExit?: boolean;
+    defaultLocale?: string;
+}): void;

package/routes-check.js

@@ -6,6 +6,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.routesCheck = routesCheck;
 const is_not_empty_1 = require("@uxf/core/utils/is-not-empty");
+const throw_error_1 = require("@uxf/core/utils/throw-error");
 const fs_1 = __importDefault(require("fs"));
 const path_1 = require("path");
 const true_case_path_1 = require("true-case-path");
@@ -58,9 +59,12 @@ function checkFolderFileCollision(baseDir, pathSegments) {
         }
     }
 }
-function routesCheck(routes, shouldProcessExit = true) {
+function routesCheck(routes, options = {}) {
     Object.keys(routes).forEach((route) => {
-        const pathname = routes[route];
+        var _a;
+        const pathname = typeof routes[route].path === "string"
+            ? routes[route].path
+            : routes[route].path[(_a = options.defaultLocale) !== null && _a !== void 0 ? _a : (0, throw_error_1.throwError)("Default locale must be provided")];
         try {
             const basePath = (0, path_1.join)(__dirname, "..", "..", "src", "pages");
             const appBasePath = (0, path_1.join)(__dirname, "..", "..", "src", "app");
@@ -102,13 +106,13 @@ function routesCheck(routes, shouldProcessExit = true) {
         }
     });
     if (error) {
-        if (shouldProcessExit) {
+        if (options.shouldProcessExit) {
             process.exit(1);
         }
         throw new Error("At least one invalid route found");
     }
     else {
-        if (shouldProcessExit) {
+        if (options.shouldProcessExit) {
             process.exit(0);
         }
         // eslint-disable-next-line no-console

package/routes-check.test.js

@@ -75,14 +75,13 @@ describe("routesCheck", () => {
             (0, path_1.join)(rootDirApp, "settings"),
             (0, path_1.join)(rootDirApp, "settings", "privacy"),
         ]);
-        const routes = {
-            product: "/product",
-            productEdit: "/product/edit",
-            productDetail: "/product/[id]",
-            dashboard: "/dashboard",
-            privacy: "/settings/privacy",
-        };
-        expect(() => (0, routes_check_1.routesCheck)(routes, false)).not.toThrow();
+        expect(() => (0, routes_check_1.routesCheck)({
+            product: { path: "/product" },
+            productEdit: { path: "/product/edit" },
+            productDetail: { path: "/product/[id]" },
+            dashboard: { path: "/dashboard" },
+            privacy: { path: "/settings/privacy" },
+        }, { shouldProcessExit: false })).not.toThrow();
     });
     it("should fail when invalid routes are provided", () => {
         /**
@@ -92,11 +91,10 @@ describe("routesCheck", () => {
          */
         // Intentionally not mocking any matching paths here
         mockFileExists([]);
-        const routes = {
-            unknown: "/unknown",
-            productUnknown: "/product/unknown",
-        };
-        expect(() => (0, routes_check_1.routesCheck)(routes, false)).toThrow();
+        expect(() => (0, routes_check_1.routesCheck)({
+            unknown: { path: "/unknown" },
+            productUnknown: { path: "/product/unknown" },
+        }, { shouldProcessExit: false })).toThrow();
     });
     it("Pages folder: should detect collisions (file + folder) in multiple segments", () => {
         /**
@@ -108,10 +106,9 @@ describe("routesCheck", () => {
             (0, path_1.join)(rootDirPages, "payments.tsx"),
             (0, path_1.join)(rootDirPages, "payments", "export.tsx"),
         ], [(0, path_1.join)(rootDirPages, "payments")]);
-        const routes = {
-            paymentsExport: "/payments/export",
-        };
-        expect(() => (0, routes_check_1.routesCheck)(routes, false)).toThrow();
+        expect(() => (0, routes_check_1.routesCheck)({
+            paymentsExport: { path: "/payments/export" },
+        }, { shouldProcessExit: false })).toThrow();
     });
     it("App folder: should detect that page.tsx is not created for the route", () => {
         /**
@@ -122,9 +119,12 @@ describe("routesCheck", () => {
             // app collisions
             (0, path_1.join)(rootDirApp, "admin", "analytics.tsx"),
         ], [(0, path_1.join)(rootDirApp, "admin"), (0, path_1.join)(rootDirApp, "admin", "analytics")]);
-        const routes = {
-            adminAnalytics: "/admin/analytics",
-        };
-        expect(() => (0, routes_check_1.routesCheck)(routes, false)).toThrow();
+        expect(() => (0, routes_check_1.routesCheck)({
+            adminAnalytics: {
+                path: "/admin/analytics",
+            },
+        }, {
+            shouldProcessExit: false,
+        })).toThrow();
     });
 });

package/sitemap-generator.d.ts

@@ -7,22 +7,32 @@ export type SitemapItem = {
     changefreq?: ChangeFrequency;
 };
 type RouteResolverResult = null | undefined | SitemapItem | Array<SitemapItem | null | undefined>;
-type RouteResolver<Route> = (route: Route) => Promise<RouteResolverResult>;
-type MissingRoutesError<Routes> = {
-    __nonExhaustive: never;
-    missingRoutes: Routes;
+/**
+ * Object-based approach for sitemap generation with compile-time exhaustiveness checking.
+ *
+ * Instead of builder pattern, this requires all routes to be specified in a single object.
+ * Routes that shouldn't be in sitemap are set to null, others have RouteResolver functions.
+ *
+ * This approach is much faster for TypeScript compiler as it avoids recursive type operations.
+ */
+export type SitemapRouteResolvers<Locales extends string[], RouteList extends RoutesDefinition<Locales>> = {
+    [K in keyof RouteList]: ((routeName: K) => Promise<RouteResolverResult>) | null;
 };
-export type SitemapGeneratorType<Locales extends string[], RouteList extends RoutesDefinition<Locales>> = {
-    add: <Route extends keyof RouteList>(route: Route, resolver: RouteResolver<Route>) => SitemapGeneratorType<Locales, Omit<RouteList, Route>>;
-    skip: <Route extends keyof RouteList>(route: Route) => SitemapGeneratorType<Locales, Omit<RouteList, Route>>;
-    exhaustive: keyof RouteList extends never ? () => SitemapGeneratorType<Locales, RouteList> : MissingRoutesError<keyof RouteList>;
-    toXml: keyof RouteList extends never ? () => Promise<string> : MissingRoutesError<keyof RouteList>;
-    toJson: keyof RouteList extends never ? () => Promise<any> : MissingRoutesError<keyof RouteList>;
+export type SitemapGeneratorType = {
+    toXml(): Promise<string>;
+    toJson(): Promise<string>;
 };
 export type SitemapGeneratorOptions = {
     baseUrl?: string;
     defaultPriority?: number;
     defaultChangeFreq?: ChangeFrequency;
 };
-export declare const createSitemapGenerator: <Locales extends string[], RouteList extends RoutesDefinition<Locales>>(options?: SitemapGeneratorOptions) => SitemapGeneratorType<Locales, RouteList>;
+export declare class SitemapGenerator<Locales extends string[], RouteList extends RoutesDefinition<Locales>> {
+    private routeResolvers;
+    private options;
+    constructor(resolvers: SitemapRouteResolvers<Locales, RouteList>, options?: SitemapGeneratorOptions);
+    private getSitemapItems;
+    toXml(): Promise<string>;
+    toJson(): Promise<string>;
+}
 export {};

package/sitemap-generator.js

@@ -1,29 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createSitemapGenerator = void 0;
+exports.SitemapGenerator = void 0;
 const object_to_xml_1 = require("./utils/object-to-xml");
 function filterNullish(val) {
     return val.filter((item) => item !== null && item !== undefined);
 }
 class SitemapGenerator {
-    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>\n${(0, object_to_xml_1.objectToXml)(item)}\n    </url>`).join("\n")}
-</urlset>`;
-            });
-        };
-        this.toJson = () => this.getSitemapItems().then(JSON.stringify);
-        this.options = options !== null && options !== void 0 ? options : null;
+    constructor(resolvers, options) {
+        this.routeResolvers = resolvers;
+        this.options = options !== null && options !== void 0 ? options : {};
     }
     async getSitemapItems() {
         const routes = Object.keys(this.routeResolvers);
-        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 resolversWithRoutes = routes
+            .map((route) => ({ route, resolver: this.routeResolvers[route] }))
+            .filter(({ resolver }) => resolver !== null);
+        const allSitemapItems = await Promise.all(resolversWithRoutes.map(({ route, resolver }) => resolver(route))).then((resolverResults) => {
             const sitemapItems = [];
             resolverResults.forEach((result) => {
                 if (!result) {
@@ -38,22 +30,25 @@ ${sitemapItems.map((item) => `    <url>\n${(0, object_to_xml_1.objectToXml)(item
             return sitemapItems;
         });
         return allSitemapItems.map((sitemapItem) => {
-            var _a, _b, _c, _d;
+            var _a;
             return ({
                 lastmod: sitemapItem.lastmod,
-                loc: ((_b = (_a = this.options) === null || _a === void 0 ? void 0 : _a.baseUrl) !== null && _b !== void 0 ? _b : "") + sitemapItem.loc,
-                changefreq: sitemapItem.changefreq !== undefined ? sitemapItem.changefreq : (_c = this.options) === null || _c === void 0 ? void 0 : _c.defaultChangeFreq,
-                priority: sitemapItem.priority !== undefined ? sitemapItem.priority : (_d = this.options) === null || _d === void 0 ? void 0 : _d.defaultPriority,
+                loc: ((_a = this.options.baseUrl) !== null && _a !== void 0 ? _a : "") + sitemapItem.loc,
+                changefreq: sitemapItem.changefreq !== undefined ? sitemapItem.changefreq : this.options.defaultChangeFreq,
+                priority: sitemapItem.priority !== undefined ? sitemapItem.priority : this.options.defaultPriority,
             });
         });
     }
-    add(route, resolver) {
-        this.routeResolvers[route] = resolver;
-        return 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>\n${(0, object_to_xml_1.objectToXml)(item)}\n    </url>`).join("\n")}
+</urlset>`;
+        });
     }
-    skip() {
-        return this;
+    toJson() {
+        return this.getSitemapItems().then(JSON.stringify);
     }
 }
-const createSitemapGenerator = (options) => new SitemapGenerator(options);
-exports.createSitemapGenerator = createSitemapGenerator;
+exports.SitemapGenerator = SitemapGenerator;

package/sitemap-generator.test.js

@@ -9,6 +9,9 @@ const { createSitemapGenerator, routeToUrl } = (0, router_1.createRouter)({
             queryParam: (0, superstruct_1.optional)((0, superstruct_1.string)()),
         }),
     },
+    skippedRoute: {
+        path: "/skipped",
+    },
     catchAllSegments: {
         path: "/catch-all/[...pathParams]",
         schema: (0, superstruct_1.object)({
@@ -26,18 +29,21 @@ const { createSitemapGenerator, routeToUrl } = (0, router_1.createRouter)({
 }, { baseUrl: "https://www.uxf.cz" });
 const BASE_URL = "www.uxf.cz";
 test("routeToUrl", async () => {
-    const xml = await createSitemapGenerator({ baseUrl: BASE_URL })
-        .add("index", async () => ({ loc: routeToUrl("index", {}) }))
-        .add("catchAllSegments", async () => ({ loc: routeToUrl("catchAllSegments", { pathParams: ["param-1"] }) }))
-        .add("optionalCatchAllSegments", async () => ({
-        loc: routeToUrl("optionalCatchAllSegments", { pathParams: ["param-1", "param-2"] }),
-        priority: 10,
-    }))
-        .toXml();
+    const xml = await createSitemapGenerator({
+        index: async (route) => ({ loc: routeToUrl(route, { queryParam: "test" }) }),
+        catchAllSegments: async (route) => ({ loc: routeToUrl(route, { pathParams: ["param-1"] }) }),
+        optionalCatchAllSegments: async (route) => ({
+            loc: routeToUrl(route, { pathParams: ["param-1", "param-2"] }),
+            priority: 10,
+        }),
+        skippedRoute: null,
+    }, {
+        baseUrl: BASE_URL,
+    }).toXml();
     expect(xml).toBe(`<?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">
     <url>
-        <loc>${BASE_URL}/</loc>
+        <loc>${BASE_URL}/?queryParam=test</loc>
     </url>
     <url>
         <loc>${BASE_URL}/catch-all/param-1</loc>

package/types.d.ts

@@ -1,18 +1,18 @@
 import { GetServerSideProps, GetStaticProps, PreviewData as NextPreviewData } from "next";
-import { Struct } from "superstruct";
+import { Infer, Struct } from "superstruct";
 export type RoutesDefinition<Locales extends string[]> = Record<string, {
     path: string | Record<Locales[number], string>;
     schema?: Struct<any, any> | null;
 }>;
-export type QueryParams<RouteList, Route extends keyof RouteList> = RouteList[Route] extends null ? never : {
-    [key in keyof RouteList[Route]]: string | string[] | undefined;
+export type QueryParams<RouteList extends RoutesDefinition<any>, Route extends keyof RouteList> = RouteList[Route]["schema"] extends null ? never : {
+    [key in keyof Infer<NonNullable<RouteList[Route]["schema"]>>]: string | string[] | undefined;
 };
-export type UxfGetStaticProps<RouteList, Route extends keyof RouteList, Props extends {
+export type UxfGetStaticProps<RouteList extends RoutesDefinition<any>, Route extends keyof RouteList, Props extends {
     [key: string]: any;
 } = {
     [key: string]: any;
 }, PreviewData extends NextPreviewData = NextPreviewData> = GetStaticProps<Props, QueryParams<RouteList, Route>, PreviewData>;
-export type UxfGetServerSideProps<RouteList, Route extends keyof RouteList, Props extends {
+export type UxfGetServerSideProps<RouteList extends RoutesDefinition<any>, Route extends keyof RouteList, Props extends {
     [key: string]: any;
 } = {
     [key: string]: any;