@tenancy.nz/reports 1.5.6 → 1.5.7

package/dist/cjs/node_modules/.pnpm/@mui_system@7.3.7_@emotion_react@11.14.0_@types_react@19.2.11_react@18.3.1__@emotion_st_d53d05a2f7097242700b874f83f482c0/node_modules/@mui/system/esm/spacing/spacing.cjs

@@ -0,0 +1,164 @@
+'use strict';
+
+var style$1 = require('../style/style.cjs');
+var merge = require('../merge/merge.cjs');
+var memoize = require('../memoize/memoize.cjs');
+var responsivePropType = require('../responsivePropType/responsivePropType.cjs');
+var breakpoints = require('../breakpoints/breakpoints.cjs');
+
+const properties = {
+  m: 'margin',
+  p: 'padding'
+};
+const directions = {
+  t: 'Top',
+  r: 'Right',
+  b: 'Bottom',
+  l: 'Left',
+  x: ['Left', 'Right'],
+  y: ['Top', 'Bottom']
+};
+const aliases = {
+  marginX: 'mx',
+  marginY: 'my',
+  paddingX: 'px',
+  paddingY: 'py'
+};
+
+// memoize() impact:
+// From 300,000 ops/sec
+// To 350,000 ops/sec
+const getCssProperties = memoize.default(prop => {
+  // It's not a shorthand notation.
+  if (prop.length > 2) {
+    if (aliases[prop]) {
+      prop = aliases[prop];
+    } else {
+      return [prop];
+    }
+  }
+  const [a, b] = prop.split('');
+  const property = properties[a];
+  const direction = directions[b] || '';
+  return Array.isArray(direction) ? direction.map(dir => property + dir) : [property + direction];
+});
+const marginKeys = ['m', 'mt', 'mr', 'mb', 'ml', 'mx', 'my', 'margin', 'marginTop', 'marginRight', 'marginBottom', 'marginLeft', 'marginX', 'marginY', 'marginInline', 'marginInlineStart', 'marginInlineEnd', 'marginBlock', 'marginBlockStart', 'marginBlockEnd'];
+const paddingKeys = ['p', 'pt', 'pr', 'pb', 'pl', 'px', 'py', 'padding', 'paddingTop', 'paddingRight', 'paddingBottom', 'paddingLeft', 'paddingX', 'paddingY', 'paddingInline', 'paddingInlineStart', 'paddingInlineEnd', 'paddingBlock', 'paddingBlockStart', 'paddingBlockEnd'];
+const spacingKeys = [...marginKeys, ...paddingKeys];
+function createUnaryUnit(theme, themeKey, defaultValue, propName) {
+  const themeSpacing = style$1.getPath(theme, themeKey, true) ?? defaultValue;
+  if (typeof themeSpacing === 'number' || typeof themeSpacing === 'string') {
+    return val => {
+      if (typeof val === 'string') {
+        return val;
+      }
+      if (process.env.NODE_ENV !== 'production') {
+        if (typeof val !== 'number') {
+          console.error(`MUI: Expected ${propName} argument to be a number or a string, got ${val}.`);
+        }
+      }
+      if (typeof themeSpacing === 'string') {
+        if (themeSpacing.startsWith('var(') && val === 0) {
+          return 0;
+        }
+        if (themeSpacing.startsWith('var(') && val === 1) {
+          return themeSpacing;
+        }
+        return `calc(${val} * ${themeSpacing})`;
+      }
+      return themeSpacing * val;
+    };
+  }
+  if (Array.isArray(themeSpacing)) {
+    return val => {
+      if (typeof val === 'string') {
+        return val;
+      }
+      const abs = Math.abs(val);
+      if (process.env.NODE_ENV !== 'production') {
+        if (!Number.isInteger(abs)) {
+          console.error([`MUI: The \`theme.${themeKey}\` array type cannot be combined with non integer values.` + `You should either use an integer value that can be used as index, or define the \`theme.${themeKey}\` as a number.`].join('\n'));
+        } else if (abs > themeSpacing.length - 1) {
+          console.error([`MUI: The value provided (${abs}) overflows.`, `The supported values are: ${JSON.stringify(themeSpacing)}.`, `${abs} > ${themeSpacing.length - 1}, you need to add the missing values.`].join('\n'));
+        }
+      }
+      const transformed = themeSpacing[abs];
+      if (val >= 0) {
+        return transformed;
+      }
+      if (typeof transformed === 'number') {
+        return -transformed;
+      }
+      if (typeof transformed === 'string' && transformed.startsWith('var(')) {
+        return `calc(-1 * ${transformed})`;
+      }
+      return `-${transformed}`;
+    };
+  }
+  if (typeof themeSpacing === 'function') {
+    return themeSpacing;
+  }
+  if (process.env.NODE_ENV !== 'production') {
+    console.error([`MUI: The \`theme.${themeKey}\` value (${themeSpacing}) is invalid.`, 'It should be a number, an array or a function.'].join('\n'));
+  }
+  return () => undefined;
+}
+function createUnarySpacing(theme) {
+  return createUnaryUnit(theme, 'spacing', 8, 'spacing');
+}
+function getValue(transformer, propValue) {
+  if (typeof propValue === 'string' || propValue == null) {
+    return propValue;
+  }
+  return transformer(propValue);
+}
+function getStyleFromPropValue(cssProperties, transformer) {
+  return propValue => cssProperties.reduce((acc, cssProperty) => {
+    acc[cssProperty] = getValue(transformer, propValue);
+    return acc;
+  }, {});
+}
+function resolveCssProperty(props, keys, prop, transformer) {
+  // Using a hash computation over an array iteration could be faster, but with only 28 items,
+  // it's doesn't worth the bundle size.
+  if (!keys.includes(prop)) {
+    return null;
+  }
+  const cssProperties = getCssProperties(prop);
+  const styleFromPropValue = getStyleFromPropValue(cssProperties, transformer);
+  const propValue = props[prop];
+  return breakpoints.handleBreakpoints(props, propValue, styleFromPropValue);
+}
+function style(props, keys) {
+  const transformer = createUnarySpacing(props.theme);
+  return Object.keys(props).map(prop => resolveCssProperty(props, keys, prop, transformer)).reduce(merge.default, {});
+}
+function margin(props) {
+  return style(props, marginKeys);
+}
+margin.propTypes = process.env.NODE_ENV !== 'production' ? marginKeys.reduce((obj, key) => {
+  obj[key] = responsivePropType.default;
+  return obj;
+}, {}) : {};
+margin.filterProps = marginKeys;
+function padding(props) {
+  return style(props, paddingKeys);
+}
+padding.propTypes = process.env.NODE_ENV !== 'production' ? paddingKeys.reduce((obj, key) => {
+  obj[key] = responsivePropType.default;
+  return obj;
+}, {}) : {};
+padding.filterProps = paddingKeys;
+process.env.NODE_ENV !== 'production' ? spacingKeys.reduce((obj, key) => {
+  obj[key] = responsivePropType.default;
+  return obj;
+}, {}) : {};
+
+exports.createUnarySpacing = createUnarySpacing;
+exports.createUnaryUnit = createUnaryUnit;
+exports.getStyleFromPropValue = getStyleFromPropValue;
+exports.getValue = getValue;
+exports.margin = margin;
+exports.marginKeys = marginKeys;
+exports.padding = padding;
+exports.paddingKeys = paddingKeys;

package/dist/cjs/node_modules/.pnpm/@mui_system@7.3.7_@emotion_react@11.14.0_@types_react@19.2.11_react@18.3.1__@emotion_st_d53d05a2f7097242700b874f83f482c0/node_modules/@mui/system/esm/style/style.cjs

@@ -0,0 +1,83 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var responsivePropType = require('../responsivePropType/responsivePropType.cjs');
+var breakpoints = require('../breakpoints/breakpoints.cjs');
+var capitalize = require('../../../../../../@mui_utils@7.3.7_@types_react@19.2.11_react@18.3.1/node_modules/@mui/utils/esm/capitalize/capitalize.cjs');
+
+function getPath(obj, path, checkVars = true) {
+  if (!path || typeof path !== 'string') {
+    return null;
+  }
+
+  // Check if CSS variables are used
+  if (obj && obj.vars && checkVars) {
+    const val = `vars.${path}`.split('.').reduce((acc, item) => acc && acc[item] ? acc[item] : null, obj);
+    if (val != null) {
+      return val;
+    }
+  }
+  return path.split('.').reduce((acc, item) => {
+    if (acc && acc[item] != null) {
+      return acc[item];
+    }
+    return null;
+  }, obj);
+}
+function getStyleValue(themeMapping, transform, propValueFinal, userValue = propValueFinal) {
+  let value;
+  if (typeof themeMapping === 'function') {
+    value = themeMapping(propValueFinal);
+  } else if (Array.isArray(themeMapping)) {
+    value = themeMapping[propValueFinal] || userValue;
+  } else {
+    value = getPath(themeMapping, propValueFinal) || userValue;
+  }
+  if (transform) {
+    value = transform(value, userValue, themeMapping);
+  }
+  return value;
+}
+function style(options) {
+  const {
+    prop,
+    cssProperty = options.prop,
+    themeKey,
+    transform
+  } = options;
+
+  // false positive
+  // eslint-disable-next-line react/function-component-definition
+  const fn = props => {
+    if (props[prop] == null) {
+      return null;
+    }
+    const propValue = props[prop];
+    const theme = props.theme;
+    const themeMapping = getPath(theme, themeKey) || {};
+    const styleFromPropValue = propValueFinal => {
+      let value = getStyleValue(themeMapping, transform, propValueFinal);
+      if (propValueFinal === value && typeof propValueFinal === 'string') {
+        // Haven't found value
+        value = getStyleValue(themeMapping, transform, `${prop}${propValueFinal === 'default' ? '' : capitalize.default(propValueFinal)}`, propValueFinal);
+      }
+      if (cssProperty === false) {
+        return value;
+      }
+      return {
+        [cssProperty]: value
+      };
+    };
+    return breakpoints.handleBreakpoints(props, propValue, styleFromPropValue);
+  };
+  fn.propTypes = process.env.NODE_ENV !== 'production' ? {
+    [prop]: responsivePropType.default
+  } : {};
+  fn.filterProps = [prop];
+  return fn;
+}
+
+exports.default = style;
+exports.getPath = getPath;
+exports.getStyleValue = getStyleValue;

package/dist/cjs/node_modules/.pnpm/@mui_system@7.3.7_@emotion_react@11.14.0_@types_react@19.2.11_react@18.3.1__@emotion_st_d53d05a2f7097242700b874f83f482c0/node_modules/@mui/system/esm/styleFunctionSx/defaultSxConfig.cjs

@@ -0,0 +1,300 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var sizing = require('../sizing/sizing.cjs');
+var cssGrid = require('../cssGrid/cssGrid.cjs');
+var spacing = require('../spacing/spacing.cjs');
+var palette = require('../palette/palette.cjs');
+var borders = require('../borders/borders.cjs');
+
+const defaultSxConfig = {
+  // borders
+  border: {
+    themeKey: 'borders',
+    transform: borders.borderTransform
+  },
+  borderTop: {
+    themeKey: 'borders',
+    transform: borders.borderTransform
+  },
+  borderRight: {
+    themeKey: 'borders',
+    transform: borders.borderTransform
+  },
+  borderBottom: {
+    themeKey: 'borders',
+    transform: borders.borderTransform
+  },
+  borderLeft: {
+    themeKey: 'borders',
+    transform: borders.borderTransform
+  },
+  borderColor: {
+    themeKey: 'palette'
+  },
+  borderTopColor: {
+    themeKey: 'palette'
+  },
+  borderRightColor: {
+    themeKey: 'palette'
+  },
+  borderBottomColor: {
+    themeKey: 'palette'
+  },
+  borderLeftColor: {
+    themeKey: 'palette'
+  },
+  outline: {
+    themeKey: 'borders',
+    transform: borders.borderTransform
+  },
+  outlineColor: {
+    themeKey: 'palette'
+  },
+  borderRadius: {
+    themeKey: 'shape.borderRadius',
+    style: borders.borderRadius
+  },
+  // palette
+  color: {
+    themeKey: 'palette',
+    transform: palette.paletteTransform
+  },
+  bgcolor: {
+    themeKey: 'palette',
+    cssProperty: 'backgroundColor',
+    transform: palette.paletteTransform
+  },
+  backgroundColor: {
+    themeKey: 'palette',
+    transform: palette.paletteTransform
+  },
+  // spacing
+  p: {
+    style: spacing.padding
+  },
+  pt: {
+    style: spacing.padding
+  },
+  pr: {
+    style: spacing.padding
+  },
+  pb: {
+    style: spacing.padding
+  },
+  pl: {
+    style: spacing.padding
+  },
+  px: {
+    style: spacing.padding
+  },
+  py: {
+    style: spacing.padding
+  },
+  padding: {
+    style: spacing.padding
+  },
+  paddingTop: {
+    style: spacing.padding
+  },
+  paddingRight: {
+    style: spacing.padding
+  },
+  paddingBottom: {
+    style: spacing.padding
+  },
+  paddingLeft: {
+    style: spacing.padding
+  },
+  paddingX: {
+    style: spacing.padding
+  },
+  paddingY: {
+    style: spacing.padding
+  },
+  paddingInline: {
+    style: spacing.padding
+  },
+  paddingInlineStart: {
+    style: spacing.padding
+  },
+  paddingInlineEnd: {
+    style: spacing.padding
+  },
+  paddingBlock: {
+    style: spacing.padding
+  },
+  paddingBlockStart: {
+    style: spacing.padding
+  },
+  paddingBlockEnd: {
+    style: spacing.padding
+  },
+  m: {
+    style: spacing.margin
+  },
+  mt: {
+    style: spacing.margin
+  },
+  mr: {
+    style: spacing.margin
+  },
+  mb: {
+    style: spacing.margin
+  },
+  ml: {
+    style: spacing.margin
+  },
+  mx: {
+    style: spacing.margin
+  },
+  my: {
+    style: spacing.margin
+  },
+  margin: {
+    style: spacing.margin
+  },
+  marginTop: {
+    style: spacing.margin
+  },
+  marginRight: {
+    style: spacing.margin
+  },
+  marginBottom: {
+    style: spacing.margin
+  },
+  marginLeft: {
+    style: spacing.margin
+  },
+  marginX: {
+    style: spacing.margin
+  },
+  marginY: {
+    style: spacing.margin
+  },
+  marginInline: {
+    style: spacing.margin
+  },
+  marginInlineStart: {
+    style: spacing.margin
+  },
+  marginInlineEnd: {
+    style: spacing.margin
+  },
+  marginBlock: {
+    style: spacing.margin
+  },
+  marginBlockStart: {
+    style: spacing.margin
+  },
+  marginBlockEnd: {
+    style: spacing.margin
+  },
+  // display
+  displayPrint: {
+    cssProperty: false,
+    transform: value => ({
+      '@media print': {
+        display: value
+      }
+    })
+  },
+  display: {},
+  overflow: {},
+  textOverflow: {},
+  visibility: {},
+  whiteSpace: {},
+  // flexbox
+  flexBasis: {},
+  flexDirection: {},
+  flexWrap: {},
+  justifyContent: {},
+  alignItems: {},
+  alignContent: {},
+  order: {},
+  flex: {},
+  flexGrow: {},
+  flexShrink: {},
+  alignSelf: {},
+  justifyItems: {},
+  justifySelf: {},
+  // grid
+  gap: {
+    style: cssGrid.gap
+  },
+  rowGap: {
+    style: cssGrid.rowGap
+  },
+  columnGap: {
+    style: cssGrid.columnGap
+  },
+  gridColumn: {},
+  gridRow: {},
+  gridAutoFlow: {},
+  gridAutoColumns: {},
+  gridAutoRows: {},
+  gridTemplateColumns: {},
+  gridTemplateRows: {},
+  gridTemplateAreas: {},
+  gridArea: {},
+  // positions
+  position: {},
+  zIndex: {
+    themeKey: 'zIndex'
+  },
+  top: {},
+  right: {},
+  bottom: {},
+  left: {},
+  // shadows
+  boxShadow: {
+    themeKey: 'shadows'
+  },
+  // sizing
+  width: {
+    transform: sizing.sizingTransform
+  },
+  maxWidth: {
+    style: sizing.maxWidth
+  },
+  minWidth: {
+    transform: sizing.sizingTransform
+  },
+  height: {
+    transform: sizing.sizingTransform
+  },
+  maxHeight: {
+    transform: sizing.sizingTransform
+  },
+  minHeight: {
+    transform: sizing.sizingTransform
+  },
+  boxSizing: {},
+  // typography
+  font: {
+    themeKey: 'font'
+  },
+  fontFamily: {
+    themeKey: 'typography'
+  },
+  fontSize: {
+    themeKey: 'typography'
+  },
+  fontStyle: {
+    themeKey: 'typography'
+  },
+  fontWeight: {
+    themeKey: 'typography'
+  },
+  letterSpacing: {},
+  textTransform: {},
+  lineHeight: {},
+  textAlign: {},
+  typography: {
+    cssProperty: false,
+    themeKey: 'typography'
+  }
+};
+
+exports.default = defaultSxConfig;

package/dist/cjs/node_modules/.pnpm/@mui_system@7.3.7_@emotion_react@11.14.0_@types_react@19.2.11_react@18.3.1__@emotion_st_d53d05a2f7097242700b874f83f482c0/node_modules/@mui/system/esm/styleFunctionSx/extendSxProp.cjs

@@ -0,0 +1,58 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var defaultSxConfig = require('./defaultSxConfig.cjs');
+var deepmerge = require('../../../../../../@mui_utils@7.3.7_@types_react@19.2.11_react@18.3.1/node_modules/@mui/utils/esm/deepmerge/deepmerge.cjs');
+
+const splitProps = props => {
+  const result = {
+    systemProps: {},
+    otherProps: {}
+  };
+  const config = props?.theme?.unstable_sxConfig ?? defaultSxConfig.default;
+  Object.keys(props).forEach(prop => {
+    if (config[prop]) {
+      result.systemProps[prop] = props[prop];
+    } else {
+      result.otherProps[prop] = props[prop];
+    }
+  });
+  return result;
+};
+function extendSxProp(props) {
+  const {
+    sx: inSx,
+    ...other
+  } = props;
+  const {
+    systemProps,
+    otherProps
+  } = splitProps(other);
+  let finalSx;
+  if (Array.isArray(inSx)) {
+    finalSx = [systemProps, ...inSx];
+  } else if (typeof inSx === 'function') {
+    finalSx = (...args) => {
+      const result = inSx(...args);
+      if (!deepmerge.isPlainObject(result)) {
+        return systemProps;
+      }
+      return {
+        ...systemProps,
+        ...result
+      };
+    };
+  } else {
+    finalSx = {
+      ...systemProps,
+      ...inSx
+    };
+  }
+  return {
+    ...otherProps,
+    sx: finalSx
+  };
+}
+
+exports.default = extendSxProp;