@uxf/router 11.64.3 → 11.68.0

package/package.json

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

package/routes-check.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env ts-node-script
+export declare function routesCheck(routes: Record<string, string>, shouldProcessExit?: boolean): void;

package/routes-check.js

@@ -0,0 +1,117 @@
+#!/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 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, shouldProcessExit = true) {
+    Object.keys(routes).forEach((route) => {
+        const pathname = routes[route];
+        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 (shouldProcessExit) {
+            process.exit(1);
+        }
+        throw new Error("At least one invalid route found");
+    }
+    else {
+        if (shouldProcessExit) {
+            process.exit(0);
+        }
+        // eslint-disable-next-line no-console
+        console.log("All routes checked.");
+    }
+}

package/routes-check.test.d.ts

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

package/routes-check.test.js

@@ -0,0 +1,130 @@
+"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"),
+        ]);
+        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();
+    });
+    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([]);
+        const routes = {
+            unknown: "/unknown",
+            productUnknown: "/product/unknown",
+        };
+        expect(() => (0, routes_check_1.routesCheck)(routes, 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")]);
+        const routes = {
+            paymentsExport: "/payments/export",
+        };
+        expect(() => (0, routes_check_1.routesCheck)(routes, 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")]);
+        const routes = {
+            adminAnalytics: "/admin/analytics",
+        };
+        expect(() => (0, routes_check_1.routesCheck)(routes, false)).toThrow();
+    });
+});