@uxf/router 11.72.2 → 11.72.4

package/package.json

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

package/router.js

@@ -108,7 +108,7 @@ function createRouter(routes, routerOptions) {
             if (!schema) {
                 throw new Error(`Route '${String(routeName)}' has no schema.`);
             }
-            if (router.isReady) {
+            if (!router.isReady) {
                 throw new Error("Router is not ready. Use useQueryParamsStatic instead of useQueryParams.");
             }
             return [

package/{routes-check.d.ts → routes-check/routes-check.d.ts}

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

package/routes-check/routes-check.js

@@ -0,0 +1,65 @@
+#!/usr/bin/env ts-node-script
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.routesCheck = routesCheck;
+const throw_error_1 = require("@uxf/core/utils/throw-error");
+const path_1 = require("path");
+const process_1 = require("process");
+const true_case_path_1 = require("true-case-path");
+function fileExists(path) {
+    try {
+        return Boolean((0, true_case_path_1.trueCasePathSync)(path));
+    }
+    catch {
+        try {
+            return Boolean((0, true_case_path_1.trueCasePathSync)(path + "x"));
+        }
+        catch {
+            return false;
+        }
+    }
+}
+let hasError = false;
+function routesCheck(routes, options) {
+    Object.entries(routes).forEach(([routeName, routeDefinition]) => {
+        var _a;
+        const pathname = typeof routeDefinition.path === "string"
+            ? routeDefinition.path
+            : routeDefinition.path[(_a = options.defaultLocale) !== null && _a !== void 0 ? _a : (0, throw_error_1.throwError)("Default locale must be provided")];
+        const pathParts = pathname.substr(1).split("/");
+        try {
+            if (fileExists((0, path_1.join)(options.pagesDir, ...pathParts, "index.ts"))) {
+                return;
+            }
+            // TODO @vejvis - proč tu je tahle podmínka?
+            const lastPart = pathParts.splice(-1);
+            const pagePath = pathParts.length > 0
+                ? (0, path_1.join)(options.pagesDir, ...pathParts, `${lastPart[0] || "index"}.ts`)
+                : (0, path_1.join)(options.pagesDir, `${lastPart[0] || "index"}.tsx`);
+            if (fileExists(pagePath)) {
+                return;
+            }
+            if (fileExists((0, path_1.join)(options.appDir, ...pathname.substr(1).split("/"), "page.ts"))) {
+                // app directory
+                return;
+            }
+            throw new Error("Invalid");
+        }
+        catch {
+            process_1.stdout.write(`❌  ${routeName}\n`);
+            hasError = true;
+        }
+    });
+    if (hasError) {
+        if (options.shouldProcessExit) {
+            process.exit(1);
+        }
+        throw new Error("At least one invalid route found");
+    }
+    else {
+        if (options.shouldProcessExit) {
+            process.exit(0);
+        }
+        process_1.stdout.write("All routes checked.\n");
+    }
+}

package/routes-check/routes-check.test.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = require("path");
+const routes_check_1 = require("./routes-check");
+describe("routesCheck", () => {
+    it("should be valid", () => {
+        expect(() => (0, routes_check_1.routesCheck)({
+            route1: { path: "/" }, // index
+            route2: { path: "/product" }, // index file
+            route3: { path: "/product/edit" }, // file with specific name
+            route4: { path: "/product/[id]" }, // path parameter, file with specific name
+            route5: { path: "/product-2/[id]" }, // path parameter, index file
+            app1: { path: "/app-directory" },
+            app2: { path: "/app-directory/[param]" },
+        }, {
+            shouldProcessExit: false,
+            appDir: (0, path_1.join)(__dirname, "__test__", "app"),
+            pagesDir: (0, path_1.join)(__dirname, "__test__", "pages"),
+        })).not.toThrow();
+    });
+    it("should fail", () => {
+        expect(() => (0, routes_check_1.routesCheck)({
+            unknown: { path: "/unknown-route" }, // index
+        }, {
+            shouldProcessExit: false,
+            appDir: (0, path_1.join)(__dirname, "__test__", "app"),
+            pagesDir: (0, path_1.join)(__dirname, "__test__", "pages"),
+        })).toThrow();
+    });
+});

package/routes-check.js

@@ -1,121 +0,0 @@
-#!/usr/bin/env ts-node-script
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": 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");
-let error = false;
-function fileExists(path) {
-    try {
-        return Boolean((0, true_case_path_1.trueCasePathSync)(path));
-    }
-    catch {
-        return false;
-    }
-}
-function directoryExists(path) {
-    try {
-        const stats = fs_1.default.lstatSync(path);
-        return stats.isDirectory();
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Filters out folders used for organizational purposes in the app folder
- * such as parallel routes (e.g., (group)) and dynamic routes ([param]).
- */
-function cleanPathSegments(pathSegments) {
-    return pathSegments.filter((segment) => !segment.startsWith("(") && !segment.endsWith(")"));
-}
-function normalizeDynamicSegment(segment) {
-    return (segment === null || segment === void 0 ? void 0 : segment.startsWith("[")) ? "index" : segment || "";
-}
-/**
- * Checks for collisions in the path (in `baseDir`) * between the `segment.tsx` file and the `segment/` folder within one level.
- *
- * Example:
- * - route `/payments/export` gives segments ["payments", "export"]
- * - check if it exists at the same time `pages/payments.tsx` and `pages/payments/`.
- */
-function checkFolderFileCollision(baseDir, pathSegments) {
-    for (let i = 0; i < pathSegments.length - 1; i++) {
-        const segment = pathSegments[i];
-        const parentDir = (0, path_1.join)(baseDir, ...pathSegments.slice(0, i));
-        const filePath = (0, path_1.join)(parentDir, `${segment}.tsx`);
-        const folderPath = (0, path_1.join)(parentDir, segment);
-        if (fileExists(filePath) && directoryExists(folderPath)) {
-            // eslint-disable-next-line no-console
-            console.log(`Colission: For segment '${segment}' there is file and folder at the same time.\n` +
-                `Replace file ${segment}.tsx with ${segment}/index.tsx.`);
-            throw new Error("Route colission");
-        }
-    }
-}
-function routesCheck(routes, options = {}) {
-    Object.keys(routes).forEach((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");
-            const rawPathSegments = pathname.substring(1).split("/");
-            const pathSegments = cleanPathSegments(rawPathSegments);
-            checkFolderFileCollision(basePath, pathSegments);
-            checkFolderFileCollision(appBasePath, pathSegments);
-            // Find the last segment (e.g. for /payments/export it will be "export")
-            const lastPart = pathSegments.splice(-1);
-            const normalizedLastPart = normalizeDynamicSegment(lastPart.at(0));
-            // --- Checks in `pages` folder ---
-            // 1) path like pages/product.tsx (if it's at "first level")
-            const firstLevelPagePath = (0, path_1.join)(basePath, `${normalizedLastPart}.tsx`);
-            /// 2) path type pages/product/index.tsx
-            const firstLevelFolderPath = (0, path_1.join)(basePath, normalizedLastPart, "index.tsx");
-            // 3) paths for nested pages (pages/payments/export.tsx etc.)
-            const nestedPaths = (0, path_1.join)(basePath, ...pathSegments, `${normalizedLastPart || "index"}.tsx`);
-            const pagePath = (0, is_not_empty_1.isNotEmpty)(pathSegments)
-                ? nestedPaths
-                : fileExists(firstLevelFolderPath)
-                    ? firstLevelFolderPath
-                    : firstLevelPagePath;
-            // --- Checks in `app folder ` ---
-            const appPath = (0, path_1.join)(appBasePath, ...pathSegments, normalizedLastPart, "page.tsx");
-            // Check if the path exists in either `pages` or `app`
-            if (fileExists(pagePath) || fileExists(appPath)) {
-                return; // Valid route
-            }
-            throw new Error("Missing file for route!");
-        }
-        catch (err) {
-            // eslint-disable-next-line no-console
-            console.log("❌ Invalid route: " + pathname);
-            if (err instanceof Error) {
-                // eslint-disable-next-line no-console
-                console.error(err.message);
-            }
-            error = true;
-        }
-    });
-    if (error) {
-        if (options.shouldProcessExit) {
-            process.exit(1);
-        }
-        throw new Error("At least one invalid route found");
-    }
-    else {
-        if (options.shouldProcessExit) {
-            process.exit(0);
-        }
-        // eslint-disable-next-line no-console
-        console.log("All routes checked.");
-    }
-}

package/routes-check.test.js

@@ -1,130 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const fs_1 = __importDefault(require("fs"));
-const path_1 = require("path");
-const true_case_path_1 = require("true-case-path");
-const routes_check_1 = require("./routes-check");
-jest.mock("fs", () => {
-    // Access the actual fs module so we can spread it
-    const actualFs = jest.requireActual("fs");
-    return {
-        ...actualFs,
-        // We'll mock only the function(s) we need
-        lstatSync: jest.fn(),
-    };
-});
-jest.mock("true-case-path", () => ({
-    trueCasePathSync: jest.fn(),
-}));
-const mockTrueCasePathSync = true_case_path_1.trueCasePathSync;
-/**
- * Helper function to mock:
- *  1) Which file paths "exist"
- *  2) Which directory paths "exist"
- */
-function mockFileExists(knownPaths, knownDirs = []) {
-    // Mock the trueCasePathSync behavior (our fileExists check)
-    mockTrueCasePathSync.mockImplementation((inputPath) => {
-        if (knownPaths.includes(inputPath)) {
-            return inputPath; // indicates file exists
-        }
-        throw new Error(`Path not found: ${inputPath}`);
-    });
-    // Mock lstatSync for directory checks
-    fs_1.default.lstatSync.mockImplementation((inputPath) => {
-        if (knownDirs.includes(inputPath)) {
-            return { isDirectory: () => true };
-        }
-        // if it's in knownPaths but not in knownDirs => treat it as a file
-        if (knownPaths.includes(inputPath)) {
-            return { isDirectory: () => false };
-        }
-        // otherwise, it's not found => throw
-        throw new Error(`No such file or directory: ${inputPath}`);
-    });
-}
-const rootDirPages = (0, path_1.join)(__dirname, "..", "..", "src", "pages");
-const rootDirApp = (0, path_1.join)(__dirname, "..", "..", "src", "app");
-describe("routesCheck", () => {
-    beforeEach(() => {
-        jest.clearAllMocks();
-    });
-    it("should handle multiple valid routes at once (pages + app)", () => {
-        /**
-         *  1) /product   => pages/product/index.tsx
-         *  2) /product/edit => pages/product/edit.tsx
-         *  3) /product/[id] => pages/product/[id].tsx
-         *  4) /dashboard => app/dashboard/page.tsx
-         *  5) /settings/privacy => app/settings/privacy/page.tsx
-         */
-        mockFileExists([
-            // pages
-            (0, path_1.join)(rootDirPages, "product", "index.tsx"),
-            (0, path_1.join)(rootDirPages, "product", "edit.tsx"),
-            (0, path_1.join)(rootDirPages, "product", "[id].tsx"),
-            // app
-            (0, path_1.join)(rootDirApp, "dashboard", "page.tsx"),
-            (0, path_1.join)(rootDirApp, "settings", "privacy", "page.tsx"),
-        ], [
-            // directories
-            (0, path_1.join)(rootDirPages, "product"),
-            (0, path_1.join)(rootDirApp, "dashboard"),
-            (0, path_1.join)(rootDirApp, "settings"),
-            (0, path_1.join)(rootDirApp, "settings", "privacy"),
-        ]);
-        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", () => {
-        /**
-         * We'll test multiple routes that do not exist in either pages or app:
-         *  1) /unknown
-         *  2) /product/unknown
-         */
-        // Intentionally not mocking any matching paths here
-        mockFileExists([]);
-        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", () => {
-        /**
-         * Testing collision scenarios together:
-         *  1) /payments/export in pages => collision with payments.tsx + payments/ folder
-         */
-        mockFileExists([
-            // pages collisions
-            (0, path_1.join)(rootDirPages, "payments.tsx"),
-            (0, path_1.join)(rootDirPages, "payments", "export.tsx"),
-        ], [(0, path_1.join)(rootDirPages, "payments")]);
-        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", () => {
-        /**
-         * Testing collision scenarios together:
-         *  1) /admin/analytics in app => collision with analytics.tsx + analytics/ folder
-         */
-        mockFileExists([
-            // app collisions
-            (0, path_1.join)(rootDirApp, "admin", "analytics.tsx"),
-        ], [(0, path_1.join)(rootDirApp, "admin"), (0, path_1.join)(rootDirApp, "admin", "analytics")]);
-        expect(() => (0, routes_check_1.routesCheck)({
-            adminAnalytics: {
-                path: "/admin/analytics",
-            },
-        }, {
-            shouldProcessExit: false,
-        })).toThrow();
-    });
-});