@tenancy.nz/reports 1.5.5 → 1.5.7

package/dist/cjs/packages/reports/src/components/analytics-section.cjs

@@ -0,0 +1,168 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var React = require('react');
+var reactUid = require('react-uid');
+var index = require('../../../../node_modules/.pnpm/@mui_material@7.3.7_@emotion_react@11.14.0_@types_react@19.2.11_react@18.3.1__@emotion__2e78518fe8c8fb9eb3d08e308137f05a/node_modules/@mui/material/esm/useMediaQuery/index.cjs');
+var ui = require('@tenancy.nz/ui');
+var featureUi = require('@tenancy.nz/feature-ui');
+var Stack = require('../../../../node_modules/.pnpm/@mui_material@7.3.7_@emotion_react@11.14.0_@types_react@19.2.11_react@18.3.1__@emotion__2e78518fe8c8fb9eb3d08e308137f05a/node_modules/@mui/material/esm/Stack/Stack.cjs');
+
+var styles = {
+  chartPaper: {
+    height: "100%",
+    width: "100%",
+    alignItems: "center",
+    justifyContent: "center",
+    display: "flex"
+  }
+};
+function AnalyticsSection(_ref) {
+  var viewingsCount = _ref.viewingsCount,
+    bookingsCount = _ref.bookingsCount,
+    attendeesCount = _ref.attendeesCount,
+    cancellationsCount = _ref.cancellationsCount,
+    applicationsCount = _ref.applicationsCount,
+    averageRent = _ref.averageRent,
+    textUsage = _ref.textUsage,
+    agreementsCount = _ref.agreementsCount,
+    agreementsFinalisedCount = _ref.agreementsFinalisedCount,
+    filterDaysCount = _ref.filterDaysCount,
+    allHouseEnquiriesCount = _ref.allHouseEnquiriesCount,
+    bookMeEnquiriesCount = _ref.bookMeEnquiriesCount,
+    oneRoofEnquiriesCount = _ref.oneRoofEnquiriesCount,
+    realestateEnquiriesCount = _ref.realestateEnquiriesCount,
+    tradeMeEnquiriesCount = _ref.tradeMeEnquiriesCount,
+    manualEnquiryCount = _ref.manualEnquiryCount,
+    allHouseBookingsCount = _ref.allHouseBookingsCount,
+    bookMeBookingsCount = _ref.bookMeBookingsCount,
+    oneRoofBookingsCount = _ref.oneRoofBookingsCount,
+    realestateBookingsCount = _ref.realestateBookingsCount,
+    tradeMeBookingsCount = _ref.tradeMeBookingsCount,
+    manualBookingsCount = _ref.manualBookingsCount;
+  var isXlUp = index.default(function (theme) {
+    return theme.breakpoints.up("xl");
+  });
+  var stats = [{
+    label: "Viewings",
+    value: viewingsCount
+  }, {
+    label: "Bookings",
+    value: bookingsCount
+  }, {
+    label: "Attendees",
+    value: attendeesCount
+  }, {
+    label: "Cancellations",
+    value: cancellationsCount
+  }, {
+    label: "Applications",
+    value: applicationsCount
+  }, {
+    label: "Average Rent",
+    value: "$".concat(averageRent)
+  }, {
+    label: "Text Usage Total",
+    value: textUsage
+  }];
+  return /* @__PURE__ */React.createElement(Stack.default, {
+    gap: 6
+  }, /* @__PURE__ */React.createElement(ui.Grid, {
+    container: true,
+    spacing: 6
+  }, /* @__PURE__ */React.createElement(ui.Grid, {
+    container: true,
+    item: true,
+    spacing: 6,
+    xs: 9
+  }, /* @__PURE__ */React.createElement(ui.Grid, {
+    item: true,
+    xs: 6
+  }, /* @__PURE__ */React.createElement(ui.Paper, {
+    outlined: true,
+    inset: "medium",
+    overflow: false,
+    sx: styles.chartPaper
+  }, /* @__PURE__ */React.createElement(featureUi.AnalyticsDoughnutChart, {
+    tradeMeCount: tradeMeEnquiriesCount,
+    bookMeCount: bookMeEnquiriesCount,
+    manualCount: manualEnquiryCount,
+    allhouseCount: allHouseEnquiriesCount,
+    oneRoofCount: oneRoofEnquiriesCount,
+    realEstateCount: realestateEnquiriesCount,
+    heading: "Number of enquiries"
+  }))), /* @__PURE__ */React.createElement(ui.Grid, {
+    item: true,
+    xs: 6
+  }, /* @__PURE__ */React.createElement(ui.Paper, {
+    outlined: true,
+    inset: "medium",
+    overflow: false,
+    sx: styles.chartPaper
+  }, /* @__PURE__ */React.createElement(featureUi.AnalyticsDoughnutChart, {
+    tradeMeCount: tradeMeBookingsCount,
+    bookMeCount: bookMeBookingsCount,
+    manualCount: manualBookingsCount,
+    allhouseCount: allHouseBookingsCount,
+    oneRoofCount: oneRoofBookingsCount,
+    realEstateCount: realestateBookingsCount,
+    heading: "Number of bookings"
+  })))), /* @__PURE__ */React.createElement(ui.Grid, {
+    item: true,
+    container: true,
+    xs: 3,
+    spacing: 6
+  }, /* @__PURE__ */React.createElement(ui.Grid, {
+    item: true,
+    xs: 12
+  }, /* @__PURE__ */React.createElement(featureUi.AnalyticsBox, {
+    outlined: true,
+    label: /* @__PURE__ */React.createElement("strong", null, "Converted Properties"),
+    amount: agreementsCount,
+    width: "100%",
+    height: isXlUp ? "157px" : "auto",
+    text: /* @__PURE__ */React.createElement(ui.Text, {
+      as: "span",
+      variant: "inherit"
+    }, "Properties that have had a viewing in the last", " ", /* @__PURE__ */React.createElement("strong", null, filterDaysCount), " days where an agreement has been ", /* @__PURE__ */React.createElement("strong", null, "created"))
+  })), /* @__PURE__ */React.createElement(ui.Grid, {
+    item: true,
+    xs: 12,
+    sx: {
+      display: "flex",
+      alignItems: "flex-end"
+    }
+  }, /* @__PURE__ */React.createElement(featureUi.AnalyticsBox, {
+    outlined: true,
+    label: /* @__PURE__ */React.createElement("strong", null, "Converted Properties"),
+    amount: agreementsFinalisedCount,
+    width: "100%",
+    height: isXlUp ? "157px" : "auto",
+    text: /* @__PURE__ */React.createElement(ui.Text, {
+      as: "span",
+      variant: "inherit"
+    }, "Properties that have had a viewing in the last", " ", /* @__PURE__ */React.createElement("strong", null, " ", filterDaysCount), " days where an agreement has been ", /* @__PURE__ */React.createElement("strong", null, "finalised"))
+  })))), /* @__PURE__ */React.createElement(ui.Grid, {
+    container: true,
+    spacing: {
+      xs: 3,
+      md: 6
+    }
+  }, stats.map(function (stat, i) {
+    return /* @__PURE__ */React.createElement(ui.Grid, {
+      item: true,
+      key: reactUid.uid(stat, i),
+      xs: 3,
+      md: 2
+    }, /* @__PURE__ */React.createElement(featureUi.AnalyticsBox, {
+      outlined: true,
+      label: stat.label,
+      amount: stat.value,
+      width: "100%",
+      height: isXlUp ? "157px" : "124px"
+    }));
+  })));
+}
+
+exports.default = AnalyticsSection;

package/dist/esm/_virtual/_commonjsHelpers.js

@@ -0,0 +1,5 @@
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+export { getDefaultExportFromCjs };

package/dist/esm/_virtual/index.js

@@ -0,0 +1,7 @@
+import { getDefaultExportFromCjs } from './_commonjsHelpers.js';
+import { __require as requirePropTypes } from '../node_modules/.pnpm/prop-types@15.8.1/node_modules/prop-types/index.js';
+
+var propTypesExports = /*@__PURE__*/ requirePropTypes();
+var PropTypes = /*@__PURE__*/getDefaultExportFromCjs(propTypesExports);
+
+export { PropTypes as default };

package/dist/esm/_virtual/index2.js

@@ -0,0 +1,3 @@
+var propTypes = {exports: {}};
+
+export { propTypes as __module };

package/dist/esm/node_modules/.pnpm/@babel_runtime@7.28.6/node_modules/@babel/runtime/helpers/esm/extends.js

@@ -0,0 +1,11 @@
+function _extends() {
+  return _extends = Object.assign ? Object.assign.bind() : function (n) {
+    for (var e = 1; e < arguments.length; e++) {
+      var t = arguments[e];
+      for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
+    }
+    return n;
+  }, _extends.apply(null, arguments);
+}
+
+export { _extends as default };

package/dist/esm/node_modules/.pnpm/@emotion_cache@11.14.0/node_modules/@emotion/cache/dist/emotion-cache.esm.js

@@ -0,0 +1,499 @@
+import { StyleSheet } from '../../../../../@emotion_sheet@1.4.0/node_modules/@emotion/sheet/dist/emotion-sheet.esm.js';
+import weakMemoize from '../../../../../@emotion_weak-memoize@0.4.0/node_modules/@emotion/weak-memoize/dist/emotion-weak-memoize.esm.js';
+import memoize from '../../../../../@emotion_memoize@0.9.0/node_modules/@emotion/memoize/dist/emotion-memoize.esm.js';
+import { middleware, rulesheet } from '../../../../../stylis@4.2.0/node_modules/stylis/src/Middleware.js';
+import { RULESET, KEYFRAMES, DECLARATION, WEBKIT, MS, MOZ } from '../../../../../stylis@4.2.0/node_modules/stylis/src/Enum.js';
+import { combine, replace, hash, charat, strlen, indexof, match, from } from '../../../../../stylis@4.2.0/node_modules/stylis/src/Utility.js';
+import { serialize, stringify } from '../../../../../stylis@4.2.0/node_modules/stylis/src/Serializer.js';
+import { copy, dealloc, alloc, next, token, peek, delimit, slice, position } from '../../../../../stylis@4.2.0/node_modules/stylis/src/Tokenizer.js';
+import { compile } from '../../../../../stylis@4.2.0/node_modules/stylis/src/Parser.js';
+
+var isBrowser = typeof document !== 'undefined';
+
+var identifierWithPointTracking = function identifierWithPointTracking(begin, points, index) {
+  var previous = 0;
+  var character = 0;
+
+  while (true) {
+    previous = character;
+    character = peek(); // &\f
+
+    if (previous === 38 && character === 12) {
+      points[index] = 1;
+    }
+
+    if (token(character)) {
+      break;
+    }
+
+    next();
+  }
+
+  return slice(begin, position);
+};
+
+var toRules = function toRules(parsed, points) {
+  // pretend we've started with a comma
+  var index = -1;
+  var character = 44;
+
+  do {
+    switch (token(character)) {
+      case 0:
+        // &\f
+        if (character === 38 && peek() === 12) {
+          // this is not 100% correct, we don't account for literal sequences here - like for example quoted strings
+          // stylis inserts \f after & to know when & where it should replace this sequence with the context selector
+          // and when it should just concatenate the outer and inner selectors
+          // it's very unlikely for this sequence to actually appear in a different context, so we just leverage this fact here
+          points[index] = 1;
+        }
+
+        parsed[index] += identifierWithPointTracking(position - 1, points, index);
+        break;
+
+      case 2:
+        parsed[index] += delimit(character);
+        break;
+
+      case 4:
+        // comma
+        if (character === 44) {
+          // colon
+          parsed[++index] = peek() === 58 ? '&\f' : '';
+          points[index] = parsed[index].length;
+          break;
+        }
+
+      // fallthrough
+
+      default:
+        parsed[index] += from(character);
+    }
+  } while (character = next());
+
+  return parsed;
+};
+
+var getRules = function getRules(value, points) {
+  return dealloc(toRules(alloc(value), points));
+}; // WeakSet would be more appropriate, but only WeakMap is supported in IE11
+
+
+var fixedElements = /* #__PURE__ */new WeakMap();
+var compat = function compat(element) {
+  if (element.type !== 'rule' || !element.parent || // positive .length indicates that this rule contains pseudo
+  // negative .length indicates that this rule has been already prefixed
+  element.length < 1) {
+    return;
+  }
+
+  var value = element.value;
+  var parent = element.parent;
+  var isImplicitRule = element.column === parent.column && element.line === parent.line;
+
+  while (parent.type !== 'rule') {
+    parent = parent.parent;
+    if (!parent) return;
+  } // short-circuit for the simplest case
+
+
+  if (element.props.length === 1 && value.charCodeAt(0) !== 58
+  /* colon */
+  && !fixedElements.get(parent)) {
+    return;
+  } // if this is an implicitly inserted rule (the one eagerly inserted at the each new nested level)
+  // then the props has already been manipulated beforehand as they that array is shared between it and its "rule parent"
+
+
+  if (isImplicitRule) {
+    return;
+  }
+
+  fixedElements.set(element, true);
+  var points = [];
+  var rules = getRules(value, points);
+  var parentRules = parent.props;
+
+  for (var i = 0, k = 0; i < rules.length; i++) {
+    for (var j = 0; j < parentRules.length; j++, k++) {
+      element.props[k] = points[i] ? rules[i].replace(/&\f/g, parentRules[j]) : parentRules[j] + " " + rules[i];
+    }
+  }
+};
+var removeLabel = function removeLabel(element) {
+  if (element.type === 'decl') {
+    var value = element.value;
+
+    if ( // charcode for l
+    value.charCodeAt(0) === 108 && // charcode for b
+    value.charCodeAt(2) === 98) {
+      // this ignores label
+      element["return"] = '';
+      element.value = '';
+    }
+  }
+};
+
+/* eslint-disable no-fallthrough */
+
+function prefix(value, length) {
+  switch (hash(value, length)) {
+    // color-adjust
+    case 5103:
+      return WEBKIT + 'print-' + value + value;
+    // animation, animation-(delay|direction|duration|fill-mode|iteration-count|name|play-state|timing-function)
+
+    case 5737:
+    case 4201:
+    case 3177:
+    case 3433:
+    case 1641:
+    case 4457:
+    case 2921: // text-decoration, filter, clip-path, backface-visibility, column, box-decoration-break
+
+    case 5572:
+    case 6356:
+    case 5844:
+    case 3191:
+    case 6645:
+    case 3005: // mask, mask-image, mask-(mode|clip|size), mask-(repeat|origin), mask-position, mask-composite,
+
+    case 6391:
+    case 5879:
+    case 5623:
+    case 6135:
+    case 4599:
+    case 4855: // background-clip, columns, column-(count|fill|gap|rule|rule-color|rule-style|rule-width|span|width)
+
+    case 4215:
+    case 6389:
+    case 5109:
+    case 5365:
+    case 5621:
+    case 3829:
+      return WEBKIT + value + value;
+    // appearance, user-select, transform, hyphens, text-size-adjust
+
+    case 5349:
+    case 4246:
+    case 4810:
+    case 6968:
+    case 2756:
+      return WEBKIT + value + MOZ + value + MS + value + value;
+    // flex, flex-direction
+
+    case 6828:
+    case 4268:
+      return WEBKIT + value + MS + value + value;
+    // order
+
+    case 6165:
+      return WEBKIT + value + MS + 'flex-' + value + value;
+    // align-items
+
+    case 5187:
+      return WEBKIT + value + replace(value, /(\w+).+(:[^]+)/, WEBKIT + 'box-$1$2' + MS + 'flex-$1$2') + value;
+    // align-self
+
+    case 5443:
+      return WEBKIT + value + MS + 'flex-item-' + replace(value, /flex-|-self/, '') + value;
+    // align-content
+
+    case 4675:
+      return WEBKIT + value + MS + 'flex-line-pack' + replace(value, /align-content|flex-|-self/, '') + value;
+    // flex-shrink
+
+    case 5548:
+      return WEBKIT + value + MS + replace(value, 'shrink', 'negative') + value;
+    // flex-basis
+
+    case 5292:
+      return WEBKIT + value + MS + replace(value, 'basis', 'preferred-size') + value;
+    // flex-grow
+
+    case 6060:
+      return WEBKIT + 'box-' + replace(value, '-grow', '') + WEBKIT + value + MS + replace(value, 'grow', 'positive') + value;
+    // transition
+
+    case 4554:
+      return WEBKIT + replace(value, /([^-])(transform)/g, '$1' + WEBKIT + '$2') + value;
+    // cursor
+
+    case 6187:
+      return replace(replace(replace(value, /(zoom-|grab)/, WEBKIT + '$1'), /(image-set)/, WEBKIT + '$1'), value, '') + value;
+    // background, background-image
+
+    case 5495:
+    case 3959:
+      return replace(value, /(image-set\([^]*)/, WEBKIT + '$1' + '$`$1');
+    // justify-content
+
+    case 4968:
+      return replace(replace(value, /(.+:)(flex-)?(.*)/, WEBKIT + 'box-pack:$3' + MS + 'flex-pack:$3'), /s.+-b[^;]+/, 'justify') + WEBKIT + value + value;
+    // (margin|padding)-inline-(start|end)
+
+    case 4095:
+    case 3583:
+    case 4068:
+    case 2532:
+      return replace(value, /(.+)-inline(.+)/, WEBKIT + '$1$2') + value;
+    // (min|max)?(width|height|inline-size|block-size)
+
+    case 8116:
+    case 7059:
+    case 5753:
+    case 5535:
+    case 5445:
+    case 5701:
+    case 4933:
+    case 4677:
+    case 5533:
+    case 5789:
+    case 5021:
+    case 4765:
+      // stretch, max-content, min-content, fill-available
+      if (strlen(value) - 1 - length > 6) switch (charat(value, length + 1)) {
+        // (m)ax-content, (m)in-content
+        case 109:
+          // -
+          if (charat(value, length + 4) !== 45) break;
+        // (f)ill-available, (f)it-content
+
+        case 102:
+          return replace(value, /(.+:)(.+)-([^]+)/, '$1' + WEBKIT + '$2-$3' + '$1' + MOZ + (charat(value, length + 3) == 108 ? '$3' : '$2-$3')) + value;
+        // (s)tretch
+
+        case 115:
+          return ~indexof(value, 'stretch') ? prefix(replace(value, 'stretch', 'fill-available'), length) + value : value;
+      }
+      break;
+    // position: sticky
+
+    case 4949:
+      // (s)ticky?
+      if (charat(value, length + 1) !== 115) break;
+    // display: (flex|inline-flex)
+
+    case 6444:
+      switch (charat(value, strlen(value) - 3 - (~indexof(value, '!important') && 10))) {
+        // stic(k)y
+        case 107:
+          return replace(value, ':', ':' + WEBKIT) + value;
+        // (inline-)?fl(e)x
+
+        case 101:
+          return replace(value, /(.+:)([^;!]+)(;|!.+)?/, '$1' + WEBKIT + (charat(value, 14) === 45 ? 'inline-' : '') + 'box$3' + '$1' + WEBKIT + '$2$3' + '$1' + MS + '$2box$3') + value;
+      }
+
+      break;
+    // writing-mode
+
+    case 5936:
+      switch (charat(value, length + 11)) {
+        // vertical-l(r)
+        case 114:
+          return WEBKIT + value + MS + replace(value, /[svh]\w+-[tblr]{2}/, 'tb') + value;
+        // vertical-r(l)
+
+        case 108:
+          return WEBKIT + value + MS + replace(value, /[svh]\w+-[tblr]{2}/, 'tb-rl') + value;
+        // horizontal(-)tb
+
+        case 45:
+          return WEBKIT + value + MS + replace(value, /[svh]\w+-[tblr]{2}/, 'lr') + value;
+      }
+
+      return WEBKIT + value + MS + value + value;
+  }
+
+  return value;
+}
+
+var prefixer = function prefixer(element, index, children, callback) {
+  if (element.length > -1) if (!element["return"]) switch (element.type) {
+    case DECLARATION:
+      element["return"] = prefix(element.value, element.length);
+      break;
+
+    case KEYFRAMES:
+      return serialize([copy(element, {
+        value: replace(element.value, '@', '@' + WEBKIT)
+      })], callback);
+
+    case RULESET:
+      if (element.length) return combine(element.props, function (value) {
+        switch (match(value, /(::plac\w+|:read-\w+)/)) {
+          // :read-(only|write)
+          case ':read-only':
+          case ':read-write':
+            return serialize([copy(element, {
+              props: [replace(value, /:(read-\w+)/, ':' + MOZ + '$1')]
+            })], callback);
+          // :placeholder
+
+          case '::placeholder':
+            return serialize([copy(element, {
+              props: [replace(value, /:(plac\w+)/, ':' + WEBKIT + 'input-$1')]
+            }), copy(element, {
+              props: [replace(value, /:(plac\w+)/, ':' + MOZ + '$1')]
+            }), copy(element, {
+              props: [replace(value, /:(plac\w+)/, MS + 'input-$1')]
+            })], callback);
+        }
+
+        return '';
+      });
+  }
+};
+
+var getServerStylisCache = isBrowser ? undefined : weakMemoize(function () {
+  return memoize(function () {
+    return {};
+  });
+});
+var defaultStylisPlugins = [prefixer];
+
+var createCache = function createCache(options) {
+  var key = options.key;
+
+  if (isBrowser && key === 'css') {
+    var ssrStyles = document.querySelectorAll("style[data-emotion]:not([data-s])"); // get SSRed styles out of the way of React's hydration
+    // document.head is a safe place to move them to(though note document.head is not necessarily the last place they will be)
+    // note this very very intentionally targets all style elements regardless of the key to ensure
+    // that creating a cache works inside of render of a React component
+
+    Array.prototype.forEach.call(ssrStyles, function (node) {
+      // we want to only move elements which have a space in the data-emotion attribute value
+      // because that indicates that it is an Emotion 11 server-side rendered style elements
+      // while we will already ignore Emotion 11 client-side inserted styles because of the :not([data-s]) part in the selector
+      // Emotion 10 client-side inserted styles did not have data-s (but importantly did not have a space in their data-emotion attributes)
+      // so checking for the space ensures that loading Emotion 11 after Emotion 10 has inserted some styles
+      // will not result in the Emotion 10 styles being destroyed
+      var dataEmotionAttribute = node.getAttribute('data-emotion');
+
+      if (dataEmotionAttribute.indexOf(' ') === -1) {
+        return;
+      }
+
+      document.head.appendChild(node);
+      node.setAttribute('data-s', '');
+    });
+  }
+
+  var stylisPlugins = options.stylisPlugins || defaultStylisPlugins;
+
+  var inserted = {};
+  var container;
+  var nodesToHydrate = [];
+
+  if (isBrowser) {
+    container = options.container || document.head;
+    Array.prototype.forEach.call( // this means we will ignore elements which don't have a space in them which
+    // means that the style elements we're looking at are only Emotion 11 server-rendered style elements
+    document.querySelectorAll("style[data-emotion^=\"" + key + " \"]"), function (node) {
+      var attrib = node.getAttribute("data-emotion").split(' ');
+
+      for (var i = 1; i < attrib.length; i++) {
+        inserted[attrib[i]] = true;
+      }
+
+      nodesToHydrate.push(node);
+    });
+  }
+
+  var _insert;
+
+  var omnipresentPlugins = [compat, removeLabel];
+
+  if (!getServerStylisCache) {
+    var currentSheet;
+    var finalizingPlugins = [stringify, rulesheet(function (rule) {
+      currentSheet.insert(rule);
+    })];
+    var serializer = middleware(omnipresentPlugins.concat(stylisPlugins, finalizingPlugins));
+
+    var stylis = function stylis(styles) {
+      return serialize(compile(styles), serializer);
+    };
+
+    _insert = function insert(selector, serialized, sheet, shouldCache) {
+      currentSheet = sheet;
+
+      stylis(selector ? selector + "{" + serialized.styles + "}" : serialized.styles);
+
+      if (shouldCache) {
+        cache.inserted[serialized.name] = true;
+      }
+    };
+  } else {
+    var _finalizingPlugins = [stringify];
+
+    var _serializer = middleware(omnipresentPlugins.concat(stylisPlugins, _finalizingPlugins));
+
+    var _stylis = function _stylis(styles) {
+      return serialize(compile(styles), _serializer);
+    };
+
+    var serverStylisCache = getServerStylisCache(stylisPlugins)(key);
+
+    var getRules = function getRules(selector, serialized) {
+      var name = serialized.name;
+
+      if (serverStylisCache[name] === undefined) {
+        serverStylisCache[name] = _stylis(selector ? selector + "{" + serialized.styles + "}" : serialized.styles);
+      }
+
+      return serverStylisCache[name];
+    };
+
+    _insert = function _insert(selector, serialized, sheet, shouldCache) {
+      var name = serialized.name;
+      var rules = getRules(selector, serialized);
+
+      if (cache.compat === undefined) {
+        // in regular mode, we don't set the styles on the inserted cache
+        // since we don't need to and that would be wasting memory
+        // we return them so that they are rendered in a style tag
+        if (shouldCache) {
+          cache.inserted[name] = true;
+        }
+
+        return rules;
+      } else {
+        // in compat mode, we put the styles on the inserted cache so
+        // that emotion-server can pull out the styles
+        // except when we don't want to cache it which was in Global but now
+        // is nowhere but we don't want to do a major right now
+        // and just in case we're going to leave the case here
+        // it's also not affecting client side bundle size
+        // so it's really not a big deal
+        if (shouldCache) {
+          cache.inserted[name] = rules;
+        } else {
+          return rules;
+        }
+      }
+    };
+  }
+
+  var cache = {
+    key: key,
+    sheet: new StyleSheet({
+      key: key,
+      container: container,
+      nonce: options.nonce,
+      speedy: options.speedy,
+      prepend: options.prepend,
+      insertionPoint: options.insertionPoint
+    }),
+    nonce: options.nonce,
+    inserted: inserted,
+    registered: {},
+    insert: _insert
+  };
+  cache.sheet.hydrate(nodesToHydrate);
+  return cache;
+};
+
+export { createCache as default };