@uxf/router 11.68.0 → 11.72.0

package/README.md

@@ -14,27 +14,53 @@ yarn add @uxf/router
 
 import { createRouter } from "@uxf/router";
 
-interface RouteList {
-    index: null;
-    "admin/index": { param1?: number };
-    "blog/detail": { id: number };
-}
-
-export default createRouter<RouteList>({
-    index: "/",
-    "admin/index": "/admin",
-    "blog/detail": "/blog/[id]",
-});
+export default createRouter(
+    {
+        index: {
+            path: "/"
+        },
+        "admin/index": {
+            path: "/admin",
+            schema: object({
+                param1: optional(number())
+            })
+        },
+        "blog/detail": {
+            path: "/blog/[id]",
+            schema: object({
+                id: number()
+            })
+        },
+        "localized-route": {
+            path: {
+                en: "/en/home",
+                cs: "/cs/domu"
+            },
+            schema: object({
+                term: optional(string()),
+            })
+        }
+    } as const, 
+    { 
+        locales: ["cs", "en"],
+        baseUrl: "https://www.uxf.cz"
+    } as const
+);
 ```
 
 ```ts
 // routes/index.ts
 
-import router, { RouteList } from "./routes";
+import router from "./routes";
 import { UxfGetServerSideProps, UxfGetStaticProps } from "@uxf/router";
 import { PreviewData as NextPreviewData } from "next/types";
 
-export const { route, routeToUrl, sitemapGenerator, useQueryParams } = router;
+export const {
+    routeToUrl, 
+    sitemapGenerator, 
+    useQueryParams, 
+    useQueryParamsStatic 
+} = router;
 
 export type GetStaticProps<
     Route extends keyof RouteList,
@@ -67,12 +93,15 @@ Add configuration to `tsconfig.json`
 ## useQueryParams
 
 ```tsx
-import {useQueryParams} from "@app-routes";
-import {queryParamToNumber} from "./helper";
+import { useQueryParams } from "@app-routes";
+import { queryParamToNumber } from "./helper";
 
-const params = useQueryParams<"route-name">()
+// can be used on SSR pages
+const [query, { push, replace }] = useQueryParams("route-name");
 
-const id = queryParamToNumber(params.id);
+// must be used on static pages, because router is not ready on first render
+// query is null if router is not ready
+const [query, { push, replace }] = useQueryParamsStatic("route-name");
 ```
 
 ## Next Link
@@ -81,10 +110,10 @@ const id = queryParamToNumber(params.id);
 // pages/index.js
 
 import Link from "next/link";
-import { route } from "@app-routes";
+import { routeToUrl } from "@app-routes";
 
 export default () => (
-    <Link href={route("blog/detail", { id: 12 })}>
+    <Link href={routeToUrl("blog/detail", { id: 12 })}>
       Hello world
     </Link>
 )

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@uxf/router",
-    "version": "11.68.0",
+    "version": "11.72.0",
     "description": "UXF Router",
     "author": "UXFans <dev@uxf.cz>",
     "homepage": "https://gitlab.com/uxf-npm/router#readme",
@@ -23,7 +23,8 @@
         "url": "https://gitlab.com/uxf-npm/router/issues"
     },
     "dependencies": {
-        "qs": "6.13.0"
+        "qs": "6.13.0",
+        "superstruct": "2.0.2"
     },
     "peerDependencies": {
         "next": ">= 12"

package/router.d.ts

@@ -1,22 +1,52 @@
 import { LinkProps } from "next/link";
+import { Infer, Struct } from "superstruct";
 import { SitemapGeneratorOptions, SitemapGeneratorType } from "./sitemap-generator";
-import { QueryParams } from "./types";
-export type FunctionParametersGenerator<RouteList> = {
-    [K in keyof RouteList]: RouteList[K] extends null ? [K] : [K, RouteList[K]];
+import { QueryParams, RoutesDefinition } from "./types";
+type ExtractSchema<T> = T extends {
+    schema: Struct<infer U, any>;
+} ? U : null;
+type Options = {
+    shouldBeAbsolute?: boolean;
+};
+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>];
 }[keyof RouteList];
-type RouteFunction<RouteList> = (...args: FunctionParametersGenerator<RouteList>) => LinkProps["href"];
-type RouteToUrlFunction<RouteList> = (...args: FunctionParametersGenerator<RouteList>) => string;
-type Router<RouteList> = {
-    route: RouteFunction<RouteList>;
-    routeToUrl: RouteToUrlFunction<RouteList>;
-    createSitemapGenerator: (options?: SitemapGeneratorOptions) => SitemapGeneratorType<RouteList>;
-    routes: {
-        [key in keyof RouteList]: string;
-    };
-    useActiveRoute: () => keyof RouteList;
-    useQueryParams: <T extends keyof RouteList>() => QueryParams<RouteList, T>;
+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;
+type QueryParamsResult<Nullable extends boolean, T extends keyof RouteList, Locales extends string[], RouteList extends RoutesDefinition<Locales>> = [
+    Nullable extends true ? Infer<NonNullable<RouteList[T]["schema"]>> | null : Infer<NonNullable<RouteList[T]["schema"]>>,
+    {
+        push: (params: Infer<NonNullable<RouteList[T]["schema"]>>) => Promise<boolean>;
+        replace: (params: Infer<NonNullable<RouteList[T]["schema"]>>) => Promise<boolean>;
+    }
+];
+type Router<Locales extends string[], RouteList extends RoutesDefinition<Locales>> = {
+    route: RouteFunction<Locales, RouteList>;
+    routeToUrl: RouteToUrlFunction<Locales, RouteList>;
+    createSitemapGenerator: (options?: SitemapGeneratorOptions) => SitemapGeneratorType<Locales, RouteList>;
+    routes: RouteList;
+    useActiveRoute: () => ActiveRoute<Locales, RouteList>;
+    /**
+     * @deprecated use useQueryParamsStatic or useQueryParams instead
+     */
+    useQueryParamsDeprecated: <T extends keyof RouteList>() => QueryParams<RouteList, T>;
+    useQueryParams: <T extends keyof RouteList>(routeName: T) => QueryParamsResult<false, T, Locales, RouteList>;
+    useQueryParamsStatic: <T extends keyof RouteList>(routeName: T) => QueryParamsResult<true, T, Locales, RouteList>;
+};
+type RouterOptions<L extends string[]> = {
+    baseUrl?: string;
+    locales?: L;
+};
+type ActiveRoute<Locales extends string[], RouteList extends RoutesDefinition<Locales>> = {
+    route: keyof RouteList;
+    locale: Locales[number] | null;
 };
-export declare function createRouter<RouteList>(routes: {
-    [key in keyof RouteList]: string;
-}): Router<RouteList>;
+export declare function createRouter<Locales extends string[], RouteList extends RoutesDefinition<Locales>>(routes: RouteList, routerOptions: RouterOptions<Locales>): Router<Locales, RouteList>;
 export {};

package/router.js

@@ -2,18 +2,38 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createRouter = createRouter;
 const empty_object_1 = require("@uxf/core/constants/empty-object");
+const throw_error_1 = require("@uxf/core/utils/throw-error");
 const router_1 = require("next/router");
 const qs_1 = require("qs");
+const superstruct_1 = require("superstruct");
 const sitemap_generator_1 = require("./sitemap-generator");
-function createRouter(routes) {
+/**
+ * Arguments can be:
+ *
+ * [routeName, params, options]
+ */
+function decodeArgs(args) {
+    return { route: args[0], params: args[1], options: args[2] };
+}
+function createRouter(routes, routerOptions) {
     return {
-        route: (route, params = undefined) => ({
-            pathname: routes[route],
-            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-            query: params !== null && params !== void 0 ? params : null,
-        }),
-        routeToUrl: (route, params = undefined) => {
-            let pathname = routes[route];
+        route(...args) {
+            var _a;
+            const { route, params, options } = decodeArgs(args);
+            return {
+                pathname: typeof routes[route].path === "string"
+                    ? routes[route].path
+                    : routes[route].path[(_a = options === null || options === void 0 ? void 0 : options.locale) !== null && _a !== void 0 ? _a : (0, throw_error_1.throwError)("Locale is required")],
+                // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+                query: params !== null && params !== void 0 ? params : null,
+            };
+        },
+        routeToUrl(...args) {
+            var _a;
+            const { route, params, options } = decodeArgs(args);
+            let pathname = typeof routes[route].path === "string"
+                ? routes[route].path
+                : routes[route].path[(_a = options === null || options === void 0 ? void 0 : options.locale) !== null && _a !== void 0 ? _a : (0, throw_error_1.throwError)("Locale is required")];
             if (!pathname) {
                 throw new Error(`Route '${String(route)}' not found.`);
             }
@@ -61,18 +81,55 @@ function createRouter(routes) {
             if (Object.keys(restParams).length > 0) {
                 pathname = `${pathname}?${(0, qs_1.stringify)(restParams, { arrayFormat: "repeat" })}`;
             }
-            return pathname;
+            return (options === null || options === void 0 ? void 0 : options.shouldBeAbsolute) ? `${routerOptions.baseUrl}${pathname}` : pathname;
         },
-        useActiveRoute: () => {
+        useActiveRoute() {
+            var _a;
             const router = (0, router_1.useRouter)();
-            const activeRoute = Object.keys(routes).find((route) => routes[route] === router.pathname);
+            const activeRoute = Object.keys(routes).find((route) => typeof routes[route].path === "string"
+                ? routes[route].path === router.pathname
+                : Object.values(routes[route].path).includes(router.pathname));
             if (!activeRoute) {
                 throw new Error("Active route not found.");
             }
-            return activeRoute;
+            return {
+                route: activeRoute,
+                locale: ((_a = router.locale) !== null && _a !== void 0 ? _a : null),
+            };
         },
         createSitemapGenerator: sitemap_generator_1.createSitemapGenerator,
         routes,
-        useQueryParams: () => (0, router_1.useRouter)().query,
+        useQueryParamsDeprecated: () => (0, router_1.useRouter)().query,
+        useQueryParams(routeName) {
+            const router = (0, router_1.useRouter)();
+            const schema = routes[routeName].schema;
+            if (!schema) {
+                throw new Error(`Route '${String(routeName)}' has no schema.`);
+            }
+            if (router.isReady) {
+                throw new Error("Router is not ready. Use useQueryParamsStatic instead of useQueryParams.");
+            }
+            return [
+                (0, superstruct_1.mask)(router.query, schema),
+                {
+                    push: (params) => router.push(this.routeToUrl(routeName, params, {})),
+                    replace: (params) => router.replace(this.routeToUrl(routeName, params, {})),
+                },
+            ];
+        },
+        useQueryParamsStatic(routeName) {
+            const router = (0, router_1.useRouter)();
+            const schema = routes[routeName].schema;
+            if (!schema) {
+                throw new Error(`Route '${String(routeName)}' has no schema.`);
+            }
+            return [
+                router.isReady ? (0, superstruct_1.mask)(router.query, schema) : null,
+                {
+                    push: (params) => router.push(this.routeToUrl(routeName, params, {})),
+                    replace: (params) => router.replace(this.routeToUrl(routeName, params, {})),
+                },
+            ];
+        },
     };
 }

package/router.test.js

@@ -1,20 +1,129 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const superstruct_1 = require("superstruct");
 const router_1 = require("./router");
+const superstruct_2 = require("./superstruct");
 const { routeToUrl } = (0, router_1.createRouter)({
-    index: "/",
-    catchAllSegments: "/catch-all/[...pathParams]",
-    optionalCatchAllSegments: "/catch-all-optional/[[...pathParams]]",
+    index: {
+        path: "/",
+        schema: (0, superstruct_1.object)({
+            queryParam: (0, superstruct_1.optional)((0, superstruct_1.string)()),
+        }),
+    },
+    catchAllSegments: {
+        path: "/catch-all/[...pathParams]",
+        schema: (0, superstruct_1.object)({
+            pathParams: (0, superstruct_2.array)((0, superstruct_1.string)()),
+            queryParam: (0, superstruct_1.optional)((0, superstruct_1.string)()),
+        }),
+    },
+    optionalCatchAllSegments: {
+        path: "/catch-all-optional/[[...pathParams]]",
+        schema: (0, superstruct_1.object)({
+            pathParams: (0, superstruct_1.optional)((0, superstruct_1.nullable)((0, superstruct_1.union)([(0, superstruct_2.array)((0, superstruct_1.string)()), (0, superstruct_1.string)()]))),
+            queryParam: (0, superstruct_1.optional)((0, superstruct_1.string)()),
+        }),
+    },
+    routeWithoutParams: {
+        path: "/route-without-params",
+    },
+    localizedRouteWithoutParams: {
+        path: {
+            cs: "/lokalizovany-odkaz",
+            en: "/localized-url",
+        },
+    },
+    localizedRouteWithParams: {
+        path: {
+            cs: "/lokalizovany-odkaz-s-parametry",
+            en: "/localized-url-with-parameters",
+        },
+        schema: (0, superstruct_1.object)({
+            test: (0, superstruct_1.string)(),
+        }),
+    },
+}, {
+    locales: ["cs", "en"],
+    baseUrl: "https://www.uxf.cz",
 });
+const DATA = [
+    {
+        actual: routeToUrl("index", {}),
+        expected: "/",
+    },
+    {
+        actual: routeToUrl("index", { queryParam: "value" }),
+        expected: "/?queryParam=value",
+    },
+    {
+        actual: routeToUrl("catchAllSegments", { pathParams: ["param1", "param2"] }),
+        expected: "/catch-all/param1/param2",
+    },
+    {
+        actual: routeToUrl("catchAllSegments", { pathParams: ["param1", "param2"], queryParam: "value" }),
+        expected: "/catch-all/param1/param2?queryParam=value",
+    },
+    {
+        actual: routeToUrl("optionalCatchAllSegments", { pathParams: ["param1", "param2"], queryParam: "value" }),
+        expected: "/catch-all-optional/param1/param2?queryParam=value",
+    },
+    {
+        actual: routeToUrl("optionalCatchAllSegments", { pathParams: [] }),
+        expected: "/catch-all-optional",
+    },
+    {
+        actual: routeToUrl("optionalCatchAllSegments", { pathParams: null }),
+        expected: "/catch-all-optional",
+    },
+    {
+        actual: routeToUrl("optionalCatchAllSegments", { pathParams: undefined }),
+        expected: "/catch-all-optional",
+    },
+    {
+        actual: routeToUrl("optionalCatchAllSegments", { pathParams: "" }),
+        expected: "/catch-all-optional",
+    },
+    {
+        actual: routeToUrl("optionalCatchAllSegments", { pathParams: "", queryParam: "value" }),
+        expected: "/catch-all-optional?queryParam=value",
+    },
+    {
+        actual: routeToUrl("routeWithoutParams"),
+        expected: "/route-without-params",
+    },
+    {
+        actual: routeToUrl("localizedRouteWithoutParams", null, { locale: "en" }),
+        expected: "/localized-url",
+    },
+    {
+        actual: routeToUrl("localizedRouteWithoutParams", null, { locale: "cs" }),
+        expected: "/lokalizovany-odkaz",
+    },
+    {
+        actual: routeToUrl("localizedRouteWithParams", { test: "value" }, { locale: "en" }),
+        expected: "/localized-url-with-parameters?test=value",
+    },
+    {
+        actual: routeToUrl("localizedRouteWithParams", { test: "value" }, { locale: "cs" }),
+        expected: "/lokalizovany-odkaz-s-parametry?test=value",
+    },
+    {
+        actual: routeToUrl("index", { queryParam: "value" }, { shouldBeAbsolute: true }),
+        expected: "https://www.uxf.cz/?queryParam=value",
+    },
+    {
+        actual: routeToUrl("routeWithoutParams", null, { shouldBeAbsolute: true }),
+        expected: "https://www.uxf.cz/route-without-params",
+    },
+    {
+        actual: routeToUrl("localizedRouteWithoutParams", null, { locale: "cs", shouldBeAbsolute: true }),
+        expected: "https://www.uxf.cz/lokalizovany-odkaz",
+    },
+    {
+        actual: routeToUrl("localizedRouteWithParams", { test: "value" }, { locale: "en", shouldBeAbsolute: true }),
+        expected: "https://www.uxf.cz/localized-url-with-parameters?test=value",
+    },
+];
 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");
+    DATA.map(({ actual, expected }) => expect(actual).toBe(expected));
 });

package/sitemap-generator.d.ts

@@ -1,3 +1,4 @@
+import { RoutesDefinition } from "./types";
 type ChangeFrequency = "always" | "hourly" | "daily" | "weekly" | "monthly" | "yearly" | "never";
 export type SitemapItem = {
     loc: string;
@@ -11,10 +12,10 @@ type MissingRoutesError<Routes> = {
     __nonExhaustive: never;
     missingRoutes: Routes;
 };
-export type SitemapGeneratorType<RouteList> = {
-    add: <Route extends keyof RouteList>(route: Route, resolver: RouteResolver<Route>) => SitemapGeneratorType<Omit<RouteList, Route>>;
-    skip: <Route extends keyof RouteList>(route: Route) => SitemapGeneratorType<Omit<RouteList, Route>>;
-    exhaustive: keyof RouteList extends never ? () => SitemapGeneratorType<RouteList> : MissingRoutesError<keyof RouteList>;
+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>;
 };
@@ -23,5 +24,5 @@ export type SitemapGeneratorOptions = {
     defaultPriority?: number;
     defaultChangeFreq?: ChangeFrequency;
 };
-export declare const createSitemapGenerator: <RouteList>(options?: SitemapGeneratorOptions) => SitemapGeneratorType<RouteList>;
+export declare const createSitemapGenerator: <Locales extends string[], RouteList extends RoutesDefinition<Locales>>(options?: SitemapGeneratorOptions) => SitemapGeneratorType<Locales, RouteList>;
 export {};

package/sitemap-generator.test.js

@@ -1,11 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const superstruct_1 = require("superstruct");
 const router_1 = require("./router");
 const { createSitemapGenerator, routeToUrl } = (0, router_1.createRouter)({
-    index: "/",
-    catchAllSegments: "/catch-all/[...pathParams]",
-    optionalCatchAllSegments: "/catch-all-optional/[[...pathParams]]",
-});
+    index: {
+        path: "/",
+        schema: (0, superstruct_1.object)({
+            queryParam: (0, superstruct_1.optional)((0, superstruct_1.string)()),
+        }),
+    },
+    catchAllSegments: {
+        path: "/catch-all/[...pathParams]",
+        schema: (0, superstruct_1.object)({
+            pathParams: (0, superstruct_1.array)(),
+            queryParam: (0, superstruct_1.optional)((0, superstruct_1.string)()),
+        }),
+    },
+    optionalCatchAllSegments: {
+        path: "/catch-all-optional/[[...pathParams]]",
+        schema: (0, superstruct_1.object)({
+            pathParams: (0, superstruct_1.optional)((0, superstruct_1.nullable)((0, superstruct_1.union)([(0, superstruct_1.array)(), (0, superstruct_1.string)()]))),
+            queryParam: (0, superstruct_1.optional)((0, superstruct_1.string)()),
+        }),
+    },
+}, { baseUrl: "https://www.uxf.cz" });
 const BASE_URL = "www.uxf.cz";
 test("routeToUrl", async () => {
     const xml = await createSitemapGenerator({ baseUrl: BASE_URL })

package/superstruct/array.d.ts

@@ -0,0 +1,7 @@
+import { Infer, Struct } from "superstruct";
+/**
+ * NextJS používá následující zápis pole v url  `?item=a&item=b&item=c`
+ *
+ * Není teda schopen rozeznat, zda parametr `?item=a` je pole o jednom prvku nebo pouze string
+ */
+export declare function array<T extends Struct<any>>(inner: T): Struct<Infer<T>[], null>;

package/superstruct/array.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.array = array;
+const superstruct_1 = require("superstruct");
+/**
+ * NextJS používá následující zápis pole v url  `?item=a&item=b&item=c`
+ *
+ * Není teda schopen rozeznat, zda parametr `?item=a` je pole o jednom prvku nebo pouze string
+ */
+function array(inner) {
+    return (0, superstruct_1.coerce)((0, superstruct_1.array)(inner), (0, superstruct_1.union)([(0, superstruct_1.string)(), (0, superstruct_1.array)((0, superstruct_1.string)())]), (value) => {
+        return Array.isArray(value) ? value : [value];
+    });
+}

package/superstruct/boolean.d.ts

@@ -0,0 +1 @@
+export declare const boolean: () => import("superstruct").Struct<boolean, null>;

package/superstruct/boolean.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.boolean = void 0;
+const superstruct_1 = require("superstruct");
+const boolean = () => (0, superstruct_1.coerce)((0, superstruct_1.boolean)(), (0, superstruct_1.string)(), (value) => {
+    return value === "1" || value === "true" || value === "";
+});
+exports.boolean = boolean;

package/superstruct/index.d.ts

@@ -0,0 +1,4 @@
+export { object, optional, string } from "superstruct";
+export * from "./array";
+export * from "./boolean";
+export * from "./integer";

package/superstruct/index.js

@@ -0,0 +1,24 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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 });
+exports.string = exports.optional = exports.object = void 0;
+var superstruct_1 = require("superstruct");
+Object.defineProperty(exports, "object", { enumerable: true, get: function () { return superstruct_1.object; } });
+Object.defineProperty(exports, "optional", { enumerable: true, get: function () { return superstruct_1.optional; } });
+Object.defineProperty(exports, "string", { enumerable: true, get: function () { return superstruct_1.string; } });
+__exportStar(require("./array"), exports);
+__exportStar(require("./boolean"), exports);
+__exportStar(require("./integer"), exports);

package/superstruct/integer.d.ts

@@ -0,0 +1 @@
+export declare const integer: () => import("superstruct").Struct<number, null>;

package/superstruct/integer.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.integer = void 0;
+const superstruct_1 = require("superstruct");
+const integer = () => (0, superstruct_1.coerce)((0, superstruct_1.integer)(), (0, superstruct_1.string)(), (value) => {
+    const parsed = parseInt(value, 10);
+    if (isNaN(parsed)) {
+        throw new Error("Invalid number string");
+    }
+    return parsed;
+});
+exports.integer = integer;

package/types.d.ts

@@ -1,4 +1,9 @@
 import { GetServerSideProps, GetStaticProps, PreviewData as NextPreviewData } from "next";
+import { 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;
 };