@quilted/quilt 0.5.151 → 0.5.153

package/build/cjs/navigate.cjs

@@ -0,0 +1,70 @@
+'use strict';
+
+var reactRouter = require('@quilted/react-router');
+
+
+
+Object.defineProperty(exports, 'Link', {
+  enumerable: true,
+  get: function () { return reactRouter.Link; }
+});
+Object.defineProperty(exports, 'NavigationBlock', {
+  enumerable: true,
+  get: function () { return reactRouter.NavigationBlock; }
+});
+Object.defineProperty(exports, 'Redirect', {
+  enumerable: true,
+  get: function () { return reactRouter.Redirect; }
+});
+Object.defineProperty(exports, 'RoutePreloading', {
+  enumerable: true,
+  get: function () { return reactRouter.RoutePreloading; }
+});
+Object.defineProperty(exports, 'Routing', {
+  enumerable: true,
+  get: function () { return reactRouter.Routing; }
+});
+Object.defineProperty(exports, 'useCurrentUrl', {
+  enumerable: true,
+  get: function () { return reactRouter.useCurrentUrl; }
+});
+Object.defineProperty(exports, 'useInitialUrl', {
+  enumerable: true,
+  get: function () { return reactRouter.useInitialUrl; }
+});
+Object.defineProperty(exports, 'useNavigate', {
+  enumerable: true,
+  get: function () { return reactRouter.useNavigate; }
+});
+Object.defineProperty(exports, 'useNavigationBlock', {
+  enumerable: true,
+  get: function () { return reactRouter.useNavigationBlock; }
+});
+Object.defineProperty(exports, 'useRedirect', {
+  enumerable: true,
+  get: function () { return reactRouter.useRedirect; }
+});
+Object.defineProperty(exports, 'useRouteChangeFocusRef', {
+  enumerable: true,
+  get: function () { return reactRouter.useRouteChangeFocusRef; }
+});
+Object.defineProperty(exports, 'useRouteMatch', {
+  enumerable: true,
+  get: function () { return reactRouter.useRouteMatch; }
+});
+Object.defineProperty(exports, 'useRouteMatchDetails', {
+  enumerable: true,
+  get: function () { return reactRouter.useRouteMatchDetails; }
+});
+Object.defineProperty(exports, 'useRouter', {
+  enumerable: true,
+  get: function () { return reactRouter.useRouter; }
+});
+Object.defineProperty(exports, 'useRoutes', {
+  enumerable: true,
+  get: function () { return reactRouter.useRoutes; }
+});
+Object.defineProperty(exports, 'useScrollRestoration', {
+  enumerable: true,
+  get: function () { return reactRouter.useScrollRestoration; }
+});

package/build/cjs/performance.cjs

@@ -0,0 +1,26 @@
+'use strict';
+
+var reactPerformance = require('@quilted/react-performance');
+
+
+
+Object.defineProperty(exports, 'PerformanceContext', {
+  enumerable: true,
+  get: function () { return reactPerformance.PerformanceContext; }
+});
+Object.defineProperty(exports, 'createPerformance', {
+  enumerable: true,
+  get: function () { return reactPerformance.createPerformance; }
+});
+Object.defineProperty(exports, 'usePerformance', {
+  enumerable: true,
+  get: function () { return reactPerformance.usePerformance; }
+});
+Object.defineProperty(exports, 'usePerformanceNavigation', {
+  enumerable: true,
+  get: function () { return reactPerformance.usePerformanceNavigation; }
+});
+Object.defineProperty(exports, 'usePerformanceNavigationEvent', {
+  enumerable: true,
+  get: function () { return reactPerformance.usePerformanceNavigationEvent; }
+});

package/build/cjs/polyfills/fetch-get-set-cookie.cjs

@@ -0,0 +1,4 @@
+'use strict';
+
+require('@quilted/polyfills/fetch-get-set-cookie');
+

package/build/cjs/react/testing.cjs

@@ -0,0 +1,30 @@
+'use strict';
+
+require('@quilted/react-testing/matchers');
+var testing = require('@quilted/testing');
+var reactTesting = require('@quilted/react-testing');
+
+
+
+Object.defineProperty(exports, 'createRender', {
+  enumerable: true,
+  get: function () { return reactTesting.createRender; }
+});
+Object.defineProperty(exports, 'destroyAll', {
+  enumerable: true,
+  get: function () { return reactTesting.destroyAll; }
+});
+Object.defineProperty(exports, 'render', {
+  enumerable: true,
+  get: function () { return reactTesting.render; }
+});
+Object.defineProperty(exports, 'rendered', {
+  enumerable: true,
+  get: function () { return reactTesting.rendered; }
+});
+Object.keys(testing).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return testing[k]; }
+  });
+});

package/build/cjs/react/tools.cjs

@@ -0,0 +1,19 @@
+'use strict';
+
+var usefulReactTypes = require('@quilted/useful-react-types');
+var reactUtilities = require('@quilted/react-utilities');
+
+
+
+Object.keys(usefulReactTypes).forEach(function (k) {
+	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function () { return usefulReactTypes[k]; }
+	});
+});
+Object.keys(reactUtilities).forEach(function (k) {
+	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function () { return reactUtilities[k]; }
+	});
+});

package/build/cjs/react.cjs

@@ -0,0 +1,15 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var react = require('@quilted/react');
+
+
+
+exports["default"] = react;
+Object.keys(react).forEach(function (k) {
+	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function () { return react[k]; }
+	});
+});

package/build/cjs/server/ServerContext.cjs

@@ -14,7 +14,7 @@ function ServerContext({
   children
 }) {
   const normalizedUrl = typeof url === 'string' ? new URL(url) : url;
-  return react.maybeWrapContext(server$2.AssetsContext, assets, react.maybeWrapContext(server.HttpServerContext, http, react.maybeWrapContext(server$1.HtmlContext, html, react.maybeWrapContext(reactRouter.InitialUrlContext, normalizedUrl, children))));
+  return react.maybeWrapContext(server$2.AssetsContext, assets, react.maybeWrapContext(server.HttpServerContext, http, react.maybeWrapContext(server$1.HTMLContext, html, react.maybeWrapContext(reactRouter.InitialUrlContext, normalizedUrl, children))));
 }
 
 exports.ServerContext = ServerContext;

package/build/cjs/server/preload.cjs

@@ -8,7 +8,7 @@ function createAssetPreloader(options) {
       ...options,
       context: requestContext
     });
-    return requestRouter.json(manifest);
+    return new requestRouter.JSONResponse(manifest);
   };
 }
 async function assetsForRequest(request, {

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

@@ -1,6 +1,7 @@
 'use strict';
 
 var react = require('react');
+var server$4 = require('react-dom/server');
 var assets = require('@quilted/assets');
 var server$2 = require('@quilted/react-assets/server');
 var server$1 = require('@quilted/react-http/server');
@@ -10,250 +11,224 @@ var requestRouter = require('@quilted/request-router');
 var ServerContext = require('./ServerContext.cjs');
 var jsxRuntime = require('react/jsx-runtime');
 
-function createServerRender(...args) {
-  let getApp;
+async function renderToResponse(optionsOrElement, definitelyOptions) {
+  let element;
   let options;
-  if (args.length > 1) {
-    getApp = args[0];
-    options = args[1] ?? {};
+  if ( /*#__PURE__*/react.isValidElement(optionsOrElement)) {
+    element = optionsOrElement;
+    options = definitelyOptions;
   } else {
-    options = args[0] ?? {};
+    options = optionsOrElement;
   }
-  const stream = options.stream;
-  return async (request, requestContext) => {
-    const accepts = request.headers.get('Accept');
-    if (accepts != null && !accepts.includes('text/html')) return;
-    const renderResponse = stream ? renderAppToStreamedResponse : renderAppToResponse;
-    return renderResponse(typeof getApp === 'function' ? () => getApp(request, requestContext) : getApp, {
-      ...options,
-      request,
-      context: requestContext,
-      extract: {
-        ...options.extract,
-        context: typeof options.extract?.context === 'function' ? options.extract.context(request, requestContext) : options.extract?.context
-      }
-    });
-  };
-}
-async function renderAppToResponse(getApp, {
-  request,
-  context,
-  assets,
-  extract,
-  html: htmlOptions
-}) {
-  const app = typeof getApp === 'function' ? await getApp() : getApp;
-  const cacheKey = await assets?.cacheKey?.(request);
-  const renderDetails = await serverRenderDetailsForApp(app, {
-    extract,
-    cacheKey,
-    url: request.url,
-    headers: request.headers
-  });
   const {
-    headers,
-    statusCode = 200,
-    redirectUrl
-  } = renderDetails.http.state;
-  if (redirectUrl) {
-    return requestRouter.redirect(redirectUrl, {
-      status: statusCode,
-      headers
-    });
-  }
-  const content = await renderAppDetailsToHtmlString(renderDetails, {
     request,
-    context,
-    assets,
-    html: htmlOptions
-  });
-  return requestRouter.html(content, {
-    headers,
-    status: statusCode
+    stream: shouldStream = false,
+    assets: assets$1,
+    cacheKey: explicitCacheKey,
+    waitUntil = noop,
+    renderHTML
+  } = options;
+  const baseUrl = request.URL ?? new URL(request.url);
+  const cacheKey = explicitCacheKey ?? (await assets$1?.cacheKey?.(request)) ?? {};
+  const html = new server.HTMLManager();
+  const http = new server$1.HttpManager({
+    headers: request.headers
   });
-}
-async function renderAppToStreamedResponse(getApp, {
-  request,
-  context,
-  assets: assets$1,
-  extract,
-  html: htmlOptions
-}) {
-  const headers = new Headers();
-  const stream = new TransformStream();
-  const cacheKey = await assets$1?.cacheKey?.(request);
-  const guaranteedAssets = await assets$1?.entry({
+  const assetsManager = new server$2.AssetsManager({
     cacheKey
   });
-  if (guaranteedAssets) {
-    for (const style of guaranteedAssets.styles) {
-      headers.append('Link', preloadHeader(assets.styleAssetPreloadAttributes(style)));
-    }
-    for (const script of guaranteedAssets.scripts) {
-      headers.append('Link', preloadHeader(assets.scriptAssetPreloadAttributes(script)));
+  let responseStatus = 200;
+  let appHeaders;
+  let appStream;
+  if (shouldStream === false && element != null) {
+    const rendered = await server$3.extract(element, {
+      decorate(element) {
+        return /*#__PURE__*/jsxRuntime.jsx(ServerContext.ServerContext, {
+          http: http,
+          html: html,
+          url: baseUrl,
+          assets: assetsManager,
+          children: element
+        });
+      }
+    });
+    const {
+      headers,
+      statusCode = 200,
+      redirectUrl
+    } = http.state;
+    if (redirectUrl) {
+      return new requestRouter.RedirectResponse(redirectUrl, {
+        status: statusCode,
+        headers,
+        request
+      });
     }
+    appHeaders = headers;
+    responseStatus = statusCode;
+    const appTransformStream = new TransformStream();
+    const appWriter = appTransformStream.writable.getWriter();
+    appStream = appTransformStream.readable;
+    appWriter.write(rendered);
+    appWriter.close();
   }
-  renderResponseToStream();
-  return requestRouter.html(stream.readable, {
-    headers,
-    status: 200
-  });
-  async function renderResponseToStream() {
-    const app = typeof getApp === 'function' ? await getApp() : getApp;
-    const renderDetails = await serverRenderDetailsForApp(app, {
-      extract,
-      cacheKey,
-      url: request.url,
-      headers: request.headers
-    });
-    const content = await renderAppDetailsToHtmlString(renderDetails, {
-      request,
-      context,
-      assets: assets$1,
-      html: htmlOptions
-    });
-    const encoder = new TextEncoder();
-    const writer = stream.writable.getWriter();
-    await writer.write(encoder.encode(content));
-    await writer.close();
+  if (appStream == null) {
+    const appTransformStream = new TransformStream();
+    appStream = appTransformStream.readable;
+    const renderAppStream = async function renderAppStream() {
+      const appWriter = appTransformStream.writable.getWriter();
+      if (element != null) {
+        const rendered = await server$3.extract(element, {
+          decorate(element) {
+            return /*#__PURE__*/jsxRuntime.jsx(ServerContext.ServerContext, {
+              http: http,
+              html: html,
+              url: baseUrl,
+              assets: assetsManager,
+              children: element
+            });
+          }
+        });
+        appWriter.write(rendered);
+      }
+      appWriter.close();
+    };
+    waitUntil(renderAppStream());
   }
-}
-async function serverRenderDetailsForApp(app, {
-  url,
-  headers,
-  cacheKey,
-  extract: extractOptions
-} = {}) {
-  const html = new server.HtmlManager();
-  const http = new server$1.HttpManager({
+  const {
+    headers,
+    body
+  } = await renderToHTMLStream(appStream);
+  return new requestRouter.HTMLResponse(body, {
+    status: responseStatus,
     headers
   });
-  const assets = new server$2.AssetsManager({
-    cacheKey
-  });
-  const {
-    decorate,
-    ...rest
-  } = extractOptions ?? {};
-  const rendered = app ? await server$3.extract(app, {
-    decorate(app) {
-      return /*#__PURE__*/jsxRuntime.jsx(ServerContext.ServerContext, {
-        http: http,
-        html: html,
-        url: url,
-        assets: assets,
-        children: decorate?.(app) ?? app
+  async function renderToHTMLStream(content) {
+    const headers = new Headers(appHeaders);
+    const [synchronousAssets, preloadAssets] = await Promise.all([assets$1?.entry({
+      cacheKey,
+      modules: assetsManager.usedModules({
+        timing: 'load'
+      })
+    }), assets$1?.modules(assetsManager.usedModules({
+      timing: 'preload'
+    }), {
+      cacheKey
+    })]);
+    if (synchronousAssets) {
+      for (const style of synchronousAssets.styles) {
+        headers.append('Link', preloadHeader(assets.styleAssetPreloadAttributes(style)));
+      }
+      for (const script of synchronousAssets.scripts) {
+        headers.append('Link', preloadHeader(assets.scriptAssetPreloadAttributes(script)));
+      }
+    }
+    if (renderHTML) {
+      const body = await renderHTML(content, {
+        manager: html,
+        assets: synchronousAssets,
+        preloadAssets
       });
-    },
-    ...rest
-  }) : undefined;
-  return {
-    rendered,
-    http,
-    html,
-    assets
-  };
-}
-async function renderAppDetailsToHtmlString(details, {
-  request,
-  context,
-  assets,
-  html: htmlOptions
-}) {
-  const {
-    http,
-    rendered,
-    html: htmlManager,
-    assets: assetsManager
-  } = details;
-  const cacheKey = assetsManager.cacheKey;
-  const usedModules = assetsManager.usedModules({
-    timing: 'load'
-  });
-  const [entryAssets, preloadAssets] = assets ? await Promise.all([assets.entry({
-    modules: usedModules,
-    cacheKey
-  }), assets.modules(assetsManager.usedModules({
-    timing: 'preload'
-  }), {
-    cacheKey
-  })]) : [];
-  let renderHtml;
-  let rootElement;
-  if (typeof htmlOptions === 'function') {
-    renderHtml = htmlOptions;
-  } else {
-    rootElement = htmlOptions?.rootElement;
-    renderHtml = defaultRenderHtml;
+      return {
+        headers,
+        body
+      };
+    }
+    const responseStream = new TextEncoderStream();
+    const body = responseStream.readable;
+    const renderFullHTML = async function renderFullHTML() {
+      const writer = responseStream.writable.getWriter();
+      writer.write(`<!DOCTYPE html>`);
+      const {
+        htmlAttributes,
+        bodyAttributes,
+        ...headProps
+      } = html.state;
+      const htmlContent = server$4.renderToStaticMarkup(
+      /*#__PURE__*/
+      // eslint-disable-next-line jsx-a11y/html-has-lang
+      jsxRuntime.jsxs("html", {
+        ...htmlAttributes,
+        children: [/*#__PURE__*/jsxRuntime.jsxs("head", {
+          children: [/*#__PURE__*/jsxRuntime.jsx(server.Head, {
+            ...headProps
+          }), synchronousAssets?.scripts.map(script => /*#__PURE__*/jsxRuntime.jsx(server.Script, {
+            asset: script,
+            baseUrl: baseUrl
+          }, script.source)), synchronousAssets?.styles.map(style => /*#__PURE__*/jsxRuntime.jsx(server.Style, {
+            asset: style,
+            baseUrl: baseUrl
+          }, style.source)), preloadAssets?.styles.map(style => /*#__PURE__*/jsxRuntime.jsx(server.StylePreload, {
+            asset: style,
+            baseUrl: baseUrl
+          }, style.source)), preloadAssets?.scripts.map(script => /*#__PURE__*/jsxRuntime.jsx(server.ScriptPreload, {
+            asset: script,
+            baseUrl: baseUrl
+          }, script.source))]
+        }), /*#__PURE__*/jsxRuntime.jsx("body", {
+          ...bodyAttributes,
+          dangerouslySetInnerHTML: {
+            __html: '%%CONTENT%%'
+          }
+        })]
+      }));
+      const [firstChunk, secondChunk] = htmlContent.split('%%CONTENT%%');
+      writer.write(firstChunk);
+      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();
+        if (done) {
+          break;
+        }
+        writer.write(value);
+      }
+      if (element != null) writer.write(`</div>`);
+      const [newSynchronousAssets, newPreloadAssets] = await Promise.all([assets$1?.entry({
+        cacheKey,
+        modules: assetsManager.usedModules({
+          timing: 'load'
+        })
+      }), assets$1?.modules(assetsManager.usedModules({
+        timing: 'preload'
+      }), {
+        cacheKey
+      })]);
+      if (newSynchronousAssets) {
+        const diffedSynchronousAssets = diffBrowserAssetsEntries(newSynchronousAssets, synchronousAssets);
+        const diffedPreloadAssets = diffBrowserAssetsEntries(newPreloadAssets, preloadAssets);
+        const additionalAssetsContent = server$4.renderToStaticMarkup( /*#__PURE__*/jsxRuntime.jsxs(jsxRuntime.Fragment, {
+          children: [diffedSynchronousAssets.scripts.map(script => /*#__PURE__*/jsxRuntime.jsx(server.Script, {
+            asset: script,
+            baseUrl: baseUrl
+          }, script.source)), diffedSynchronousAssets.styles.map(style => /*#__PURE__*/jsxRuntime.jsx(server.Style, {
+            asset: style,
+            baseUrl: baseUrl
+          }, style.source)), diffedPreloadAssets.styles.map(style => /*#__PURE__*/jsxRuntime.jsx(server.StylePreload, {
+            asset: style,
+            baseUrl: baseUrl
+          }, style.source)), diffedPreloadAssets.scripts.map(script => /*#__PURE__*/jsxRuntime.jsx(server.ScriptPreload, {
+            asset: script,
+            baseUrl: baseUrl
+          }, script.source))]
+        }));
+        writer.write(additionalAssetsContent);
+      }
+      writer.write(secondChunk);
+      writer.close();
+    };
+    waitUntil(renderFullHTML());
+    return {
+      headers,
+      body
+    };
   }
-  const htmlElement = await renderHtml(rendered, {
-    request,
-    context,
-    html: htmlManager,
-    http,
-    assets: entryAssets,
-    preloadAssets,
-    rootElement
-  });
-  return server.renderHtmlToString(htmlElement);
 }
-const defaultRenderHtml = function defaultRenderHtml(content, {
-  request,
-  html,
-  assets: assets$1,
-  preloadAssets,
-  rootElement
-}) {
-  const baseUrl = new URL(request.url);
-  return /*#__PURE__*/jsxRuntime.jsx(server.Html, {
-    manager: html,
-    rootElement: rootElement,
-    headEndContent: /*#__PURE__*/jsxRuntime.jsxs(jsxRuntime.Fragment, {
-      children: [assets$1 && assets$1.styles.map(style => {
-        const attributes = assets.styleAssetAttributes(style, {
-          baseUrl
-        });
-        return /*#__PURE__*/jsxRuntime.jsx("link", {
-          ...attributes
-        }, style.source);
-      }), assets$1 && assets$1.scripts.map(script => {
-        const isModule = script.attributes?.type === 'module';
-        const attributes = assets.scriptAssetAttributes(script, {
-          baseUrl
-        });
-        if (isModule) {
-          return /*#__PURE__*/jsxRuntime.jsxs(react.Fragment, {
-            children: [/*#__PURE__*/jsxRuntime.jsx("link", {
-              ...assets.scriptAssetPreloadAttributes(script)
-            }), /*#__PURE__*/jsxRuntime.jsx("script", {
-              ...attributes,
-              async: true
-            })]
-          }, script.source);
-        }
-        return /*#__PURE__*/jsxRuntime.jsx("script", {
-          ...attributes,
-          defer: true
-        }, script.source);
-      }), preloadAssets && preloadAssets.styles.map(style => {
-        const attributes = assets.styleAssetPreloadAttributes(style, {
-          baseUrl
-        });
-        return /*#__PURE__*/jsxRuntime.jsx("link", {
-          ...attributes
-        }, style.source);
-      }), preloadAssets && preloadAssets.scripts.map(script => {
-        const attributes = assets.scriptAssetPreloadAttributes(script, {
-          baseUrl
-        });
-        return /*#__PURE__*/jsxRuntime.jsx("link", {
-          ...attributes
-        }, script.source);
-      })]
-    }),
-    children: content
-  });
-};
 function preloadHeader(attributes) {
   const {
     as,
@@ -273,7 +248,16 @@ function preloadHeader(attributes) {
   }
   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));
+  return {
+    styles: newList.styles.filter(style => !oldStyles.has(style.source)),
+    scripts: newList.scripts.filter(script => !oldScripts.has(script.source))
+  };
+}
+function noop(..._args) {
+  // noop
+}
 
-exports.createServerRender = createServerRender;
-exports.renderAppToResponse = renderAppToResponse;
-exports.renderAppToStreamedResponse = renderAppToStreamedResponse;
+exports.renderToResponse = renderToResponse;