@quilted/quilt 0.0.0-Simpler-Quilt-app-context-component-20220421223224

package/build/cjs/static/index.cjs

@@ -0,0 +1,306 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var server = require('@quilted/react-html/server');
+var _static = require('@quilted/react-router/static');
+var render = require('./render.cjs');
+var jsxRuntime = require('react/jsx-runtime');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n["default"] = e;
+  return Object.freeze(n);
+}
+
+const BASE_URL = 'http://localhost:3000';
+async function renderStatic(App, {
+  assets,
+  routes: startingRoutes,
+  onRender,
+  crawl = true,
+  baseUrl = BASE_URL,
+  prettify = true
+}) {
+  const routesToHandle = startingRoutes.map(route => ({
+    route: removePostfixSlash(new URL(route, baseUrl).pathname),
+    fallback: false
+  }));
+  const seenRoutes = [...routesToHandle];
+  const seenRouteIds = new Set(seenRoutes.map(({
+    route
+  }) => route));
+  let renderableRoute;
+
+  while (renderableRoute = routesToHandle.shift()) {
+    const {
+      route,
+      fallback
+    } = renderableRoute;
+    const url = new URL(route, baseUrl);
+    const {
+      html,
+      http,
+      routes
+    } = await renderUrl(url, {
+      fallback
+    });
+
+    if (crawl) {
+      for (const {
+        routes: routeDefinitions,
+        fallback = false,
+        consumedPath,
+        prefix
+      } of routes) {
+        var _routeDefinitions;
+
+        const basePathname = joinPath(prefix, consumedPath);
+        const baseId = basePathname === '/' ? basePathname : `__QUILT_BASE_${basePathname}__`;
+
+        for (const routeDefinition of routeDefinitions) {
+          await recordRouteDefinition(routeDefinition, {
+            baseId,
+            basePathname,
+            addFallbacks: fallback
+          });
+        }
+
+        if (fallback && ((_routeDefinitions = routeDefinitions[routeDefinitions.length - 1]) === null || _routeDefinitions === void 0 ? void 0 : _routeDefinitions.match) != null) {
+          await recordRouteDefinition({}, {
+            baseId,
+            basePathname,
+            addFallbacks: fallback
+          });
+        }
+      }
+    }
+
+    await onRender({
+      route,
+      content: html,
+      http,
+      fallback,
+      hasChildren: !fallback && seenRoutes.some(otherRoute => otherRoute.route.startsWith(`${route}/`))
+    });
+  }
+
+  async function recordRouteDefinition({
+    match,
+    children,
+    renderStatic
+  }, {
+    basePathname,
+    baseId,
+    addFallbacks
+  }) {
+    if (renderStatic === false) return;
+    let routeId;
+    const hasChildren = children && children.length > 0;
+    const hasManualMatches = typeof renderStatic === 'function' && typeof match !== 'string';
+    const matchedRoutes = [];
+
+    if (typeof match === 'string') {
+      routeId = joinPath(baseId, match);
+      matchedRoutes.push({
+        id: routeId,
+        route: joinPath(basePathname, match),
+        fallback: false
+      });
+    } else if (typeof match === 'function') {
+      routeId = joinPath(baseId, `__QUILT_FUNCTION_ROUTE_${match.toString()}__`);
+    } else if (match instanceof RegExp) {
+      routeId = joinPath(`__QUILT_REGEX_ROUTE_${match.source}__`);
+    } else {
+      routeId = joinPath(baseId, '__QUILT_FALLBACK_ROUTE__');
+
+      if (!hasManualMatches) {
+        matchedRoutes.push({
+          id: routeId,
+          route: basePathname,
+          fallback: true
+        });
+      }
+    }
+
+    if (seenRouteIds.has(routeId)) return;
+    seenRouteIds.add(routeId);
+
+    if (typeof renderStatic === 'function' && typeof match !== 'string') {
+      const matchedRouteParts = await renderStatic();
+
+      for (const routePart of matchedRouteParts) {
+        const id = joinPath(baseId, `__QUILT_MATCH_${routePart}__`);
+        seenRouteIds.add(id);
+        matchedRoutes.push({
+          id,
+          route: joinPath(basePathname, routePart),
+          fallback: false
+        });
+      }
+    }
+
+    if (hasChildren) {
+      for (const {
+        id,
+        route
+      } of matchedRoutes) {
+        var _ref;
+
+        for (const child of children) {
+          await recordRouteDefinition(child, {
+            addFallbacks,
+            basePathname: route,
+            baseId: id
+          });
+        }
+
+        if (addFallbacks && ((_ref = children[children.length - 1]) === null || _ref === void 0 ? void 0 : _ref.match) != null) {
+          await recordRouteDefinition({}, {
+            addFallbacks,
+            basePathname: route,
+            baseId: id
+          });
+        }
+      }
+
+      return;
+    }
+
+    for (const {
+      route,
+      fallback
+    } of matchedRoutes) {
+      const renderableRoute = {
+        route,
+        fallback
+      };
+      seenRoutes.push(renderableRoute);
+      routesToHandle.push(renderableRoute);
+    }
+  }
+
+  async function renderUrl(url, {
+    fallback = false
+  } = {}) {
+    const routeRecorder = new _static.StaticRenderer({
+      forceFallback: fallback ? url.pathname : undefined
+    });
+    const {
+      http,
+      html: htmlManager,
+      markup,
+      asyncAssets
+    } = await render.renderApp( /*#__PURE__*/jsxRuntime.jsx(App, {}), {
+      url,
+
+      decorate(app) {
+        return /*#__PURE__*/jsxRuntime.jsx(_static.StaticRendererContext.Provider, {
+          value: routeRecorder,
+          children: app
+        });
+      }
+
+    });
+    const usedAssets = asyncAssets.used({
+      timing: 'load'
+    });
+    const [moduleStyles, moduleScripts, modulePreload, nomoduleStyles, nomoduleScripts] = await Promise.all([assets.styles({
+      async: usedAssets,
+      options: {
+        modules: true
+      }
+    }), assets.scripts({
+      async: usedAssets,
+      options: {
+        modules: true
+      }
+    }), assets.asyncAssets(asyncAssets.used({
+      timing: 'preload'
+    }), {
+      options: {
+        modules: true
+      }
+    }), assets.styles({
+      async: usedAssets,
+      options: {
+        modules: false
+      }
+    }), assets.scripts({
+      async: usedAssets,
+      options: {
+        modules: false
+      }
+    })]); // We don’t want to load styles from both bundles, so we only use module styles,
+    // since modules are intended to be the default and CSS (usually) doesn’t
+    // have features that meaningfully break older user agents.
+
+    const styles = moduleStyles.length > 0 ? moduleStyles : nomoduleStyles; // If there are nomodule scripts, we can’t really do preloading, because we can’t
+    // prevent the nomodule scripts from being preloaded in module browsers. If there
+    // are only module scripts, we can preload those.
+
+    const preload = nomoduleScripts.length > 0 ? [] : modulePreload;
+    const scripts = [...moduleScripts, ...nomoduleScripts.map(script => ({ ...script,
+      nomodule: true
+    }))];
+    const minifiedHtml = server.render( /*#__PURE__*/jsxRuntime.jsx(server.Html, {
+      manager: htmlManager,
+      styles: styles,
+      scripts: scripts,
+      preloadAssets: preload,
+      children: markup
+    }));
+    const html = prettify ? await prettifyHtml(minifiedHtml) : minifiedHtml;
+    return {
+      html,
+      http: http.state,
+      routes: routeRecorder.state
+    };
+  }
+}
+
+async function prettifyHtml(html) {
+  try {
+    const {
+      default: prettier
+    } = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('prettier')); });
+    return prettier.format(html, {
+      parser: 'html'
+    });
+  } catch (error) {
+    return html;
+  }
+}
+
+function joinPath(...parts) {
+  let path = '/';
+
+  for (const part of parts) {
+    if (typeof part !== 'string') continue;
+    const normalizedPart = part.startsWith('/') ? part.slice(1) : part;
+    if (normalizedPart.length === 0) continue;
+    if (path !== '/') path += '/';
+    path += normalizedPart;
+    path = removePostfixSlash(path);
+  }
+
+  return path;
+}
+
+function removePostfixSlash(value) {
+  return value.endsWith('/') && value !== '/' ? value.slice(0, value.length - 1) : value;
+}
+
+exports.renderStatic = renderStatic;

package/build/cjs/static/render.cjs

@@ -0,0 +1,46 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var server$3 = require('@quilted/react-server-render/server');
+var server = require('@quilted/react-html/server');
+var server$2 = require('@quilted/react-http/server');
+var server$1 = require('@quilted/react-async/server');
+var StaticContext = require('./StaticContext.cjs');
+var jsxRuntime = require('react/jsx-runtime');
+
+async function renderApp(app, {
+  decorate,
+  url,
+  headers,
+  ...rest
+} = {}) {
+  const html = new server.HtmlManager();
+  const asyncAssets = new server$1.AsyncAssetManager();
+  const http = new server$2.HttpManager({
+    headers
+  });
+  const markup = await server$3.extract(app, {
+    decorate(app) {
+      var _decorate;
+
+      return /*#__PURE__*/jsxRuntime.jsx(StaticContext.StaticContext, {
+        asyncAssets: asyncAssets,
+        html: html,
+        http: http,
+        url: url,
+        children: (_decorate = decorate === null || decorate === void 0 ? void 0 : decorate(app)) !== null && _decorate !== void 0 ? _decorate : app
+      });
+    },
+
+    ...rest
+  });
+  return {
+    markup,
+    http,
+    html,
+    asyncAssets
+  };
+}
+
+exports.renderApp = renderApp;

package/build/cjs/testing.cjs

@@ -0,0 +1,42 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var reactTesting = require('@quilted/react-testing');
+var testing = require('@quilted/react-router/testing');
+var testing$1 = require('@quilted/react-graphql/testing');
+
+
+
+Object.defineProperty(exports, 'createMount', {
+  enumerable: true,
+  get: function () { return reactTesting.createMount; }
+});
+Object.defineProperty(exports, 'mount', {
+  enumerable: true,
+  get: function () { return reactTesting.mount; }
+});
+Object.defineProperty(exports, 'unmountAll', {
+  enumerable: true,
+  get: function () { return reactTesting.unmountAll; }
+});
+Object.defineProperty(exports, 'TestRouter', {
+  enumerable: true,
+  get: function () { return testing.TestRouter; }
+});
+Object.defineProperty(exports, 'createTestRouter', {
+  enumerable: true,
+  get: function () { return testing.createTestRouter; }
+});
+Object.defineProperty(exports, 'TestGraphQL', {
+  enumerable: true,
+  get: function () { return testing$1.TestGraphQL; }
+});
+Object.defineProperty(exports, 'createFiller', {
+  enumerable: true,
+  get: function () { return testing$1.createFiller; }
+});
+Object.defineProperty(exports, 'createTestGraphQL', {
+  enumerable: true,
+  get: function () { return testing$1.createTestGraphQL; }
+});

package/build/cjs/utilities/react.cjs

@@ -0,0 +1,14 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var jsxRuntime = require('react/jsx-runtime');
+
+function maybeWrapContext(Context, value, children) {
+  return value ? /*#__PURE__*/jsxRuntime.jsx(Context.Provider, {
+    value: value,
+    children: children
+  }) : children;
+}
+
+exports.maybeWrapContext = maybeWrapContext;

package/build/cjs/workers/index.cjs

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

package/build/cjs/workers/worker.cjs

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

package/build/esm/AppContext.mjs

@@ -0,0 +1,18 @@
+import { HttpContext, CookieContext } from '@quilted/react-http';
+import { useHtmlUpdater } from '@quilted/react-html';
+import { jsx } from 'react/jsx-runtime';
+
+// TODO: have craft options to remove the bundle impact of parts of this that are
+// unused.
+function AppContext({
+  children
+}) {
+  useHtmlUpdater();
+  return /*#__PURE__*/jsx(HttpContext, {
+    children: /*#__PURE__*/jsx(CookieContext, {
+      children: children
+    })
+  });
+}
+
+export { AppContext };

package/build/esm/email.mjs

@@ -0,0 +1 @@
+export { usePlainTextContent, useSendBcc, useSendCc, useSendTo, useSender, useSubject } from '@quilted/react-email';

package/build/esm/env.mjs

@@ -0,0 +1,3 @@
+const Env = {};
+
+export { Env as default };

package/build/esm/global.mjs

@@ -0,0 +1,3 @@
+import { installAsyncAssetsGlobal } from '@quilted/async';
+
+installAsyncAssetsGlobal();

package/build/esm/html.mjs

@@ -0,0 +1 @@
+export { Alternate, BodyAttributes, Favicon, HtmlAttributes, Hydrator, Link, Meta, SearchRobots, Serialize, ThemeColor, Title, Viewport, getSerialized, useAlternateUrl, useBodyAttributes, useFavicon, useHtmlAttributes, useHtmlUpdater, useLink, useLocale, useMeta, useSearchRobots, useSerialized, useThemeColor, useTitle, useViewport } from '@quilted/react-html';

package/build/esm/http-handlers/index.mjs

@@ -0,0 +1 @@
+export * from '@quilted/http-handlers';

package/build/esm/http-handlers/node.mjs

@@ -0,0 +1 @@
+export * from '@quilted/http-handlers/node';

package/build/esm/http.mjs

@@ -0,0 +1 @@
+export { CacheControl, ContentSecurityPolicy, ContentSecurityPolicyDirective, ContentSecurityPolicySandboxAllow, ContentSecurityPolicySpecialSource, HttpContext, HttpMethod, NotFound, PermissionsPolicy, ResponseCookie, ResponseHeader, ResponseStatus, ResponseType, StatusCode, StrictTransportSecurity, useCacheControl, useContentSecurityPolicy, useDeleteResponseCookie, usePermissionsPolicy, useRequestHeader, useResponseCookie, useResponseHeader, useResponseRedirect, useResponseStatus, useStrictTransportSecurity } from '@quilted/react-http';

package/build/esm/index.mjs

@@ -0,0 +1,11 @@
+export { createAsyncLoader } from '@quilted/async';
+export { createAsyncComponent, useAsync, useAsyncAsset, usePreload } from '@quilted/react-async';
+export { GraphQLContext, createGraphQL, createGraphQLHttpFetch, useGraphQL, useMutation, useQuery } from '@quilted/react-graphql';
+export { useIdleCallback } from '@quilted/react-idle';
+export { ServerAction, useServerAction } from '@quilted/react-server-render';
+export { Localization, useLocale, useLocaleFromEnvironment, useLocalizedFormatting } from '@quilted/react-localize';
+export { PerformanceContext, usePerformance, usePerformanceNavigation } from '@quilted/react-performance';
+export { Link, NavigationBlock, Preloader, Redirect, Router, useCurrentUrl, useInitialUrl, useMatch, useNavigate, useNavigationBlock, useRedirect, useRouteChangeFocusRef, useRouter, useRoutes, useScrollRestoration } from '@quilted/react-router';
+export { createCallableWorker, createWorker, useWorker } from '@quilted/react-workers';
+export { CookieContext, useCookie, useCookies } from '@quilted/react-http';
+export { AppContext } from './AppContext.mjs';

package/build/esm/matchers.mjs

@@ -0,0 +1,2 @@
+import '@quilted/react-testing/matchers';
+import '@quilted/graphql/matchers';

package/build/esm/polyfills/base.mjs

@@ -0,0 +1 @@
+import '@quilted/polyfills/base';

package/build/esm/polyfills/crypto.mjs

@@ -0,0 +1 @@
+import '@quilted/polyfills/crypto';

package/build/esm/polyfills/fetch.mjs

@@ -0,0 +1 @@
+import '@quilted/polyfills/fetch';

package/build/esm/polyfills/noop.mjs

@@ -0,0 +1 @@
+import '@quilted/polyfills/noop';

package/build/esm/react/index.mjs

@@ -0,0 +1,2 @@
+export * from '@quilted/react';
+export { default } from '@quilted/react';

package/build/esm/react/jsx-runtime.mjs

@@ -0,0 +1 @@
+export * from '@quilted/react/jsx-runtime';

package/build/esm/react/server.mjs

@@ -0,0 +1 @@
+export * from '@quilted/react/server';

package/build/esm/react/test-utils.mjs

@@ -0,0 +1 @@
+export * from '@quilted/react/test-utils';

package/build/esm/server/ServerContext.mjs

@@ -0,0 +1,18 @@
+import { InitialUrlContext } from '@quilted/react-router';
+import { HtmlContext } from '@quilted/react-html/server';
+import { AsyncAssetContext } from '@quilted/react-async/server';
+import { HttpServerContext } from '@quilted/react-http/server';
+import { maybeWrapContext } from '../utilities/react.mjs';
+
+function ServerContext({
+  url,
+  html,
+  http,
+  asyncAssets,
+  children
+}) {
+  const normalizedUrl = typeof url === 'string' ? new URL(url) : url;
+  return maybeWrapContext(AsyncAssetContext, asyncAssets, maybeWrapContext(HttpServerContext, http, maybeWrapContext(HtmlContext, html, maybeWrapContext(InitialUrlContext, normalizedUrl, children))));
+}
+
+export { ServerContext };

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

@@ -0,0 +1,81 @@
+import { render, Html } from '@quilted/react-html/server';
+import { createHttpHandler, redirect, html } from '@quilted/http-handlers';
+import { renderApp } from './render.mjs';
+import { jsx } from 'react/jsx-runtime';
+
+function createServerRenderingHttpHandler(App, {
+  handler = createHttpHandler(),
+  ...options
+}) {
+  handler.get(createServerRenderingRequestHandler(App, options));
+  return handler;
+}
+function createServerRenderingRequestHandler(App, {
+  renderProps,
+  ...options
+} = {}) {
+  return request => {
+    return renderToResponse( /*#__PURE__*/jsx(App, { ...(renderProps === null || renderProps === void 0 ? void 0 : renderProps({
+        request
+      }))
+    }), request, options);
+  };
+}
+async function renderToResponse(element, request, {
+  assets,
+  ...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, renderToResponse };

package/build/esm/server/index.mjs

@@ -0,0 +1,9 @@
+export { SERVER_ACTION_ID as HTML_SERVER_ACTION_ID, Html, HtmlContext, HtmlManager, Serialize, render } from '@quilted/react-html/server';
+export { ServerAction, ServerRenderContext, ServerRenderManager, extract, useServerAction } from '@quilted/react-server-render/server';
+export { createAssetLoader } from '@quilted/async/server';
+export { SERVER_ACTION_ID as ASYNC_ASSETS_SERVER_ACTION_ID, AsyncAssetContext, AsyncAssetManager } from '@quilted/react-async/server';
+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, renderToResponse } from './http-handler.mjs';

package/build/esm/server/render.mjs

@@ -0,0 +1,42 @@
+import { extract } from '@quilted/react-server-render/server';
+import { HtmlManager } from '@quilted/react-html/server';
+import { HttpManager } from '@quilted/react-http/server';
+import { AsyncAssetManager } from '@quilted/react-async/server';
+import { ServerContext } from './ServerContext.mjs';
+import { jsx } from 'react/jsx-runtime';
+
+async function renderApp(app, {
+  decorate,
+  url,
+  headers,
+  ...rest
+} = {}) {
+  const html = new HtmlManager();
+  const asyncAssets = new AsyncAssetManager();
+  const http = new HttpManager({
+    headers
+  });
+  const markup = await extract(app, {
+    decorate(app) {
+      var _decorate;
+
+      return /*#__PURE__*/jsx(ServerContext, {
+        asyncAssets: asyncAssets,
+        http: http,
+        html: html,
+        url: url,
+        children: (_decorate = decorate === null || decorate === void 0 ? void 0 : decorate(app)) !== null && _decorate !== void 0 ? _decorate : app
+      });
+    },
+
+    ...rest
+  });
+  return {
+    markup,
+    http,
+    html,
+    asyncAssets
+  };
+}
+
+export { renderApp };