router-kit 1.2.6 → 1.3.0

package/dist/context/RouterProvider.js

@@ -2,6 +2,7 @@ import { jsx as _jsx } from "react/jsx-runtime";
 import { useEffect, useState } from "react";
 import join from "url-join";
 import Page404 from "../pages/404";
+import { createRouterError, RouterErrorCode, RouterErrors, } from "../utils/error/errors";
 import RouterContext from "./RouterContext";
 const validateUrl = (url) => {
     try {
@@ -56,7 +57,22 @@ const RouterProvider = ({ routes }) => {
     }, []);
     const pathValidation = (routeFullPath, currentPath) => {
         const routePaths = routeFullPath.split("|");
+        const staticPaths = [];
+        const dynamicPaths = [];
         for (const routePath of routePaths) {
+            if (routePath.includes(":")) {
+                dynamicPaths.push(routePath);
+            }
+            else {
+                staticPaths.push(routePath);
+            }
+        }
+        for (const routePath of staticPaths) {
+            if (routePath === currentPath) {
+                return routePath;
+            }
+        }
+        for (const routePath of dynamicPaths) {
             const routeParts = routePath.split("/").filter(Boolean);
             const pathParts = currentPath.split("/").filter(Boolean);
             if (routeParts.length !== pathParts.length)
@@ -105,7 +121,7 @@ const RouterProvider = ({ routes }) => {
             to = to.startsWith("/") ? to : `/${to}`;
         }
         if (!validateUrl(to)) {
-            console.error(`RouterKit: Invalid URL "${to}"`);
+            RouterErrors.invalidRoute(to, "Invalid URL format");
             return;
         }
         try {
@@ -118,7 +134,9 @@ const RouterProvider = ({ routes }) => {
             setPath(to);
         }
         catch (error) {
-            console.error("RouterKit: Navigation failed", error);
+            const navError = createRouterError(RouterErrorCode.NAVIGATION_ABORTED, `Navigation to "${to}" failed: ${error instanceof Error ? error.message : String(error)}`, { to, error });
+            console.error(navError.toConsoleMessage());
+            throw navError;
         }
     };
     const matchedComponent = getComponent(routes, path);

package/dist/hooks/useDynamicComponents.js

@@ -1,22 +1,20 @@
+import { RouterErrors } from "../utils/error/errors";
 import { useParams } from "./useParams";
 export const useDynamicComponents = (dynamicComponentsObject, variationParam) => {
     const params = useParams();
     const variation = params[variationParam];
     if (variation == null) {
-        throw new Error(`[router-kit] Parameter "${variationParam}" is not defined in route params`);
+        RouterErrors.paramNotDefined(variationParam, Object.keys(params));
     }
     if (typeof variation !== "string") {
-        throw new Error(`[router-kit] Parameter "${variationParam}" must be a string, got ${typeof variation}`);
+        RouterErrors.paramInvalidType(variationParam, "string", typeof variation);
     }
     if (variation.trim() === "") {
-        throw new Error(`[router-kit] Parameter "${variationParam}" cannot be an empty string`);
-    }
-    if (!variation) {
-        throw new Error(`[router-kit] Parameter "${variationParam}" is required but not found in route params`);
+        RouterErrors.paramEmptyString(variationParam);
     }
     const component = dynamicComponentsObject[variation];
     if (!component) {
-        throw new Error(`[router-kit] Component not found for variation "${variation}". Available variations: ${Object.keys(dynamicComponentsObject).join(", ")}`);
+        RouterErrors.componentNotFound(variation, Object.keys(dynamicComponentsObject));
     }
     return component;
 };

package/dist/hooks/useRouter.d.ts

@@ -1 +1,2 @@
-export declare function useRouter(): import("..").RouterContextType;
+import type { RouterContextType } from "../types";
+export declare function useRouter(): RouterContextType;

package/dist/hooks/useRouter.js

@@ -1,12 +1,10 @@
 import { useContext } from "react";
 import RouterContext from "../context/RouterContext";
+import { RouterErrors } from "../utils/error/errors";
 export function useRouter() {
     const ctx = useContext(RouterContext);
     if (!ctx) {
-        if (typeof window === "undefined") {
-            throw new Error("RouterKit: useRouter cannot be used during server side rendering");
-        }
-        throw new Error("RouterKit: useRouter must be used within RouterProvider");
+        RouterErrors.routerNotInitialized();
     }
     return ctx;
 }

package/dist/index.d.ts

@@ -6,4 +6,5 @@ export { useDynamicComponents } from "./hooks/useDynamicComponents";
 export { useLocation } from "./hooks/useLocation";
 export { useParams } from "./hooks/useParams";
 export { useQuery } from "./hooks/useQuery";
-export type { DynamicComponents, GetComponent, Location, NavigateOptions, Route, RouterContextType, RouterError, Routes, } from "./types/index";
+export type { DynamicComponents, GetComponent, Location, NavigateOptions, Route, RouterContextType, RouterError, RouterKitError, Routes, } from "./types/index";
+export { createRouterError, RouterErrorCode, RouterErrors, } from "./utils/error/errors";

package/dist/index.js

@@ -6,3 +6,4 @@ export { useDynamicComponents } from "./hooks/useDynamicComponents";
 export { useLocation } from "./hooks/useLocation";
 export { useParams } from "./hooks/useParams";
 export { useQuery } from "./hooks/useQuery";
+export { createRouterError, RouterErrorCode, RouterErrors, } from "./utils/error/errors";

package/dist/types/index.d.ts

@@ -33,3 +33,4 @@ export interface RouterError extends Error {
 export interface DynamicComponents {
     (dynamicComponentsObject: Record<string, JSX.Element>, variationParam: string): JSX.Element;
 }
+export type { RouterKitError } from "../utils/error/errors";

package/dist/utils/error/errors.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Error codes for router-kit
+ */
+export declare enum RouterErrorCode {
+    ROUTER_NOT_INITIALIZED = "ROUTER_NOT_INITIALIZED",
+    PARAM_NOT_DEFINED = "PARAM_NOT_DEFINED",
+    PARAM_INVALID_TYPE = "PARAM_INVALID_TYPE",
+    PARAM_EMPTY_STRING = "PARAM_EMPTY_STRING",
+    COMPONENT_NOT_FOUND = "COMPONENT_NOT_FOUND",
+    NAVIGATION_ABORTED = "NAVIGATION_ABORTED",
+    INVALID_ROUTE = "INVALID_ROUTE"
+}
+/**
+ * Custom error class for router-kit
+ */
+export declare class RouterKitError extends Error {
+    readonly code: RouterErrorCode;
+    readonly context?: Record<string, any>;
+    constructor(code: RouterErrorCode, message: string, context?: Record<string, any>);
+    /**
+     * Returns a formatted error message for console output
+     */
+    toConsoleMessage(): string;
+}
+/**
+ * Creates a standardized RouterKitError
+ */
+export declare function createRouterError(code: RouterErrorCode, message: string, context?: Record<string, any>): RouterKitError;
+/**
+ * Throws a RouterKitError with optional console styling
+ */
+export declare function throwRouterError(code: RouterErrorCode, message: string, context?: Record<string, any>): never;
+/**
+ * Pre-configured error creators for common scenarios
+ */
+export declare const RouterErrors: {
+    routerNotInitialized: (additionalInfo?: string) => never;
+    paramNotDefined: (paramName: string, availableParams?: string[]) => never;
+    paramInvalidType: (paramName: string, expectedType: string, receivedType: string) => never;
+    paramEmptyString: (paramName: string) => never;
+    componentNotFound: (variation: string, availableVariations: string[]) => never;
+    navigationAborted: (reason: string) => never;
+    invalidRoute: (path: string, reason?: string) => never;
+};

package/dist/utils/error/errors.js

@@ -0,0 +1,77 @@
+/**
+ * Error codes for router-kit
+ */
+export var RouterErrorCode;
+(function (RouterErrorCode) {
+    // Router context errors
+    RouterErrorCode["ROUTER_NOT_INITIALIZED"] = "ROUTER_NOT_INITIALIZED";
+    // Dynamic components errors
+    RouterErrorCode["PARAM_NOT_DEFINED"] = "PARAM_NOT_DEFINED";
+    RouterErrorCode["PARAM_INVALID_TYPE"] = "PARAM_INVALID_TYPE";
+    RouterErrorCode["PARAM_EMPTY_STRING"] = "PARAM_EMPTY_STRING";
+    RouterErrorCode["COMPONENT_NOT_FOUND"] = "COMPONENT_NOT_FOUND";
+    // Navigation errors
+    RouterErrorCode["NAVIGATION_ABORTED"] = "NAVIGATION_ABORTED";
+    RouterErrorCode["INVALID_ROUTE"] = "INVALID_ROUTE";
+})(RouterErrorCode || (RouterErrorCode = {}));
+/**
+ * Custom error class for router-kit
+ */
+export class RouterKitError extends Error {
+    constructor(code, message, context) {
+        super(message);
+        this.name = "RouterKitError";
+        this.code = code;
+        this.context = context;
+        // Maintains proper stack trace for where our error was thrown (only available on V8)
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, RouterKitError);
+        }
+    }
+    /**
+     * Returns a formatted error message for console output
+     */
+    toConsoleMessage() {
+        const contextStr = this.context
+            ? `\n\nContext: ${JSON.stringify(this.context, null, 2)}`
+            : "";
+        return `[router-kit] ${this.code}: ${this.message}${contextStr}`;
+    }
+}
+/**
+ * Creates a standardized RouterKitError
+ */
+export function createRouterError(code, message, context) {
+    return new RouterKitError(code, message, context);
+}
+/**
+ * Throws a RouterKitError with optional console styling
+ */
+export function throwRouterError(code, message, context) {
+    const error = createRouterError(code, message, context);
+    // Enhanced console error with styling (if available)
+    if (typeof window !== "undefined" && window.console && console.error) {
+        console.error(`%c[router-kit]%c ${code}`, "color: #fff; background: #d9534f; font-weight: 700; padding: 2px 6px; border-radius: 3px;", "color: #d9534f; font-weight: 600;");
+        console.error(`%c${message}`, "color: #d9534f;");
+        if (context) {
+            console.error("Context:", context);
+        }
+    }
+    else {
+        console.error(error.toConsoleMessage());
+    }
+    throw error;
+}
+/**
+ * Pre-configured error creators for common scenarios
+ */
+export const RouterErrors = {
+    routerNotInitialized: (additionalInfo) => throwRouterError(RouterErrorCode.ROUTER_NOT_INITIALIZED, `Router context is not initialized. ${additionalInfo ||
+        "Common hooks and components must be used within the RouterProvider returned by createRouter(). Wrap your app with the RouterProvider."}`),
+    paramNotDefined: (paramName, availableParams) => throwRouterError(RouterErrorCode.PARAM_NOT_DEFINED, `Parameter "${paramName}" is not defined in route params`, availableParams ? { paramName, availableParams } : { paramName }),
+    paramInvalidType: (paramName, expectedType, receivedType) => throwRouterError(RouterErrorCode.PARAM_INVALID_TYPE, `Parameter "${paramName}" must be a ${expectedType}, got ${receivedType}`, { paramName, expectedType, receivedType }),
+    paramEmptyString: (paramName) => throwRouterError(RouterErrorCode.PARAM_EMPTY_STRING, `Parameter "${paramName}" cannot be an empty string`, { paramName }),
+    componentNotFound: (variation, availableVariations) => throwRouterError(RouterErrorCode.COMPONENT_NOT_FOUND, `Component not found for variation "${variation}". Available variations: ${availableVariations.join(", ")}`, { variation, availableVariations }),
+    navigationAborted: (reason) => throwRouterError(RouterErrorCode.NAVIGATION_ABORTED, `Navigation aborted: ${reason}`),
+    invalidRoute: (path, reason) => throwRouterError(RouterErrorCode.INVALID_ROUTE, `Invalid route "${path}"${reason ? `: ${reason}` : ""}`, { path }),
+};

package/package.json

@@ -5,7 +5,7 @@
     "email": "mohammed.bencheikh.dev@gmail.com",
     "url": "https://mohammedbencheikh.com/"
   },
-  "version": "1.2.6",
+  "version": "1.3.0",
   "description": "A small React routing provider library",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",