@inertiajs/core 2.1.0 → 2.1.2

package/dist/index.js

@@ -34,8 +34,10 @@ __export(index_exports, {
   formDataToObject: () => formDataToObject,
   hideProgress: () => hide,
   hrefToUrl: () => hrefToUrl,
+  isUrlMethodPair: () => isUrlMethodPair,
   mergeDataIntoQueryString: () => mergeDataIntoQueryString,
   objectToFormData: () => objectToFormData,
+  resetFormFields: () => resetFormFields,
   revealProgress: () => reveal,
   router: () => router,
   setupProgress: () => setupProgress,
@@ -388,14 +390,15 @@ var transformUrlAndData = (href, data, method, forceFormData, queryStringArrayFo
   return [hrefToUrl(_href), _data];
 };
 function mergeDataIntoQueryString(method, href, data, qsArrayFormat = "brackets") {
+  const hasDataForQueryString = method === "get" && !isFormData(data) && Object.keys(data).length > 0;
   const hasHost = /^[a-z][a-z0-9+.-]*:\/\//i.test(href.toString());
-  const hasAbsolutePath = hasHost || href.toString().startsWith("/");
+  const hasAbsolutePath = hasHost || href.toString().startsWith("/") || href.toString() === "";
   const hasRelativePath = !hasAbsolutePath && !href.toString().startsWith("#") && !href.toString().startsWith("?");
   const hasRelativePathWithDotPrefix = /^[.]{1,2}([/]|$)/.test(href.toString());
-  const hasSearch = href.toString().includes("?") || method === "get" && Object.keys(data).length;
+  const hasSearch = href.toString().includes("?") || hasDataForQueryString;
   const hasHash = href.toString().includes("#");
   const url = new URL(href.toString(), typeof window === "undefined" ? "http://localhost" : window.location.toString());
-  if (method === "get" && Object.keys(data).length) {
+  if (hasDataForQueryString) {
     const parseOptions = { ignoreQueryPrefix: true, parseArrays: false };
     url.search = qs.stringify(
       { ...qs.parse(url.search, parseOptions), ...data },
@@ -404,7 +407,6 @@ function mergeDataIntoQueryString(method, href, data, qsArrayFormat = "brackets"
         arrayFormat: qsArrayFormat
       }
     );
-    data = {};
   }
   return [
     [
@@ -414,7 +416,7 @@ function mergeDataIntoQueryString(method, href, data, qsArrayFormat = "brackets"
       hasSearch ? url.search : "",
       hasHash ? url.hash : ""
     ].join(""),
-    data
+    hasDataForQueryString ? {} : data
   ];
 }
 function urlWithoutHash(url) {
@@ -430,6 +432,9 @@ var setHashIfSameUrl = (originUrl, destinationUrl) => {
 var isSameUrlWithoutHash = (url1, url2) => {
   return urlWithoutHash(url1).href === urlWithoutHash(url2).href;
 };
+function isUrlMethodPair(href) {
+  return href !== null && typeof href === "object" && href !== void 0 && "url" in href && "method" in href;
+}
 
 // src/page.ts
 var CurrentPage = class {
@@ -1051,7 +1056,7 @@ var PrefetchedRequests = class {
     this.removalTimers = [];
     this.currentUseId = null;
   }
-  add(params, sendFunc, { cacheFor }) {
+  add(params, sendFunc, { cacheFor, cacheTags }) {
     const inFlight = this.findInFlight(params);
     if (inFlight) {
       return Promise.resolve();
@@ -1082,6 +1087,10 @@ var PrefetchedRequests = class {
         },
         onPrefetchResponse(response) {
           resolve(response);
+        },
+        onPrefetchError(error) {
+          prefetchedRequests.removeFromInFlight(params);
+          reject(error);
         }
       });
     }).then((response) => {
@@ -1092,12 +1101,11 @@ var PrefetchedRequests = class {
         response: promise,
         singleUse: expires === 0,
         timestamp: Date.now(),
-        inFlight: false
+        inFlight: false,
+        tags: Array.isArray(cacheTags) ? cacheTags : [cacheTags]
       });
       this.scheduleForRemoval(params, expires);
-      this.inFlightRequests = this.inFlightRequests.filter((prefetching) => {
-        return !this.paramsAreEqual(prefetching.params, params);
-      });
+      this.removeFromInFlight(params);
       response.handlePrefetch();
       return response;
     });
@@ -1116,12 +1124,22 @@ var PrefetchedRequests = class {
     });
     this.removalTimers = [];
   }
+  removeByTags(tags) {
+    this.cached = this.cached.filter((prefetched) => {
+      return !prefetched.tags.some((tag) => tags.includes(tag));
+    });
+  }
   remove(params) {
     this.cached = this.cached.filter((prefetched) => {
       return !this.paramsAreEqual(prefetched.params, params);
     });
     this.clearTimer(params);
   }
+  removeFromInFlight(params) {
+    this.inFlightRequests = this.inFlightRequests.filter((prefetching) => {
+      return !this.paramsAreEqual(prefetching.params, params);
+    });
+  }
   extractStaleValues(cacheFor) {
     const [stale, expires] = this.cacheForToStaleAndExpires(cacheFor);
     return [timeToMs(stale), timeToMs(expires)];
@@ -1253,6 +1271,8 @@ var RequestParams = class _RequestParams {
         ...params,
         ...wrappedCallbacks,
         onPrefetchResponse: params.onPrefetchResponse || (() => {
+        }),
+        onPrefetchError: params.onPrefetchError || (() => {
         })
       };
     }
@@ -1302,6 +1322,11 @@ var RequestParams = class _RequestParams {
       this.params.onPrefetchResponse(response);
     }
   }
+  onPrefetchError(error) {
+    if (this.params.onPrefetchError) {
+      this.params.onPrefetchError(error);
+    }
+  }
   all() {
     return this.params;
   }
@@ -1453,6 +1478,7 @@ var Response = class _Response {
       fireErrorEvent(scopedErrors);
       return this.requestParams.all().onError(scopedErrors);
     }
+    router.flushByCacheTags(this.requestParams.all().invalidateCacheTags || []);
     fireSuccessEvent(page.get());
     await this.requestParams.all().onSuccess(page.get());
     history.preserveUrl = false;
@@ -1684,6 +1710,9 @@ var Request = class _Request {
         return;
       }
       if (fireExceptionEvent(error)) {
+        if (originallyPrefetch) {
+          this.requestParams.onPrefetchError(error);
+        }
         return Promise.reject(error);
       }
     }).finally(() => {
@@ -1892,11 +1921,15 @@ var Router = class {
   flushAll() {
     prefetchedRequests.removeAll();
   }
+  flushByCacheTags(tags) {
+    prefetchedRequests.removeByTags(Array.isArray(tags) ? tags : [tags]);
+  }
   getPrefetching(href, options = {}) {
     return prefetchedRequests.findInFlight(this.getPrefetchParams(href, options));
   }
-  prefetch(href, options = {}, { cacheFor = 3e4 }) {
-    if (options.method !== "get") {
+  prefetch(href, options = {}, prefetchOptions = {}) {
+    const method = options.method ?? (isUrlMethodPair(href) ? href.method : "get");
+    if (method !== "get") {
       throw new Error("Prefetch requests must use the GET method");
     }
     const visit = this.getPendingVisit(href, {
@@ -1938,7 +1971,11 @@ var Router = class {
         (params) => {
           this.asyncRequestStream.send(Request.create(params, page.get()));
         },
-        { cacheFor }
+        {
+          cacheFor: 3e4,
+          cacheTags: [],
+          ...prefetchOptions
+        }
       );
     });
   }
@@ -1993,6 +2030,11 @@ var Router = class {
     };
   }
   getPendingVisit(href, options, pendingVisitOptions = {}) {
+    if (isUrlMethodPair(href)) {
+      const urlMethodPair = href;
+      href = urlMethodPair.url;
+      options.method = options.method ?? urlMethodPair.method;
+    }
     const mergedOptions = {
       method: "get",
       data: {},
@@ -2011,6 +2053,7 @@ var Router = class {
       reset: [],
       preserveUrl: false,
       prefetch: false,
+      invalidateCacheTags: [],
       ...options
     };
     const [url, _data] = transformUrlAndData(
@@ -2117,6 +2160,140 @@ function formDataToObject(source) {
   return form;
 }
 
+// src/resetFormFields.ts
+function isFormElement(element) {
+  return element instanceof HTMLInputElement || element instanceof HTMLSelectElement || element instanceof HTMLTextAreaElement;
+}
+function resetInputElement(input, defaultValues) {
+  const oldValue = input.value;
+  const oldChecked = input.checked;
+  switch (input.type.toLowerCase()) {
+    case "checkbox":
+      input.checked = defaultValues.includes(input.value);
+      break;
+    case "radio":
+      input.checked = defaultValues[0] === input.value;
+      break;
+    case "file":
+      input.value = "";
+      break;
+    case "button":
+    case "submit":
+    case "reset":
+    case "image":
+      break;
+    default:
+      input.value = defaultValues[0] !== null && defaultValues[0] !== void 0 ? String(defaultValues[0]) : "";
+  }
+  return input.value !== oldValue || input.checked !== oldChecked;
+}
+function resetSelectElement(select, defaultValues) {
+  const oldValue = select.value;
+  const oldSelectedOptions = Array.from(select.selectedOptions).map((opt) => opt.value);
+  if (select.multiple) {
+    const defaultStrings = defaultValues.map((value) => String(value));
+    Array.from(select.options).forEach((option) => {
+      option.selected = defaultStrings.includes(option.value);
+    });
+  } else {
+    select.value = defaultValues[0] !== void 0 ? String(defaultValues[0]) : "";
+  }
+  const newSelectedOptions = Array.from(select.selectedOptions).map((opt) => opt.value);
+  const hasChanged = select.multiple ? JSON.stringify(oldSelectedOptions.sort()) !== JSON.stringify(newSelectedOptions.sort()) : select.value !== oldValue;
+  return hasChanged;
+}
+function resetFormElement(element, defaultValues) {
+  if (element.disabled) {
+    if (element instanceof HTMLInputElement) {
+      const oldValue = element.value;
+      const oldChecked = element.checked;
+      switch (element.type.toLowerCase()) {
+        case "checkbox":
+        case "radio":
+          element.checked = element.defaultChecked;
+          return element.checked !== oldChecked;
+        case "file":
+          element.value = "";
+          return oldValue !== "";
+        case "button":
+        case "submit":
+        case "reset":
+        case "image":
+          return false;
+        default:
+          element.value = element.defaultValue;
+          return element.value !== oldValue;
+      }
+    } else if (element instanceof HTMLSelectElement) {
+      const oldSelectedOptions = Array.from(element.selectedOptions).map((opt) => opt.value);
+      Array.from(element.options).forEach((option) => {
+        option.selected = option.defaultSelected;
+      });
+      const newSelectedOptions = Array.from(element.selectedOptions).map((opt) => opt.value);
+      return JSON.stringify(oldSelectedOptions.sort()) !== JSON.stringify(newSelectedOptions.sort());
+    } else if (element instanceof HTMLTextAreaElement) {
+      const oldValue = element.value;
+      element.value = element.defaultValue;
+      return element.value !== oldValue;
+    }
+    return false;
+  }
+  if (element instanceof HTMLInputElement) {
+    return resetInputElement(element, defaultValues);
+  } else if (element instanceof HTMLSelectElement) {
+    return resetSelectElement(element, defaultValues);
+  } else if (element instanceof HTMLTextAreaElement) {
+    const oldValue = element.value;
+    element.value = defaultValues[0] !== void 0 ? String(defaultValues[0]) : "";
+    return element.value !== oldValue;
+  }
+  return false;
+}
+function resetFieldElements(elements, defaultValues) {
+  let hasChanged = false;
+  if (elements instanceof RadioNodeList || elements instanceof HTMLCollection) {
+    Array.from(elements).forEach((node, index) => {
+      if (node instanceof Element && isFormElement(node)) {
+        if (node instanceof HTMLInputElement && ["checkbox", "radio"].includes(node.type.toLowerCase())) {
+          if (resetFormElement(node, defaultValues)) {
+            hasChanged = true;
+          }
+        } else {
+          const indexedDefaultValues = defaultValues[index] !== void 0 ? [defaultValues[index]] : [defaultValues[0] ?? null].filter(Boolean);
+          if (resetFormElement(node, indexedDefaultValues)) {
+            hasChanged = true;
+          }
+        }
+      }
+    });
+  } else if (isFormElement(elements)) {
+    hasChanged = resetFormElement(elements, defaultValues);
+  }
+  return hasChanged;
+}
+function resetFormFields(formElement, defaults, fieldNames) {
+  if (!formElement) {
+    return;
+  }
+  if (!fieldNames || fieldNames.length === 0) {
+    const formData = new FormData(formElement);
+    const formElementNames = Array.from(formElement.elements).map((el) => isFormElement(el) ? el.name : "").filter(Boolean);
+    fieldNames = [.../* @__PURE__ */ new Set([...defaults.keys(), ...formData.keys(), ...formElementNames])];
+  }
+  let hasChanged = false;
+  fieldNames.forEach((fieldName) => {
+    const elements = formElement.elements.namedItem(fieldName);
+    if (elements) {
+      if (resetFieldElements(elements, defaults.getAll(fieldName))) {
+        hasChanged = true;
+      }
+    }
+  });
+  if (hasChanged) {
+    formElement.dispatchEvent(new Event("reset", { bubbles: true }));
+  }
+}
+
 // src/head.ts
 var Renderer = {
   buildDOMElement(tag) {