@quilted/quilt 0.5.157 → 0.6.0

package/build/esnext/server/request-router.esnext

@@ -1,3 +1,4 @@
+import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
 import { isValidElement } from 'react';
 import { renderToStaticMarkup } from 'react-dom/server';
 import { styleAssetPreloadAttributes, scriptAssetPreloadAttributes } from '@quilted/assets';
@@ -7,12 +8,11 @@ import { HTMLManager, Head, Script, Style, StylePreload, ScriptPreload } from '@
 import { extract } from '@quilted/react-server-render/server';
 import { RedirectResponse, HTMLResponse } from '@quilted/request-router';
 import { ServerContext } from './ServerContext.esnext';
-import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
 
 async function renderToResponse(optionsOrElement, definitelyOptions) {
   let element;
   let options;
-  if ( /*#__PURE__*/isValidElement(optionsOrElement)) {
+  if (isValidElement(optionsOrElement)) {
     element = optionsOrElement;
     options = definitelyOptions;
   } else {
@@ -27,42 +27,37 @@ async function renderToResponse(optionsOrElement, definitelyOptions) {
     renderHTML
   } = options;
   const baseUrl = request.URL ?? new URL(request.url);
-  const cacheKey = explicitCacheKey ?? (await assets?.cacheKey?.(request)) ?? {};
+  const cacheKey = explicitCacheKey ?? (await assets?.cacheKey?.(request) ?? {});
   const html = new HTMLManager();
-  const http = new HttpManager({
-    headers: request.headers
-  });
-  const assetsManager = new AssetsManager({
-    cacheKey
-  });
+  const http = new HttpManager({ headers: request.headers });
+  const assetsManager = new AssetsManager({ cacheKey });
   let responseStatus = 200;
   let appHeaders;
   let appStream;
   if (shouldStream === false && element != null) {
     const rendered = await extract(element, {
-      decorate(element) {
-        return /*#__PURE__*/jsx(ServerContext, {
-          http: http,
-          html: html,
-          url: baseUrl,
-          assets: assetsManager,
-          children: element
-        });
+      decorate(element2) {
+        return /* @__PURE__ */ jsx(
+          ServerContext,
+          {
+            http,
+            html,
+            url: baseUrl,
+            assets: assetsManager,
+            children: element2
+          }
+        );
       }
     });
-    const {
-      headers,
-      statusCode = 200,
-      redirectUrl
-    } = http.state;
+    const { headers: headers2, statusCode = 200, redirectUrl } = http.state;
     if (redirectUrl) {
       return new RedirectResponse(redirectUrl, {
         status: statusCode,
-        headers,
+        headers: headers2,
         request
       });
     }
-    appHeaders = headers;
+    appHeaders = headers2;
     responseStatus = statusCode;
     const appTransformStream = new TransformStream();
     const appWriter = appTransformStream.writable.getWriter();
@@ -73,18 +68,21 @@ async function renderToResponse(optionsOrElement, definitelyOptions) {
   if (appStream == null) {
     const appTransformStream = new TransformStream();
     appStream = appTransformStream.readable;
-    const renderAppStream = async function renderAppStream() {
+    const renderAppStream = async function renderAppStream2() {
       const appWriter = appTransformStream.writable.getWriter();
       if (element != null) {
         const rendered = await extract(element, {
-          decorate(element) {
-            return /*#__PURE__*/jsx(ServerContext, {
-              http: http,
-              html: html,
-              url: baseUrl,
-              assets: assetsManager,
-              children: element
-            });
+          decorate(element2) {
+            return /* @__PURE__ */ jsx(
+              ServerContext,
+              {
+                http,
+                html,
+                url: baseUrl,
+                assets: assetsManager,
+                children: element2
+              }
+            );
           }
         });
         appWriter.write(rendered);
@@ -93,172 +91,171 @@ async function renderToResponse(optionsOrElement, definitelyOptions) {
     };
     waitUntil(renderAppStream());
   }
-  const {
-    headers,
-    body
-  } = await renderToHTMLStream(appStream);
+  const { headers, body } = await renderToHTMLStream(appStream);
   return new HTMLResponse(body, {
     status: responseStatus,
     headers
   });
   async function renderToHTMLStream(content) {
-    const headers = new Headers(appHeaders);
-    const [synchronousAssets, preloadAssets] = await Promise.all([assets?.entry({
-      cacheKey,
-      modules: assetsManager.usedModules({
-        timing: 'load'
+    const headers2 = new Headers(appHeaders);
+    const [synchronousAssets, preloadAssets] = await Promise.all([
+      assets?.entry({
+        cacheKey,
+        modules: assetsManager.usedModules({ timing: "load" })
+      }),
+      assets?.modules(assetsManager.usedModules({ timing: "preload" }), {
+        cacheKey
       })
-    }), assets?.modules(assetsManager.usedModules({
-      timing: 'preload'
-    }), {
-      cacheKey
-    })]);
+    ]);
     if (synchronousAssets) {
       for (const style of synchronousAssets.styles) {
-        headers.append('Link', preloadHeader(styleAssetPreloadAttributes(style)));
+        headers2.append(
+          "Link",
+          preloadHeader(styleAssetPreloadAttributes(style))
+        );
       }
       for (const script of synchronousAssets.scripts) {
-        headers.append('Link', preloadHeader(scriptAssetPreloadAttributes(script)));
+        headers2.append(
+          "Link",
+          preloadHeader(scriptAssetPreloadAttributes(script))
+        );
       }
     }
     if (renderHTML) {
-      const body = await renderHTML(content, {
+      const body3 = await renderHTML(content, {
         manager: html,
         assets: synchronousAssets,
         preloadAssets
       });
-      return {
-        headers,
-        body
-      };
+      return { headers: headers2, body: body3 };
     }
     const responseStream = new TextEncoderStream();
-    const body = responseStream.readable;
-    const renderFullHTML = async function renderFullHTML() {
+    const body2 = responseStream.readable;
+    const renderFullHTML = async function renderFullHTML2() {
       const writer = responseStream.writable.getWriter();
       writer.write(`<!DOCTYPE html>`);
-
-      /* eslint-disable jsx-a11y/html-has-lang */
-
-      const {
-        htmlAttributes,
-        bodyAttributes,
-        ...headProps
-      } = html.state;
-      const htmlContent = renderToStaticMarkup( /*#__PURE__*/jsxs("html", {
-        ...htmlAttributes,
-        children: [/*#__PURE__*/jsxs("head", {
-          children: [/*#__PURE__*/jsx(Head, {
-            ...headProps
-          }), synchronousAssets?.scripts.map(script => /*#__PURE__*/jsx(Script, {
-            asset: script,
-            baseUrl: baseUrl
-          }, script.source)), synchronousAssets?.styles.map(style => /*#__PURE__*/jsx(Style, {
-            asset: style,
-            baseUrl: baseUrl
-          }, style.source)), preloadAssets?.styles.map(style => /*#__PURE__*/jsx(StylePreload, {
-            asset: style,
-            baseUrl: baseUrl
-          }, style.source)), preloadAssets?.scripts.map(script => /*#__PURE__*/jsx(ScriptPreload, {
-            asset: script,
-            baseUrl: baseUrl
-          }, script.source))]
-        }), /*#__PURE__*/jsx("body", {
-          ...bodyAttributes,
-          dangerouslySetInnerHTML: {
-            __html: '%%CONTENT%%'
-          }
-        })]
-      }));
-
-      /* eslint-enable jsx-a11y/html-has-lang */
-
-      const [firstChunk, secondChunk] = htmlContent.split('%%CONTENT%%');
+      const { htmlAttributes, bodyAttributes, ...headProps } = html.state;
+      const htmlContent = renderToStaticMarkup(
+        /* @__PURE__ */ jsxs("html", { ...htmlAttributes, children: [
+          /* @__PURE__ */ jsxs("head", { children: [
+            /* @__PURE__ */ jsx(Head, { ...headProps }),
+            synchronousAssets?.scripts.map((script) => /* @__PURE__ */ jsx(Script, { asset: script, baseUrl }, script.source)),
+            synchronousAssets?.styles.map((style) => /* @__PURE__ */ jsx(Style, { asset: style, baseUrl }, style.source)),
+            preloadAssets?.styles.map((style) => /* @__PURE__ */ jsx(
+              StylePreload,
+              {
+                asset: style,
+                baseUrl
+              },
+              style.source
+            )),
+            preloadAssets?.scripts.map((script) => /* @__PURE__ */ jsx(
+              ScriptPreload,
+              {
+                asset: script,
+                baseUrl
+              },
+              script.source
+            ))
+          ] }),
+          /* @__PURE__ */ jsx(
+            "body",
+            {
+              ...bodyAttributes,
+              dangerouslySetInnerHTML: { __html: "%%CONTENT%%" }
+            }
+          )
+        ] })
+      );
+      const [firstChunk, secondChunk] = htmlContent.split("%%CONTENT%%");
       writer.write(firstChunk);
-      if (element != null) writer.write(`<div id="app">`);
+      if (element != null)
+        writer.write(`<div id="app">`);
       const reader = content.getReader();
-
-      // eslint-disable-next-line no-constant-condition
       while (true) {
-        const {
-          done,
-          value
-        } = await reader.read();
+        const { done, value } = await reader.read();
         if (done) {
           break;
         }
         writer.write(value);
       }
-      if (element != null) writer.write(`</div>`);
-      const [newSynchronousAssets, newPreloadAssets] = await Promise.all([assets?.entry({
-        cacheKey,
-        modules: assetsManager.usedModules({
-          timing: 'load'
+      if (element != null)
+        writer.write(`</div>`);
+      const [newSynchronousAssets, newPreloadAssets] = await Promise.all([
+        assets?.entry({
+          cacheKey,
+          modules: assetsManager.usedModules({ timing: "load" })
+        }),
+        assets?.modules(assetsManager.usedModules({ timing: "preload" }), {
+          cacheKey
         })
-      }), assets?.modules(assetsManager.usedModules({
-        timing: 'preload'
-      }), {
-        cacheKey
-      })]);
+      ]);
       if (newSynchronousAssets) {
-        const diffedSynchronousAssets = diffBrowserAssetsEntries(newSynchronousAssets, synchronousAssets);
-        const diffedPreloadAssets = diffBrowserAssetsEntries(newPreloadAssets, preloadAssets);
-        const additionalAssetsContent = renderToStaticMarkup( /*#__PURE__*/jsxs(Fragment, {
-          children: [diffedSynchronousAssets.scripts.map(script => /*#__PURE__*/jsx(Script, {
-            asset: script,
-            baseUrl: baseUrl
-          }, script.source)), diffedSynchronousAssets.styles.map(style => /*#__PURE__*/jsx(Style, {
-            asset: style,
-            baseUrl: baseUrl
-          }, style.source)), diffedPreloadAssets.styles.map(style => /*#__PURE__*/jsx(StylePreload, {
-            asset: style,
-            baseUrl: baseUrl
-          }, style.source)), diffedPreloadAssets.scripts.map(script => /*#__PURE__*/jsx(ScriptPreload, {
-            asset: script,
-            baseUrl: baseUrl
-          }, script.source))]
-        }));
+        const diffedSynchronousAssets = diffBrowserAssetsEntries(
+          newSynchronousAssets,
+          synchronousAssets
+        );
+        const diffedPreloadAssets = diffBrowserAssetsEntries(
+          newPreloadAssets,
+          preloadAssets
+        );
+        const additionalAssetsContent = renderToStaticMarkup(
+          /* @__PURE__ */ jsxs(Fragment, { children: [
+            diffedSynchronousAssets.scripts.map((script) => /* @__PURE__ */ jsx(Script, { asset: script, baseUrl }, script.source)),
+            diffedSynchronousAssets.styles.map((style) => /* @__PURE__ */ jsx(Style, { asset: style, baseUrl }, style.source)),
+            diffedPreloadAssets.styles.map((style) => /* @__PURE__ */ jsx(
+              StylePreload,
+              {
+                asset: style,
+                baseUrl
+              },
+              style.source
+            )),
+            diffedPreloadAssets.scripts.map((script) => /* @__PURE__ */ jsx(
+              ScriptPreload,
+              {
+                asset: script,
+                baseUrl
+              },
+              script.source
+            ))
+          ] })
+        );
         writer.write(additionalAssetsContent);
       }
       writer.write(secondChunk);
       writer.close();
     };
     waitUntil(renderFullHTML());
-    return {
-      headers,
-      body
-    };
+    return { headers: headers2, body: body2 };
   }
 }
 function preloadHeader(attributes) {
   const {
     as,
-    rel = 'preload',
+    rel = "preload",
     href,
     crossOrigin,
     crossorigin
   } = attributes;
-
-  // Support both property and attribute versions of the casing
   const finalCrossOrigin = crossOrigin ?? crossorigin;
   let header = `<${href}>; rel="${rel}"; as="${as}"`;
-  if (finalCrossOrigin === '' || finalCrossOrigin === true) {
+  if (finalCrossOrigin === "" || finalCrossOrigin === true) {
     header += `; crossorigin`;
-  } else if (typeof finalCrossOrigin === 'string') {
+  } else if (typeof finalCrossOrigin === "string") {
     header += `; crossorigin="${finalCrossOrigin}"`;
   }
   return header;
 }
 function diffBrowserAssetsEntries(newList, oldList) {
-  const oldStyles = new Set(oldList.styles.map(style => style.source));
-  const oldScripts = new Set(oldList.scripts.map(script => script.source));
+  const oldStyles = new Set(oldList.styles.map((style) => style.source));
+  const oldScripts = new Set(oldList.scripts.map((script) => script.source));
   return {
-    styles: newList.styles.filter(style => !oldStyles.has(style.source)),
-    scripts: newList.scripts.filter(script => !oldScripts.has(script.source))
+    styles: newList.styles.filter((style) => !oldStyles.has(style.source)),
+    scripts: newList.scripts.filter((script) => !oldScripts.has(script.source))
   };
 }
 function noop(..._args) {
-  // noop
 }
 
 export { renderToResponse };

package/build/esnext/utilities/react.esnext

@@ -1,10 +1,7 @@
 import { jsx } from 'react/jsx-runtime';
 
 function maybeWrapContext(Context, value, children) {
-  return value ? /*#__PURE__*/jsx(Context.Provider, {
-    value: value,
-    children: children
-  }) : children;
+  return value ? /* @__PURE__ */ jsx(Context.Provider, { value, children }) : children;
 }
 
 export { maybeWrapContext };