@quilted/quilt 0.5.66 → 0.5.69

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # @quilted/quilt
 
+## 0.5.69
+
+### Patch Changes
+
+- [`937a890`](https://github.com/lemonmade/quilt/commit/937a89009924a7b1d9e2a102028efd97928396e3) Thanks [@lemonmade](https://github.com/lemonmade)! - Improve base TypeScript preset
+
+## 0.5.68
+
+### Patch Changes
+
+- [`c4c6792`](https://github.com/lemonmade/quilt/commit/c4c6792ef355cc3bc8c8ada65ec7b1db8a836fef) Thanks [@lemonmade](https://github.com/lemonmade)! - Improve server rendering helpers
+
+## 0.5.67
+
+### Patch Changes
+
+- [`ec90a3f`](https://github.com/lemonmade/quilt/commit/ec90a3f0de7366a42fd1e13b903154f5bc8c0a54) Thanks [@lemonmade](https://github.com/lemonmade)! - Add simpler way of rendering React to a http-handlers response
+
 ## 0.5.66
 
 ### Patch Changes

package/build/cjs/server/http-handler.cjs

@@ -7,78 +7,81 @@ var httpHandlers = require('@quilted/http-handlers');
 var render = require('./render.cjs');
 var jsxRuntime = require('react/jsx-runtime');
 
-function createServerRenderingRequestHandler(App, {
-  assets,
-  renderProps = () => ({})
+function createServerRenderingHttpHandler(App, {
+  handler = httpHandlers.createHttpHandler(),
+  ...options
 }) {
-  return async request => {
-    const accepts = request.headers.get('Accept');
-    if (accepts != null && !accepts.includes('text/html')) return;
-    const {
-      html: htmlManager,
-      http,
-      markup,
-      asyncAssets
-    } = await render.renderApp( /*#__PURE__*/jsxRuntime.jsx(App, { ...renderProps?.({
+  handler.get(createServerRenderingRequestHandler(App, options));
+  return handler;
+}
+function createServerRenderingRequestHandler(App, {
+  renderProps,
+  ...options
+} = {}) {
+  return request => {
+    return renderToResponse( /*#__PURE__*/jsxRuntime.jsx(App, { ...renderProps?.({
         request
       })
-    }), {
-      url: request.url,
-      headers: request.headers
-    });
-    const {
-      headers,
-      statusCode = 200,
-      redirectUrl
-    } = http.state;
-
-    if (redirectUrl) {
-      return httpHandlers.redirect(redirectUrl, {
-        status: statusCode,
-        headers
-      });
-    }
-
-    const usedAssets = asyncAssets.used({
-      timing: 'load'
-    });
-    const assetOptions = {
-      userAgent: request.headers.get('User-Agent')
-    };
-    const [styles, scripts, preload] = await Promise.all([assets.styles({
-      async: usedAssets,
-      options: assetOptions
-    }), assets.scripts({
-      async: usedAssets,
-      options: assetOptions
-    }), assets.asyncAssets(asyncAssets.used({
-      timing: 'preload'
-    }), {
-      options: assetOptions
-    })]);
-    return httpHandlers.html(server.render( /*#__PURE__*/jsxRuntime.jsx(server.Html, {
-      manager: htmlManager,
-      styles: styles,
-      scripts: scripts,
-      preloadAssets: preload,
-      children: markup
-    })), {
-      headers,
-      status: statusCode
-    });
+    }), request, options);
   };
 }
-function createServerRenderingHttpHandler(App, {
+async function renderToResponse(element, request, {
   assets,
-  renderProps,
-  handler = httpHandlers.createHttpHandler()
-}) {
-  handler.get(createServerRenderingRequestHandler(App, {
-    assets,
-    renderProps
-  }));
-  return handler;
+  ...options
+} = {}) {
+  const accepts = request.headers.get('Accept');
+  if (accepts != null && !accepts.includes('text/html')) return;
+  const {
+    html: htmlManager,
+    http,
+    markup,
+    asyncAssets
+  } = await render.renderApp(element, { ...options,
+    url: request.url,
+    headers: request.headers
+  });
+  const {
+    headers,
+    statusCode = 200,
+    redirectUrl
+  } = http.state;
+
+  if (redirectUrl) {
+    return httpHandlers.redirect(redirectUrl, {
+      status: statusCode,
+      headers
+    });
+  }
+
+  const usedAssets = asyncAssets.used({
+    timing: 'load'
+  });
+  const assetOptions = {
+    userAgent: request.headers.get('User-Agent')
+  };
+  const [styles, scripts, preload] = assets ? await Promise.all([assets.styles({
+    async: usedAssets,
+    options: assetOptions
+  }), assets.scripts({
+    async: usedAssets,
+    options: assetOptions
+  }), assets.asyncAssets(asyncAssets.used({
+    timing: 'preload'
+  }), {
+    options: assetOptions
+  })]) : [];
+  return httpHandlers.html(server.render( /*#__PURE__*/jsxRuntime.jsx(server.Html, {
+    manager: htmlManager,
+    styles: styles,
+    scripts: scripts,
+    preloadAssets: preload,
+    children: markup
+  })), {
+    headers,
+    status: statusCode
+  });
 }
 
 exports.createServerRenderingHttpHandler = createServerRenderingHttpHandler;
 exports.createServerRenderingRequestHandler = createServerRenderingRequestHandler;
+exports.renderToResponse = renderToResponse;

package/build/cjs/server/index.cjs

@@ -86,3 +86,4 @@ exports.renderApp = render.renderApp;
 exports.ServerContext = ServerContext.ServerContext;
 exports.createServerRenderingHttpHandler = httpHandler.createServerRenderingHttpHandler;
 exports.createServerRenderingRequestHandler = httpHandler.createServerRenderingRequestHandler;
+exports.renderToResponse = httpHandler.renderToResponse;

package/build/esm/server/http-handler.mjs

@@ -1,79 +1,81 @@
 import { render, Html } from '@quilted/react-html/server';
-import { redirect, html, createHttpHandler } from '@quilted/http-handlers';
+import { createHttpHandler, redirect, html } from '@quilted/http-handlers';
 import { renderApp } from './render.mjs';
 import { jsx } from 'react/jsx-runtime';
 
-function createServerRenderingRequestHandler(App, {
-  assets,
-  renderProps = () => ({})
+function createServerRenderingHttpHandler(App, {
+  handler = createHttpHandler(),
+  ...options
 }) {
-  return async request => {
-    const accepts = request.headers.get('Accept');
-    if (accepts != null && !accepts.includes('text/html')) return;
-    const {
-      html: htmlManager,
-      http,
-      markup,
-      asyncAssets
-    } = await renderApp( /*#__PURE__*/jsx(App, { ...renderProps?.({
+  handler.get(createServerRenderingRequestHandler(App, options));
+  return handler;
+}
+function createServerRenderingRequestHandler(App, {
+  renderProps,
+  ...options
+} = {}) {
+  return request => {
+    return renderToResponse( /*#__PURE__*/jsx(App, { ...renderProps?.({
         request
       })
-    }), {
-      url: request.url,
-      headers: request.headers
-    });
-    const {
-      headers,
-      statusCode = 200,
-      redirectUrl
-    } = http.state;
-
-    if (redirectUrl) {
-      return redirect(redirectUrl, {
-        status: statusCode,
-        headers
-      });
-    }
-
-    const usedAssets = asyncAssets.used({
-      timing: 'load'
-    });
-    const assetOptions = {
-      userAgent: request.headers.get('User-Agent')
-    };
-    const [styles, scripts, preload] = await Promise.all([assets.styles({
-      async: usedAssets,
-      options: assetOptions
-    }), assets.scripts({
-      async: usedAssets,
-      options: assetOptions
-    }), assets.asyncAssets(asyncAssets.used({
-      timing: 'preload'
-    }), {
-      options: assetOptions
-    })]);
-    return html(render( /*#__PURE__*/jsx(Html, {
-      manager: htmlManager,
-      styles: styles,
-      scripts: scripts,
-      preloadAssets: preload,
-      children: markup
-    })), {
-      headers,
-      status: statusCode
-    });
+    }), request, options);
   };
 }
-function createServerRenderingHttpHandler(App, {
+async function renderToResponse(element, request, {
   assets,
-  renderProps,
-  handler = createHttpHandler()
-}) {
-  handler.get(createServerRenderingRequestHandler(App, {
-    assets,
-    renderProps
-  }));
-  return handler;
+  ...options
+} = {}) {
+  const accepts = request.headers.get('Accept');
+  if (accepts != null && !accepts.includes('text/html')) return;
+  const {
+    html: htmlManager,
+    http,
+    markup,
+    asyncAssets
+  } = await renderApp(element, { ...options,
+    url: request.url,
+    headers: request.headers
+  });
+  const {
+    headers,
+    statusCode = 200,
+    redirectUrl
+  } = http.state;
+
+  if (redirectUrl) {
+    return redirect(redirectUrl, {
+      status: statusCode,
+      headers
+    });
+  }
+
+  const usedAssets = asyncAssets.used({
+    timing: 'load'
+  });
+  const assetOptions = {
+    userAgent: request.headers.get('User-Agent')
+  };
+  const [styles, scripts, preload] = assets ? await Promise.all([assets.styles({
+    async: usedAssets,
+    options: assetOptions
+  }), assets.scripts({
+    async: usedAssets,
+    options: assetOptions
+  }), assets.asyncAssets(asyncAssets.used({
+    timing: 'preload'
+  }), {
+    options: assetOptions
+  })]) : [];
+  return html(render( /*#__PURE__*/jsx(Html, {
+    manager: htmlManager,
+    styles: styles,
+    scripts: scripts,
+    preloadAssets: preload,
+    children: markup
+  })), {
+    headers,
+    status: statusCode
+  });
 }
 
-export { createServerRenderingHttpHandler, createServerRenderingRequestHandler };
+export { createServerRenderingHttpHandler, createServerRenderingRequestHandler, renderToResponse };

package/build/esm/server/index.mjs

@@ -6,4 +6,4 @@ export { renderEmail } from '@quilted/react-email/server';
 export { createHttpHandler } from '@quilted/http-handlers';
 export { renderApp } from './render.mjs';
 export { ServerContext } from './ServerContext.mjs';
-export { createServerRenderingHttpHandler, createServerRenderingRequestHandler } from './http-handler.mjs';
+export { createServerRenderingHttpHandler, createServerRenderingRequestHandler, renderToResponse } from './http-handler.mjs';

package/build/esnext/server/http-handler.esnext

@@ -1,79 +1,81 @@
 import { render, Html } from '@quilted/react-html/server';
-import { redirect, html, createHttpHandler } from '@quilted/http-handlers';
+import { createHttpHandler, redirect, html } from '@quilted/http-handlers';
 import { renderApp } from './render.esnext';
 import { jsx } from 'react/jsx-runtime';
 
-function createServerRenderingRequestHandler(App, {
-  assets,
-  renderProps = () => ({})
+function createServerRenderingHttpHandler(App, {
+  handler = createHttpHandler(),
+  ...options
 }) {
-  return async request => {
-    const accepts = request.headers.get('Accept');
-    if (accepts != null && !accepts.includes('text/html')) return;
-    const {
-      html: htmlManager,
-      http,
-      markup,
-      asyncAssets
-    } = await renderApp( /*#__PURE__*/jsx(App, { ...renderProps?.({
+  handler.get(createServerRenderingRequestHandler(App, options));
+  return handler;
+}
+function createServerRenderingRequestHandler(App, {
+  renderProps,
+  ...options
+} = {}) {
+  return request => {
+    return renderToResponse( /*#__PURE__*/jsx(App, { ...renderProps?.({
         request
       })
-    }), {
-      url: request.url,
-      headers: request.headers
-    });
-    const {
-      headers,
-      statusCode = 200,
-      redirectUrl
-    } = http.state;
-
-    if (redirectUrl) {
-      return redirect(redirectUrl, {
-        status: statusCode,
-        headers
-      });
-    }
-
-    const usedAssets = asyncAssets.used({
-      timing: 'load'
-    });
-    const assetOptions = {
-      userAgent: request.headers.get('User-Agent')
-    };
-    const [styles, scripts, preload] = await Promise.all([assets.styles({
-      async: usedAssets,
-      options: assetOptions
-    }), assets.scripts({
-      async: usedAssets,
-      options: assetOptions
-    }), assets.asyncAssets(asyncAssets.used({
-      timing: 'preload'
-    }), {
-      options: assetOptions
-    })]);
-    return html(render( /*#__PURE__*/jsx(Html, {
-      manager: htmlManager,
-      styles: styles,
-      scripts: scripts,
-      preloadAssets: preload,
-      children: markup
-    })), {
-      headers,
-      status: statusCode
-    });
+    }), request, options);
   };
 }
-function createServerRenderingHttpHandler(App, {
+async function renderToResponse(element, request, {
   assets,
-  renderProps,
-  handler = createHttpHandler()
-}) {
-  handler.get(createServerRenderingRequestHandler(App, {
-    assets,
-    renderProps
-  }));
-  return handler;
+  ...options
+} = {}) {
+  const accepts = request.headers.get('Accept');
+  if (accepts != null && !accepts.includes('text/html')) return;
+  const {
+    html: htmlManager,
+    http,
+    markup,
+    asyncAssets
+  } = await renderApp(element, { ...options,
+    url: request.url,
+    headers: request.headers
+  });
+  const {
+    headers,
+    statusCode = 200,
+    redirectUrl
+  } = http.state;
+
+  if (redirectUrl) {
+    return redirect(redirectUrl, {
+      status: statusCode,
+      headers
+    });
+  }
+
+  const usedAssets = asyncAssets.used({
+    timing: 'load'
+  });
+  const assetOptions = {
+    userAgent: request.headers.get('User-Agent')
+  };
+  const [styles, scripts, preload] = assets ? await Promise.all([assets.styles({
+    async: usedAssets,
+    options: assetOptions
+  }), assets.scripts({
+    async: usedAssets,
+    options: assetOptions
+  }), assets.asyncAssets(asyncAssets.used({
+    timing: 'preload'
+  }), {
+    options: assetOptions
+  })]) : [];
+  return html(render( /*#__PURE__*/jsx(Html, {
+    manager: htmlManager,
+    styles: styles,
+    scripts: scripts,
+    preloadAssets: preload,
+    children: markup
+  })), {
+    headers,
+    status: statusCode
+  });
 }
 
-export { createServerRenderingHttpHandler, createServerRenderingRequestHandler };
+export { createServerRenderingHttpHandler, createServerRenderingRequestHandler, renderToResponse };

package/build/esnext/server/index.esnext

@@ -6,4 +6,4 @@ export { renderEmail } from '@quilted/react-email/server';
 export { createHttpHandler } from '@quilted/http-handlers';
 export { renderApp } from './render.esnext';
 export { ServerContext } from './ServerContext.esnext';
-export { createServerRenderingHttpHandler, createServerRenderingRequestHandler } from './http-handler.esnext';
+export { createServerRenderingHttpHandler, createServerRenderingRequestHandler, renderToResponse } from './http-handler.esnext';