@nimpl/getters 1.4.0 → 1.4.1-canary.1

package/get-params.d.ts

@@ -1,3 +1,16 @@
-export declare const getParams: () => {
-    [key: string]: string | string[];
+type GetParamsOptions = {
+    /**
+     * In case of error or segments difference
+     * getter will return null
+     * (_f.e. `/_not-found` could be at `/it/removed-page` and it would not have any params_)
+     */
+    ignoreDifferenceError?: true;
+    /** Custom pathname (f.e. `["/example/custom"]`). Usable for rewritten pages in SSR or custom functions */
+    pathname?: string;
+    /** Custom pagePaths list (f.e. `["/example/[slug]/page"]`). Usable for rewritten pages in SSR or custom functions */
+    pagePaths?: string[];
 };
+export declare const getParams: (options?: GetParamsOptions) => {
+    [key: string]: string | string[];
+} | null;
+export {};

package/get-params.js

@@ -2,34 +2,48 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getParams = void 0;
 const static_generation_async_storage_external_1 = require("next/dist/client/components/static-generation-async-storage.external");
-const utils_1 = require("./utils");
 const server_getter_in_client_component_error_1 = require("./server-getter-in-client-component-error");
-const getParams = () => {
+const utils_1 = require("./utils");
+const getParams = (options = {}) => {
     (0, server_getter_in_client_component_error_1.serverGetterInClientComponentError)("getParams");
     const store = static_generation_async_storage_external_1.staticGenerationAsyncStorage.getStore();
     if (!store)
         return {};
+    const { ignoreDifferenceError, pagePaths, pathname } = options;
     const { urlPathname, pagePath = "/" } = store;
-    const cleanUrlPathname = (0, utils_1.normalizePathname)(urlPathname);
-    const cleanPagePath = (0, utils_1.normalizePagePath)(pagePath);
-    const pagePathParts = cleanPagePath.split("/");
-    const pagePathInterceptedParts = (0, utils_1.normalizeInterceptingRoutes)(pagePathParts);
-    const pathnameParts = cleanUrlPathname.split("/");
-    const isNotFoundPage = pagePath.match(/\/_not-found\/?$/);
-    const isValidCatchALl = cleanPagePath.match(/\/\[\.\.\.[^\]]+\]/) && pathnameParts.length >= pagePathInterceptedParts.length;
-    const isValidOptionalCatchALl = cleanPagePath.match(/\/\[\[\.\.\.[^\]]+\]\]/) && pathnameParts.length >= pagePathInterceptedParts.length - 1;
-    const isCorrectMatched = isNotFoundPage ||
-        pagePathInterceptedParts.length === pathnameParts.length ||
-        isValidCatchALl ||
-        isValidOptionalCatchALl;
-    if (!isCorrectMatched) {
+    const targetUrlPathname = pathname || urlPathname;
+    let isInvalid = false;
+    try {
+        if (pagePaths) {
+            for (const userPagePath of pagePaths) {
+                const params = (0, utils_1.parseParams)(targetUrlPathname, userPagePath);
+                if (params === utils_1.INVALID_PARSE) {
+                    isInvalid ||= true;
+                    continue;
+                }
+                return params;
+            }
+        }
+        else {
+            const params = (0, utils_1.parseParams)(targetUrlPathname, pagePath);
+            if (params === utils_1.INVALID_PARSE) {
+                isInvalid ||= true;
+            }
+            else {
+                return params;
+            }
+        }
+    }
+    catch {
+        isInvalid = true;
+    }
+    if (isInvalid && !ignoreDifferenceError) {
         const createIssueUrl = new URL("https://github.com/vordgi/nimpl-getters/issues/new");
         createIssueUrl.searchParams.set("title", "Error parsing segments in get-params");
-        createIssueUrl.searchParams.set("body", `urlPathname: \`${urlPathname}\`;\n\npagePath: \`${pagePath}\`;`);
+        createIssueUrl.searchParams.set("body", `urlPathname: \`${urlPathname}\`;\n\npagePath(s): \`${pagePaths || pagePath}\`;`);
         createIssueUrl.searchParams.append("labels", "bug");
         throw new Error(`Something went wrong. Please create an issue on Github: ${createIssueUrl}`);
     }
-    const query = (0, utils_1.parseSegments)(pagePathInterceptedParts, pathnameParts);
-    return query;
+    return null;
 };
 exports.getParams = getParams;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nimpl/getters",
-  "version": "1.4.0",
+  "version": "1.4.1-canary.1",
   "description": "Implementation of server getters in React Server Components without switching to SSR in next.js",
   "files": [
     "**/*.js",

package/utils.d.ts

@@ -4,3 +4,7 @@ export declare const parseSegments: (pagePathParts: string[], pathnameParts: str
     [key: string]: string | string[];
 };
 export declare const normalizeInterceptingRoutes: (pageParts: string[]) => string[];
+export declare const INVALID_PARSE: unique symbol;
+export declare const parseParams: (urlPathname: string, pagePath: string) => typeof INVALID_PARSE | {
+    [key: string]: string | string[];
+};

package/utils.js

@@ -1,20 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.normalizeInterceptingRoutes = exports.parseSegments = exports.normalizePagePath = exports.normalizePathname = void 0;
+exports.parseParams = exports.INVALID_PARSE = exports.normalizeInterceptingRoutes = exports.parseSegments = exports.normalizePagePath = exports.normalizePathname = void 0;
 const normalizePathname = (pathname) => {
     const cleanPathname = pathname && new URL(pathname, "http://n").pathname;
     const pathnameWithoutTrailingSlash = cleanPathname?.replace(/^(\/.*)\/$/, "$1");
     const pathnameWithoutFileType = pathnameWithoutTrailingSlash?.replace(/\/_not-found$/, "");
-    return pathnameWithoutFileType || "/";
+    return pathnameWithoutFileType.endsWith("/") ? pathnameWithoutFileType : pathnameWithoutFileType + "/";
 };
 exports.normalizePathname = normalizePathname;
 const normalizePagePath = (pagePath) => {
     const cleanPagePath = pagePath && new URL(pagePath, "http://n").pathname;
-    const pagePathWithoutFileType = cleanPagePath?.replace(/(\/page|\/_not-found)$/, "");
+    const pagePathWithoutFileType = cleanPagePath?.replace(/(\/page|\/_not-found)$/, "/");
     const pagePathWithoutGroups = pagePathWithoutFileType
         .split("/")
+        .filter(Boolean)
         .filter((segment) => !segment.match(/^(\([^)]+\)$|^\@.+$)/g));
-    return pagePathWithoutGroups.join("/") || "/";
+    if (pagePathWithoutGroups.length === 0)
+        return "/";
+    return "/" + pagePathWithoutGroups.join("/") + "/";
 };
 exports.normalizePagePath = normalizePagePath;
 const parseSegments = (pagePathParts, pathnameParts) => {
@@ -72,3 +75,32 @@ const normalizeInterceptingRoutes = (pageParts) => {
     return normilizedParts.reverse();
 };
 exports.normalizeInterceptingRoutes = normalizeInterceptingRoutes;
+exports.INVALID_PARSE = Symbol("Invalid Parse");
+const isSamePaths = (urlPathnameParts, pagePathParts) => {
+    for (let i = 0; i < pagePathParts.length; i++) {
+        const urlPathnamePart = urlPathnameParts[i];
+        const pagePathPart = pagePathParts[i];
+        if (pagePathPart.match(/\[\.\.\.[^\]]+\]/))
+            return true;
+        if (pagePathPart.match(/\[[^\]]+\]/))
+            continue;
+        if (urlPathnamePart !== pagePathPart)
+            return false;
+    }
+    return urlPathnameParts.length === pagePathParts.length;
+};
+const parseParams = (urlPathname, pagePath) => {
+    const cleanUrlPathname = (0, exports.normalizePathname)(urlPathname);
+    const cleanPagePath = (0, exports.normalizePagePath)(pagePath);
+    const pagePathParts = cleanPagePath.split("/").slice(0, -1);
+    const pagePathInterceptedParts = (0, exports.normalizeInterceptingRoutes)(pagePathParts);
+    const pathnameParts = cleanUrlPathname.split("/").slice(0, -1);
+    const isNotFoundPage = pagePath.match(/\/_not-found\/?$/);
+    const isCorrectMatched = isNotFoundPage || isSamePaths(pathnameParts, pagePathInterceptedParts);
+    if (!isCorrectMatched) {
+        return exports.INVALID_PARSE;
+    }
+    const query = (0, exports.parseSegments)(pagePathInterceptedParts, pathnameParts);
+    return query;
+};
+exports.parseParams = parseParams;