fix(Backend css file)

resources/js/wayfinder/index.ts

@@ -1,17 +1,18 @@
-export type QueryParams = Record<
-    string,
-    | string
-    | number
-    | boolean
-    | string[]
-    | null
-    | undefined
-    | Record<string, string | number | boolean>
->;
+export type QueryParams = {
+    [key: string]:
+        | string
+        | number
+        | boolean
+        | (string | number)[]
+        | null
+        | undefined
+        | QueryParams;
+};
 
 type Method = "get" | "post" | "put" | "delete" | "patch" | "head" | "options";
+type UrlDefaults = Record<string, unknown>;
 
-let urlDefaults: Record<string, unknown> = {};
+let urlDefaults: () => UrlDefaults = () => ({});
 
 export type RouteDefinition<TMethod extends Method | Method[]> = {
     url: string;
@@ -27,6 +28,38 @@ export type RouteQueryOptions = {
     mergeQuery?: QueryParams;
 };
 
+const getValue = (value: string | number | boolean) => {
+    if (value === true) {
+        return "1";
+    }
+
+    if (value === false) {
+        return "0";
+    }
+
+    return value.toString();
+};
+
+const addNestedParams = (
+    obj: QueryParams,
+    prefix: string,
+    params: URLSearchParams,
+) => {
+    Object.entries(obj).forEach(([subKey, value]) => {
+        if (value === undefined) return;
+
+        const paramKey = `${prefix}[${subKey}]`;
+
+        if (Array.isArray(value)) {
+            value.forEach((v) => params.append(`${paramKey}[]`, getValue(v)));
+        } else if (value !== null && typeof value === "object") {
+            addNestedParams(value, paramKey, params);
+        } else if (["string", "number", "boolean"].includes(typeof value)) {
+            params.set(paramKey, getValue(value as string | number | boolean));
+        }
+    });
+};
+
 export const queryParams = (options?: RouteQueryOptions) => {
     if (!options || (!options.query && !options.mergeQuery)) {
         return "";
@@ -35,18 +68,6 @@ export const queryParams = (options?: RouteQueryOptions) => {
     const query = options.query ?? options.mergeQuery;
     const includeExisting = options.mergeQuery !== undefined;
 
-    const getValue = (value: string | number | boolean) => {
-        if (value === true) {
-            return "1";
-        }
-
-        if (value === false) {
-            return "0";
-        }
-
-        return value.toString();
-    };
-
     const params = new URLSearchParams(
         includeExisting && typeof window !== "undefined"
             ? window.location.search
@@ -54,44 +75,31 @@ export const queryParams = (options?: RouteQueryOptions) => {
     );
 
     for (const key in query) {
-        if (query[key] === undefined || query[key] === null) {
+        const queryValue = query[key];
+
+        if (queryValue === undefined || queryValue === null) {
             params.delete(key);
             continue;
         }
 
-        if (Array.isArray(query[key])) {
+        if (Array.isArray(queryValue)) {
             if (params.has(`${key}[]`)) {
                 params.delete(`${key}[]`);
             }
 
-            query[key].forEach((value) => {
+            queryValue.forEach((value) => {
                 params.append(`${key}[]`, value.toString());
             });
-        } else if (typeof query[key] === "object") {
+        } else if (typeof queryValue === "object") {
             params.forEach((_, paramKey) => {
                 if (paramKey.startsWith(`${key}[`)) {
                     params.delete(paramKey);
                 }
             });
 
-            for (const subKey in query[key]) {
-                if (typeof query[key][subKey] === "undefined") {
-                    continue;
-                }
-
-                if (
-                    ["string", "number", "boolean"].includes(
-                        typeof query[key][subKey],
-                    )
-                ) {
-                    params.set(
-                        `${key}[${subKey}]`,
-                        getValue(query[key][subKey]),
-                    );
-                }
-            }
+            addNestedParams(queryValue, key, params);
         } else {
-            params.set(key, getValue(query[key]));
+            params.set(key, getValue(queryValue));
         }
     }
 
@@ -100,28 +108,33 @@ export const queryParams = (options?: RouteQueryOptions) => {
     return str.length > 0 ? `?${str}` : "";
 };
 
-export const setUrlDefaults = (params: Record<string, unknown>) => {
-    urlDefaults = params;
+export const setUrlDefaults = (params: UrlDefaults | (() => UrlDefaults)) => {
+    urlDefaults = typeof params === "function" ? params : () => params;
 };
 
 export const addUrlDefault = (
     key: string,
     value: string | number | boolean,
 ) => {
-    urlDefaults[key] = value;
+    const params = urlDefaults();
+    params[key] = value;
+
+    urlDefaults = () => params;
 };
 
-export const applyUrlDefaults = <T extends Record<string, unknown> | undefined>(
+export const applyUrlDefaults = <T extends UrlDefaults | undefined>(
     existing: T,
 ): T => {
-    const existingParams = { ...(existing ?? ({} as Record<string, unknown>)) };
+    const existingParams = { ...(existing ?? ({} as UrlDefaults)) };
+    const defaultParams = urlDefaults();
 
-    for (const key in urlDefaults) {
+    for (const key in defaultParams) {
         if (
             existingParams[key] === undefined &&
-            urlDefaults[key] !== undefined
+            defaultParams[key] !== undefined
         ) {
-            (existingParams as Record<string, unknown>)[key] = urlDefaults[key];
+            (existingParams as Record<string, unknown>)[key] =
+                defaultParams[key];
         }
     }