npm - @tenancy.nz/datepicker - Versions diffs - 1.3.4 - Mend

@tenancy.nz/datepicker 1.3.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (361) hide show

package/dist/cjs/node_modules/.pnpm/@mui_system@7.3.1_@emotion_react@11.14.0_@types_react@19.1.9_react@18.3.1__@emotion_sty_acba54c86a0a45a77cd5d01171297ec0/node_modules/@mui/system/esm/createTheme/createTheme.cjs ADDED Viewed

@@ -0,0 +1,55 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+var createBreakpoints = require('../createBreakpoints/createBreakpoints.cjs');
+var shape = require('./shape.cjs');
+var createSpacing = require('./createSpacing.cjs');
+var styleFunctionSx = require('../styleFunctionSx/styleFunctionSx.cjs');
+var defaultSxConfig = require('../styleFunctionSx/defaultSxConfig.cjs');
+var applyStyles = require('./applyStyles.cjs');
+var deepmerge = require('../../../../../../@mui_utils@7.3.1_@types_react@19.1.9_react@18.3.1/node_modules/@mui/utils/esm/deepmerge/deepmerge.cjs');
+var cssContainerQueries = require('../cssContainerQueries/cssContainerQueries.cjs');
+function createTheme(options = {}, ...args) {
+  const {
+    breakpoints: breakpointsInput = {},
+    palette: paletteInput = {},
+    spacing: spacingInput,
+    shape: shapeInput = {},
+    ...other
+  } = options;
+  const breakpoints = createBreakpoints.default(breakpointsInput);
+  const spacing = createSpacing.default(spacingInput);
+  let muiTheme = deepmerge.default({
+    breakpoints,
+    direction: 'ltr',
+    components: {},
+    // Inject component definitions.
+    palette: {
+      mode: 'light',
+      ...paletteInput
+    },
+    spacing,
+    shape: {
+      ...shape.default,
+      ...shapeInput
+    }
+  }, other);
+  muiTheme = cssContainerQueries.default(muiTheme);
+  muiTheme.applyStyles = applyStyles.default;
+  muiTheme = args.reduce((acc, argument) => deepmerge.default(acc, argument), muiTheme);
+  muiTheme.unstable_sxConfig = {
+    ...defaultSxConfig.default,
+    ...other?.unstable_sxConfig
+  };
+  muiTheme.unstable_sx = function sx(props) {
+    return styleFunctionSx.default({
+      sx: props,
+      theme: this
+    });
+  };
+  return muiTheme;
+}
+exports.default = createTheme;

@@ -0,0 +1,9 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+const shape = {
+  borderRadius: 4
+};
+exports.default = shape;

@@ -0,0 +1,79 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+var formatMuiErrorMessage = require('../../../../../../@mui_utils@7.3.1_@types_react@19.1.9_react@18.3.1/node_modules/@mui/utils/esm/formatMuiErrorMessage/formatMuiErrorMessage.cjs');
+/**
+ * For using in `sx` prop to sort the breakpoint from low to high.
+ * Note: this function does not work and will not support multiple units.
+ *       e.g. input: { '@container (min-width:300px)': '1rem', '@container (min-width:40rem)': '2rem' }
+ *            output: { '@container (min-width:40rem)': '2rem', '@container (min-width:300px)': '1rem' } // since 40 < 300 eventhough 40rem > 300px
+ */
+function sortContainerQueries(theme, css) {
+  if (!theme.containerQueries) {
+    return css;
+  }
+  const sorted = Object.keys(css).filter(key => key.startsWith('@container')).sort((a, b) => {
+    const regex = /min-width:\s*([0-9.]+)/;
+    return +(a.match(regex)?.[1] || 0) - +(b.match(regex)?.[1] || 0);
+  });
+  if (!sorted.length) {
+    return css;
+  }
+  return sorted.reduce((acc, key) => {
+    const value = css[key];
+    delete acc[key];
+    acc[key] = value;
+    return acc;
+  }, {
+    ...css
+  });
+}
+function isCqShorthand(breakpointKeys, value) {
+  return value === '@' || value.startsWith('@') && (breakpointKeys.some(key => value.startsWith(`@${key}`)) || !!value.match(/^@\d/));
+}
+function getContainerQuery(theme, shorthand) {
+  const matches = shorthand.match(/^@([^/]+)?\/?(.+)?$/);
+  if (!matches) {
+    if (process.env.NODE_ENV !== 'production') {
+      throw new Error(process.env.NODE_ENV !== "production" ? `MUI: The provided shorthand ${`(${shorthand})`} is invalid. The format should be \`@<breakpoint | number>\` or \`@<breakpoint | number>/<container>\`.\n` + 'For example, `@sm` or `@600` or `@40rem/sidebar`.' : formatMuiErrorMessage.default(18, `(${shorthand})`));
+    }
+    return null;
+  }
+  const [, containerQuery, containerName] = matches;
+  const value = Number.isNaN(+containerQuery) ? containerQuery || 0 : +containerQuery;
+  return theme.containerQueries(containerName).up(value);
+}
+function cssContainerQueries(themeInput) {
+  const toContainerQuery = (mediaQuery, name) => mediaQuery.replace('@media', name ? `@container ${name}` : '@container');
+  function attachCq(node, name) {
+    node.up = (...args) => toContainerQuery(themeInput.breakpoints.up(...args), name);
+    node.down = (...args) => toContainerQuery(themeInput.breakpoints.down(...args), name);
+    node.between = (...args) => toContainerQuery(themeInput.breakpoints.between(...args), name);
+    node.only = (...args) => toContainerQuery(themeInput.breakpoints.only(...args), name);
+    node.not = (...args) => {
+      const result = toContainerQuery(themeInput.breakpoints.not(...args), name);
+      if (result.includes('not all and')) {
+        // `@container` does not work with `not all and`, so need to invert the logic
+        return result.replace('not all and ', '').replace('min-width:', 'width<').replace('max-width:', 'width>').replace('and', 'or');
+      }
+      return result;
+    };
+  }
+  const node = {};
+  const containerQueries = name => {
+    attachCq(node, name);
+    return node;
+  };
+  attachCq(containerQueries);
+  return {
+    ...themeInput,
+    containerQueries
+  };
+}
+exports.default = cssContainerQueries;
+exports.getContainerQuery = getContainerQuery;
+exports.isCqShorthand = isCqShorthand;
+exports.sortContainerQueries = sortContainerQueries;

@@ -0,0 +1,99 @@
+'use strict';
+var responsivePropType = require('../responsivePropType/responsivePropType.cjs');
+var style = require('../style/style.cjs');
+var compose = require('../compose/compose.cjs');
+var spacing = require('../spacing/spacing.cjs');
+var breakpoints = require('../breakpoints/breakpoints.cjs');
+// false positive
+// eslint-disable-next-line react/function-component-definition
+const gap = props => {
+  if (props.gap !== undefined && props.gap !== null) {
+    const transformer = spacing.createUnaryUnit(props.theme, 'spacing', 8, 'gap');
+    const styleFromPropValue = propValue => ({
+      gap: spacing.getValue(transformer, propValue)
+    });
+    return breakpoints.handleBreakpoints(props, props.gap, styleFromPropValue);
+  }
+  return null;
+};
+gap.propTypes = process.env.NODE_ENV !== 'production' ? {
+  gap: responsivePropType.default
+} : {};
+gap.filterProps = ['gap'];
+// false positive
+// eslint-disable-next-line react/function-component-definition
+const columnGap = props => {
+  if (props.columnGap !== undefined && props.columnGap !== null) {
+    const transformer = spacing.createUnaryUnit(props.theme, 'spacing', 8, 'columnGap');
+    const styleFromPropValue = propValue => ({
+      columnGap: spacing.getValue(transformer, propValue)
+    });
+    return breakpoints.handleBreakpoints(props, props.columnGap, styleFromPropValue);
+  }
+  return null;
+};
+columnGap.propTypes = process.env.NODE_ENV !== 'production' ? {
+  columnGap: responsivePropType.default
+} : {};
+columnGap.filterProps = ['columnGap'];
+// false positive
+// eslint-disable-next-line react/function-component-definition
+const rowGap = props => {
+  if (props.rowGap !== undefined && props.rowGap !== null) {
+    const transformer = spacing.createUnaryUnit(props.theme, 'spacing', 8, 'rowGap');
+    const styleFromPropValue = propValue => ({
+      rowGap: spacing.getValue(transformer, propValue)
+    });
+    return breakpoints.handleBreakpoints(props, props.rowGap, styleFromPropValue);
+  }
+  return null;
+};
+rowGap.propTypes = process.env.NODE_ENV !== 'production' ? {
+  rowGap: responsivePropType.default
+} : {};
+rowGap.filterProps = ['rowGap'];
+const gridColumn = style.default({
+  prop: 'gridColumn'
+});
+const gridRow = style.default({
+  prop: 'gridRow'
+});
+const gridAutoFlow = style.default({
+  prop: 'gridAutoFlow'
+});
+const gridAutoColumns = style.default({
+  prop: 'gridAutoColumns'
+});
+const gridAutoRows = style.default({
+  prop: 'gridAutoRows'
+});
+const gridTemplateColumns = style.default({
+  prop: 'gridTemplateColumns'
+});
+const gridTemplateRows = style.default({
+  prop: 'gridTemplateRows'
+});
+const gridTemplateAreas = style.default({
+  prop: 'gridTemplateAreas'
+});
+const gridArea = style.default({
+  prop: 'gridArea'
+});
+compose.default(gap, columnGap, rowGap, gridColumn, gridRow, gridAutoFlow, gridAutoColumns, gridAutoRows, gridTemplateColumns, gridTemplateRows, gridTemplateAreas, gridArea);
+exports.columnGap = columnGap;
+exports.gap = gap;
+exports.gridArea = gridArea;
+exports.gridAutoColumns = gridAutoColumns;
+exports.gridAutoFlow = gridAutoFlow;
+exports.gridAutoRows = gridAutoRows;
+exports.gridColumn = gridColumn;
+exports.gridRow = gridRow;
+exports.gridTemplateAreas = gridTemplateAreas;
+exports.gridTemplateColumns = gridTemplateColumns;
+exports.gridTemplateRows = gridTemplateRows;
+exports.rowGap = rowGap;

@@ -0,0 +1,15 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+function memoize(fn) {
+  const cache = {};
+  return arg => {
+    if (cache[arg] === undefined) {
+      cache[arg] = fn(arg);
+    }
+    return cache[arg];
+  };
+}
+exports.default = memoize;

@@ -0,0 +1,16 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+var deepmerge = require('../../../../../../@mui_utils@7.3.1_@types_react@19.1.9_react@18.3.1/node_modules/@mui/utils/esm/deepmerge/deepmerge.cjs');
+function merge(acc, item) {
+  if (!item) {
+    return acc;
+  }
+  return deepmerge.default(acc, item, {
+    clone: false // No need to clone deep, it's way faster.
+  });
+}
+exports.default = merge;

@@ -0,0 +1,33 @@
+'use strict';
+var style = require('../style/style.cjs');
+var compose = require('../compose/compose.cjs');
+function paletteTransform(value, userValue) {
+  if (userValue === 'grey') {
+    return userValue;
+  }
+  return value;
+}
+const color = style.default({
+  prop: 'color',
+  themeKey: 'palette',
+  transform: paletteTransform
+});
+const bgcolor = style.default({
+  prop: 'bgcolor',
+  cssProperty: 'backgroundColor',
+  themeKey: 'palette',
+  transform: paletteTransform
+});
+const backgroundColor = style.default({
+  prop: 'backgroundColor',
+  themeKey: 'palette',
+  transform: paletteTransform
+});
+compose.default(color, bgcolor, backgroundColor);
+exports.backgroundColor = backgroundColor;
+exports.bgcolor = bgcolor;
+exports.color = color;
+exports.paletteTransform = paletteTransform;

@@ -0,0 +1,9 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+var index = require('../../../../../../../../_virtual/index.cjs');
+const responsivePropType = process.env.NODE_ENV !== 'production' ? index.default.oneOfType([index.default.number, index.default.string, index.default.object, index.default.array]) : {};
+exports.default = responsivePropType;

@@ -0,0 +1,75 @@
+'use strict';
+var style = require('../style/style.cjs');
+var compose = require('../compose/compose.cjs');
+var breakpoints = require('../breakpoints/breakpoints.cjs');
+function sizingTransform(value) {
+  return value <= 1 && value !== 0 ? `${value * 100}%` : value;
+}
+const width = style.default({
+  prop: 'width',
+  transform: sizingTransform
+});
+const maxWidth = props => {
+  if (props.maxWidth !== undefined && props.maxWidth !== null) {
+    const styleFromPropValue = propValue => {
+      const breakpoint = props.theme?.breakpoints?.values?.[propValue] || breakpoints.values[propValue];
+      if (!breakpoint) {
+        return {
+          maxWidth: sizingTransform(propValue)
+        };
+      }
+      if (props.theme?.breakpoints?.unit !== 'px') {
+        return {
+          maxWidth: `${breakpoint}${props.theme.breakpoints.unit}`
+        };
+      }
+      return {
+        maxWidth: breakpoint
+      };
+    };
+    return breakpoints.handleBreakpoints(props, props.maxWidth, styleFromPropValue);
+  }
+  return null;
+};
+maxWidth.filterProps = ['maxWidth'];
+const minWidth = style.default({
+  prop: 'minWidth',
+  transform: sizingTransform
+});
+const height = style.default({
+  prop: 'height',
+  transform: sizingTransform
+});
+const maxHeight = style.default({
+  prop: 'maxHeight',
+  transform: sizingTransform
+});
+const minHeight = style.default({
+  prop: 'minHeight',
+  transform: sizingTransform
+});
+style.default({
+  prop: 'size',
+  cssProperty: 'width',
+  transform: sizingTransform
+});
+style.default({
+  prop: 'size',
+  cssProperty: 'height',
+  transform: sizingTransform
+});
+const boxSizing = style.default({
+  prop: 'boxSizing'
+});
+compose.default(width, maxWidth, minWidth, height, maxHeight, minHeight, boxSizing);
+exports.boxSizing = boxSizing;
+exports.height = height;
+exports.maxHeight = maxHeight;
+exports.maxWidth = maxWidth;
+exports.minHeight = minHeight;
+exports.minWidth = minWidth;
+exports.sizingTransform = sizingTransform;
+exports.width = width;

@@ -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;

@@ -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.1_@types_react@19.1.9_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;