@hipay/hipay-material-ui 2.3.1-rc4 → 2.3.1-rc5

package/styles/createBreakpoints.test.js

@@ -1,48 +0,0 @@
-import { assert } from 'chai';
-import createBreakpoints from './createBreakpoints';
-describe('createBreakpoints', function () {
-  var breakpoints = createBreakpoints({});
-  describe('up', function () {
-    it('should work for xs', function () {
-      assert.strictEqual(breakpoints.up('xs'), '@media (min-width:0px)');
-    });
-    it('should work for md', function () {
-      assert.strictEqual(breakpoints.up('md'), '@media (min-width:960px)');
-    });
-  });
-  describe('down', function () {
-    it('should work', function () {
-      assert.strictEqual(breakpoints.down('sm'), '@media (max-width:959.95px)');
-    });
-    it('should work for md', function () {
-      assert.strictEqual(breakpoints.down('md'), '@media (max-width:1279.95px)');
-    });
-    it('should use the specified key if it is not a recognized breakpoint', function () {
-      assert.strictEqual(breakpoints.down(600), '@media (max-width:599.95px)');
-    });
-    it('should apply to all sizes for xl', function () {
-      assert.strictEqual(breakpoints.down('xl'), '@media (min-width:0px)');
-    });
-  });
-  describe('between', function () {
-    it('should work', function () {
-      assert.strictEqual(breakpoints.between('sm', 'md'), '@media (min-width:600px) and (max-width:1279.95px)');
-    });
-    it('on xl should call up', function () {
-      assert.strictEqual(breakpoints.between('lg', 'xl'), '@media (min-width:1280px)');
-    });
-  });
-  describe('only', function () {
-    it('should work', function () {
-      assert.strictEqual(breakpoints.only('md'), '@media (min-width:960px) and (max-width:1279.95px)');
-    });
-    it('on xl should call up', function () {
-      assert.strictEqual(breakpoints.only('xl'), '@media (min-width:1920px)');
-    });
-  });
-  describe('width', function () {
-    it('should work', function () {
-      assert.strictEqual(breakpoints.width('md'), 960);
-    });
-  });
-});

package/styles/createGenerateClassName.test.js

@@ -1,141 +0,0 @@
-import { assert } from 'chai';
-import consoleErrorMock from 'test/utils/consoleErrorMock';
-import createGenerateClassName from './createGenerateClassName';
-describe('createGenerateClassName', function () {
-  describe('counter', function () {
-    it('should increment a scoped counter', function () {
-      var rule = {
-        key: 'root'
-      };
-      var generateClassName1 = createGenerateClassName();
-      assert.strictEqual(generateClassName1(rule), 'root-1');
-      assert.strictEqual(generateClassName1(rule), 'root-2');
-      var generateClassName2 = createGenerateClassName();
-      assert.strictEqual(generateClassName2(rule), 'root-1');
-    });
-  });
-  it('should escape parenthesis', function () {
-    var generateClassName = createGenerateClassName();
-    assert.strictEqual(generateClassName({
-      key: 'root'
-    }, {
-      options: {
-        classNamePrefix: 'pure(MuiButton)',
-        jss: {}
-      }
-    }), 'pure-MuiButton--root-1');
-  });
-  it('should escape spaces', function () {
-    var generateClassName = createGenerateClassName();
-    assert.strictEqual(generateClassName({
-      key: 'root'
-    }, {
-      options: {
-        classNamePrefix: 'foo bar',
-        jss: {}
-      }
-    }), 'foo-bar-root-1');
-  });
-  describe('options: dangerouslyUseGlobalCSS', function () {
-    it('should use a global class name', function () {
-      var generateClassName = createGenerateClassName({
-        dangerouslyUseGlobalCSS: true
-      });
-      assert.strictEqual(generateClassName({
-        key: 'root'
-      }, {
-        options: {
-          name: 'Button',
-          classNamePrefix: 'Button2',
-          jss: {}
-        }
-      }), 'Button-root');
-      assert.strictEqual(generateClassName({
-        key: 'root'
-      }, {
-        options: {
-          classNamePrefix: 'Button',
-          jss: {}
-        }
-      }), 'Button-root-2');
-    });
-    it('should default to a non deterministic name', function () {
-      var generateClassName = createGenerateClassName({
-        dangerouslyUseGlobalCSS: true
-      });
-      assert.strictEqual(generateClassName({
-        key: 'root'
-      }), 'root-1');
-    });
-  });
-  describe('formatting', function () {
-    it('should take the sheet meta in development if available', function () {
-      var rule = {
-        key: 'root'
-      };
-      var styleSheet = {
-        options: {
-          classNamePrefix: 'Button'
-        }
-      };
-      var generateClassName = createGenerateClassName();
-      assert.strictEqual(generateClassName(rule, styleSheet), 'Button-root-1');
-    });
-    it('should use a base 10 representation', function () {
-      var rule = {
-        key: 'root'
-      };
-      var generateClassName = createGenerateClassName();
-      assert.strictEqual(generateClassName(rule), 'root-1');
-      assert.strictEqual(generateClassName(rule), 'root-2');
-      assert.strictEqual(generateClassName(rule), 'root-3');
-      assert.strictEqual(generateClassName(rule), 'root-4');
-      assert.strictEqual(generateClassName(rule), 'root-5');
-      assert.strictEqual(generateClassName(rule), 'root-6');
-      assert.strictEqual(generateClassName(rule), 'root-7');
-      assert.strictEqual(generateClassName(rule), 'root-8');
-      assert.strictEqual(generateClassName(rule), 'root-9');
-      assert.strictEqual(generateClassName(rule), 'root-10');
-    });
-    describe('production', function () {
-      // Only run the test on node.
-      if (!/jsdom/.test(window.navigator.userAgent)) {
-        return;
-      }
-
-      var nodeEnv;
-      var env = process.env;
-      before(function () {
-        nodeEnv = env.NODE_ENV;
-        env.NODE_ENV = 'production';
-        consoleErrorMock.spy();
-      });
-      after(function () {
-        env.NODE_ENV = nodeEnv;
-        consoleErrorMock.reset();
-      });
-      it('should output a short representation', function () {
-        var rule = {
-          key: 'root'
-        };
-        var generateClassName = createGenerateClassName();
-        assert.strictEqual(generateClassName(rule), 'jss1');
-      });
-      it('should work with global CSS', function () {
-        var rule = {
-          key: 'root'
-        };
-        var generateClassName = createGenerateClassName({
-          dangerouslyUseGlobalCSS: true
-        });
-        assert.strictEqual(generateClassName(rule), 'jss1');
-      });
-      it('should warn', function () {
-        createGenerateClassName();
-        createGenerateClassName();
-        assert.strictEqual(consoleErrorMock.callCount() > 0, true);
-        assert.match(consoleErrorMock.args()[0][0], /Material-UI: we have detected more than needed creation of the/);
-      });
-    });
-  });
-});

package/styles/createMixins.test.js

@@ -1,24 +0,0 @@
-import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
-import { assert } from 'chai';
-import createMixins from './createMixins';
-import createMuiTheme from './createMuiTheme';
-describe('createMixins', function () {
-  it('should be able to override the breakpoint', function () {
-    var theme = createMuiTheme();
-    var mixins = createMixins(theme.breakpoints, theme.spacing, {});
-    var mixin = mixins.gutters(_defineProperty({
-      display: 'flex'
-    }, theme.breakpoints.up('sm'), {
-      paddingLeft: 1
-    }));
-    assert.deepEqual(mixin, {
-      '@media (min-width:600px)': {
-        paddingLeft: 1,
-        paddingRight: 24
-      },
-      display: 'flex',
-      paddingLeft: 16,
-      paddingRight: 16
-    });
-  });
-});

package/styles/createMuiTheme.test.js

@@ -1,67 +0,0 @@
-import { assert } from 'chai';
-import createMuiTheme from './createMuiTheme';
-import { deepOrange, green } from '@material-ui/core/colors';
-describe('createMuiTheme', function () {
-  it('should have a palette', function () {
-    var muiTheme = createMuiTheme();
-    assert.strictEqual(typeof createMuiTheme, 'function', 'should be a function');
-    assert.ok(muiTheme.palette, 'should have a palette');
-  });
-  it('should have the custom palette', function () {
-    var muiTheme = createMuiTheme({
-      palette: {
-        primary: {
-          main: deepOrange[500]
-        },
-        secondary: {
-          main: green.A400
-        }
-      }
-    });
-    assert.strictEqual(muiTheme.palette.primary.main, deepOrange[500], 'should have a palette');
-    assert.strictEqual(muiTheme.palette.secondary.main, green.A400, 'should have a palette');
-  });
-  it('should allow providing a partial structure', function () {
-    var muiTheme = createMuiTheme({
-      transitions: {
-        duration: {
-          shortest: 150
-        }
-      }
-    });
-    assert.notStrictEqual(muiTheme.transitions.duration.shorter, undefined);
-  });
-  describe('shadows', function () {
-    it('should provide the default array', function () {
-      var muiTheme = createMuiTheme();
-      assert.strictEqual(muiTheme.shadows[2], '0px 1px 5px 0px rgba(0, 0, 0, 0.2),' + '0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 3px 1px -2px rgba(0, 0, 0, 0.12)');
-    });
-    it('should override the array as expected', function () {
-      var shadows = ['none', 1, 1, 1, 2, 3, 3, 4, 5, 5, 6, 6, 7, 7, 7, 8, 8, 8, 9, 9, 10, 10, 10, 11, 11];
-      var muiTheme = createMuiTheme({
-        shadows: shadows
-      });
-      assert.strictEqual(muiTheme.shadows, shadows);
-    });
-  });
-  describe('props', function () {
-    it('should have the props as expected', function () {
-      var props = {
-        MuiDialog: {
-          fullScreen: true,
-          fullWidth: false
-        },
-        MuiButtonBase: {
-          disableRipple: true
-        },
-        MuiPopover: {
-          container: document.createElement('div')
-        }
-      };
-      var muiTheme = createMuiTheme({
-        props: props
-      });
-      assert.deepEqual(muiTheme.props, props);
-    });
-  });
-});

package/styles/createPalette.test.js

@@ -1,159 +0,0 @@
-import { assert } from 'chai';
-import consoleErrorMock from 'test/utils/consoleErrorMock';
-import { pink, deepOrange, green, red } from '@material-ui/core/colors';
-import { lighten, darken } from './colorManipulator';
-import createPalette, { dark, light } from './createPalette';
-describe('createPalette()', function () {
-  before(function () {
-    consoleErrorMock.spy();
-  });
-  after(function () {
-    consoleErrorMock.reset();
-  });
-  it('should create a material design palette according to spec', function () {
-    var palette = createPalette({});
-    assert.strictEqual(palette.primary.main, '#00ade9', 'should use blue hipay as the default primary main color');
-    assert.strictEqual(palette.primary.light, '#5bc8ef', 'should use light blue hipay as the default primary light color');
-    assert.strictEqual(palette.primary.dark, '#007ca9', 'should use dark blue hipay as the default primary dark color');
-    assert.strictEqual(palette.primary.contrastText, '#FFFFFF', 'should use white as the default primary contrastText color');
-    assert.strictEqual(palette.secondary.main, '#ffcf21', 'should use yellow hipay as the default secondary main color');
-    assert.strictEqual(palette.secondary.light, '#ffd94f', 'should use light yellow hipay as the default secondary light color');
-    assert.strictEqual(palette.secondary.dark, '#E9BE30', 'should use dark yellow hipay as the default secondary dark color');
-    assert.strictEqual(palette.secondary.contrastText, '#FFFFFF', 'should use white as the default secondary contrastText color');
-    assert.strictEqual(palette.error.main, red[500], 'should use red[500] as the default error main color');
-    assert.strictEqual(palette.error.light, red[300], 'should use red[300] as the default error light color');
-    assert.strictEqual(palette.error.dark, red[700], 'should use red[700] as the default error dark color');
-    assert.strictEqual(palette.text, light.text, 'should use light theme text for a light theme by default');
-  });
-  it('should create a palette with Material colors', function () {
-    var palette = createPalette({
-      primary: deepOrange,
-      secondary: green,
-      error: pink
-    });
-    assert.strictEqual(palette.primary.main, deepOrange[500], 'should use deepOrange[500] as the primary main color');
-    assert.strictEqual(palette.primary.light, deepOrange[300], 'should use deepOrange[300] as the primary light color');
-    assert.strictEqual(palette.primary.dark, deepOrange[700], 'should use deepOrange[700] as the primary dark color');
-    assert.strictEqual(palette.secondary.main, green.A400, 'should use green.A400 as the secondary main color');
-    assert.strictEqual(palette.secondary.light, green.A200, 'should use green.A200 as the secondary light color');
-    assert.strictEqual(palette.secondary.dark, green.A700, 'should use green.A700 as the secondary dark color');
-    assert.strictEqual(palette.error.main, pink[500], 'should use pink[500] as the error main color');
-    assert.strictEqual(palette.error.light, pink[300], 'should use pink[300] as the error light color');
-    assert.strictEqual(palette.error.dark, pink[700], 'should use pink[700] as the error dark color');
-    assert.strictEqual(palette.text, light.text, 'should use light theme text');
-  });
-  it('should create a palette with custom colors', function () {
-    var palette = createPalette({
-      primary: {
-        main: deepOrange[500],
-        light: deepOrange[300],
-        dark: deepOrange[700],
-        contrastText: '#ffffff'
-      },
-      secondary: {
-        main: green.A400,
-        light: green.A200,
-        dark: green.A700,
-        contrastText: '#000000'
-      },
-      error: {
-        main: pink[500],
-        light: pink[300],
-        dark: pink[700],
-        contrastText: '#00ff00'
-      }
-    });
-    assert.strictEqual(palette.primary.main, deepOrange[500], 'should use deepOrange[500] as the primary main color');
-    assert.strictEqual(palette.primary.light, deepOrange[300], 'should use deepOrange[300] as the primary light color');
-    assert.strictEqual(palette.primary.dark, deepOrange[700], 'should use deepOrange[700] as the primary dark color');
-    assert.strictEqual(palette.primary.contrastText, '#ffffff', 'should use #ffffff as the secondary contrastText color');
-    assert.strictEqual(palette.secondary.main, green.A400, 'should use green.A400 as the secondary main color');
-    assert.strictEqual(palette.secondary.light, green.A200, 'should use green.A200 as the secondary light color');
-    assert.strictEqual(palette.secondary.dark, green.A700, 'should use green.A700 as the secondary dark color');
-    assert.strictEqual(palette.secondary.contrastText, '#000000', 'should use #000000 as the secondary contrastText color');
-    assert.strictEqual(palette.error.main, pink[500], 'should use pink[500] as the error main color');
-    assert.strictEqual(palette.error.light, pink[300], 'should use pink[300] as the error light color');
-    assert.strictEqual(palette.error.dark, pink[700], 'should use pink[700] as the error dark color');
-    assert.strictEqual(palette.error.contrastText, '#00ff00', 'should use #00ff00 as the error contrastText color');
-    assert.strictEqual(palette.text, light.text, 'should use light theme text');
-  });
-  it('should calculate light and dark colors if not provided', function () {
-    var palette = createPalette({
-      primary: {
-        main: deepOrange[500]
-      },
-      secondary: {
-        main: green.A400
-      },
-      error: {
-        main: pink[500]
-      }
-    });
-    assert.strictEqual(palette.primary.main, deepOrange[500], 'should use deepOrange[500] as the primary main color');
-    assert.strictEqual(palette.primary.light, lighten(deepOrange[500], 0.2), 'should use lighten(deepOrange[500], 0.2) as the primary light color');
-    assert.strictEqual(palette.primary.dark, darken(deepOrange[500], 0.3), 'should use darken(deepOrange[500], 0.3) as the primary dark color');
-    assert.strictEqual(palette.secondary.main, green.A400, 'should use green.A400 as the secondary main color');
-    assert.strictEqual(palette.secondary.light, lighten(green.A400, 0.2), 'should use lighten(green.A400, 0.2) as the secondary light color');
-    assert.strictEqual(palette.secondary.dark, darken(green.A400, 0.3), 'should use darken(green.A400, 0.3) as the secondary dark color');
-    assert.strictEqual(palette.error.main, pink[500], 'should use pink[500] as the error main color');
-    assert.strictEqual(palette.error.light, lighten(pink[500], 0.2), 'should use lighten(pink[500], 0.2) as the error light color');
-    assert.strictEqual(palette.error.dark, darken(pink[500], 0.3), 'should use darken(pink[500], 0.3) as the error dark color');
-  });
-  it('should calculate light and dark colors using the provided tonalOffset', function () {
-    var palette = createPalette({
-      primary: {
-        main: deepOrange[500]
-      },
-      secondary: {
-        main: green.A400
-      },
-      error: {
-        main: red[500]
-      },
-      tonalOffset: 0.1
-    }); // primary
-
-    assert.strictEqual(palette.primary.main, deepOrange[500], 'should use deepOrange[500] as the primary main color');
-    assert.strictEqual(palette.primary.light, lighten(deepOrange[500], 0.1), 'should use lighten(deepOrange[500], 0.1) as the primary light color');
-    assert.strictEqual(palette.primary.dark, darken(deepOrange[500], 0.15), 'should use darken(deepOrange[500], 0.1) as the primary dark color'); // secondary
-
-    assert.strictEqual(palette.secondary.main, green.A400, 'should use green.A400 as the secondary main color');
-    assert.strictEqual(palette.secondary.light, lighten(green.A400, 0.1), 'should use lighten(green.A400, 0.1) as the secondary light color');
-    assert.strictEqual(palette.secondary.dark, darken(green.A400, 0.15), 'should use darken(green.A400, 0.1) as the secondary dark color'); // error
-
-    assert.strictEqual(palette.error.main, red[500], 'should use red[500] as the error main color');
-    assert.strictEqual(palette.error.light, lighten(red[500], 0.1), 'should use lighten(red[500], 0.1) as the error light color');
-    assert.strictEqual(palette.error.dark, darken(red[500], 0.15), 'should use darken(red[500], 0.1) as the error dark color');
-  });
-  it('should calculate contrastText using the provided contrastThreshold', function () {
-    var palette = createPalette({
-      contrastThreshold: 7
-    });
-    assert.strictEqual(palette.primary.contrastText, '#FFFFFF', 'should use white as the default primary contrastText color');
-    assert.strictEqual(palette.secondary.contrastText, '#FFFFFF', 'should use white as the default secondary contrastText color');
-  });
-  it('should create a dark palette', function () {
-    var palette = createPalette({
-      type: 'dark'
-    });
-    assert.strictEqual(palette.primary.main, '#00ade9', 'should use indigo as the default primary color');
-    assert.strictEqual(palette.secondary.main, '#ffcf21', 'should use pink as the default secondary color');
-    assert.strictEqual(palette.text, dark.text, 'should use dark theme text');
-    assert.strictEqual(consoleErrorMock.callCount(), 0);
-  });
-  it('should throw an exception when an invalid type is specified', function () {
-    createPalette({
-      type: 'foo'
-    });
-    assert.strictEqual(consoleErrorMock.callCount(), 1);
-    assert.match(consoleErrorMock.args()[0][0], /Material-UI: the palette type `foo` is not supported/);
-  });
-  describe('augmentColor', function () {
-    it('should throw when the input is invalid', function () {
-      var palette = createPalette({});
-      assert.throws(function () {
-        palette.augmentColor({});
-      }, /The color object needs to have a/);
-    });
-  });
-});

package/styles/createStyles.test.js

@@ -1,8 +0,0 @@
-import { assert } from 'chai';
-import { createStyles } from '.';
-describe('createStyles', function () {
-  it('is the identity function', function () {
-    var styles = {};
-    assert.strictEqual(createStyles(styles), styles);
-  });
-});

package/styles/createTypography.test.js

@@ -1,60 +0,0 @@
-import { assert } from 'chai';
-import createPalette from './createPalette';
-import createTypography from './createTypography';
-describe('createTypography', function () {
-  var palette;
-  before(function () {
-    palette = createPalette({});
-  });
-  it('should create a material design typography according to spec', function () {
-    var typography = createTypography(palette, {});
-    assert.strictEqual(typography.fontSize, 14);
-  });
-  it('should create a typography with custom fontSize', function () {
-    var typography = createTypography(palette, {
-      fontSize: 15
-    });
-    assert.strictEqual(typography.fontSize, 15);
-  });
-  it('should accept a function', function () {
-    var typography = createTypography(palette, function (paletteCurrent) {
-      assert.strictEqual(palette, paletteCurrent);
-      return {
-        fontSize: 15
-      };
-    });
-    assert.strictEqual(typography.fontSize, 15);
-  });
-  it('should accept a custom font size', function () {
-    var typography = createTypography(palette, {
-      fontSize: 16
-    });
-    assert.strictEqual(typography.body1.fontSize, '1rem', 'should be 16px');
-  });
-  it('should create a typography with a custom baseFontSize', function () {
-    var typography = createTypography(palette, {
-      htmlFontSize: 10
-    });
-    assert.strictEqual(typography.display4.fontSize, '11.2rem');
-  });
-  it('should create a typography with custom display4', function () {
-    var customFontSize = '18px';
-    var typography = createTypography(palette, {
-      display4: {
-        fontSize: customFontSize
-      }
-    });
-    assert.strictEqual(typography.display4.fontSize, customFontSize);
-  });
-  it('should apply a CSS property to all the variants', function () {
-    var typography = createTypography(palette, {
-      allVariants: {
-        marginLeft: 0
-      }
-    });
-    var allVariants = ['display4', 'display3', 'display2', 'display1', 'headline', 'title', 'subheading', 'body2', 'body1', 'caption', 'button'];
-    allVariants.forEach(function (variant) {
-      assert.strictEqual(typography[variant].marginLeft, 0);
-    });
-  });
-});

package/styles/getStylesCreator.test.js

@@ -1,92 +0,0 @@
-import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
-import { assert } from 'chai';
-import consoleErrorMock from 'test/utils/consoleErrorMock';
-import getStylesCreator from './getStylesCreator';
-describe('getStylesCreator', function () {
-  var name = 'name';
-  var stylesCreator = getStylesCreator({
-    root: {
-      color: 'black',
-      '&:hover': {
-        color: 'red',
-        borderRadius: 0
-      }
-    }
-  });
-  it('should be able to get the styles', function () {
-    var styles = stylesCreator.create({});
-    assert.deepEqual(styles, {
-      root: {
-        color: 'black',
-        '&:hover': {
-          color: 'red',
-          borderRadius: 0
-        }
-      }
-    });
-  });
-  describe('overrides', function () {
-    before(function () {
-      consoleErrorMock.spy();
-    });
-    after(function () {
-      consoleErrorMock.reset();
-    });
-    it('should be able to overrides some rules, deep', function () {
-      var theme = {
-        overrides: _defineProperty({}, name, {
-          root: {
-            color: 'white',
-            '&:hover': {
-              borderRadius: 2,
-              backgroundColor: 'black'
-            }
-          }
-        })
-      };
-      var styles = stylesCreator.create(theme, name);
-      assert.deepEqual(styles, {
-        root: {
-          color: 'white',
-          '&:hover': {
-            color: 'red',
-            borderRadius: 2,
-            backgroundColor: 'black'
-          }
-        }
-      });
-    });
-    it('should warn on wrong usage', function () {
-      var theme = {
-        overrides: _defineProperty({}, name, {
-          bubu: {
-            color: 'white'
-          }
-        })
-      };
-      stylesCreator.create(theme, name);
-      assert.strictEqual(consoleErrorMock.callCount(), 1);
-      assert.match(consoleErrorMock.args()[0][0], /Fix the `bubu` key of `theme\.overrides\.name`/);
-    });
-    it('should support jss-expand', function () {
-      var stylesCreator2 = getStylesCreator({
-        root: {
-          padding: [8, 16]
-        }
-      });
-      var theme = {
-        overrides: _defineProperty({}, name, {
-          root: {
-            padding: [20, 10]
-          }
-        })
-      };
-      var styles = stylesCreator2.create(theme, name);
-      assert.deepEqual(styles, {
-        root: {
-          padding: [20, 10]
-        }
-      });
-    });
-  });
-});

package/styles/getThemeProps.test.js

@@ -1,39 +0,0 @@
-import { assert } from 'chai';
-import getThemeProps from './getThemeProps';
-describe('getThemeProps', function () {
-  it('should ignore empty theme', function () {
-    var props = getThemeProps({
-      theme: {},
-      name: 'MuiFoo'
-    });
-    assert.deepEqual(props, {});
-  });
-  it('should ignore different component', function () {
-    var props = getThemeProps({
-      theme: {
-        props: {
-          MuiBar: {
-            disableRipple: true
-          }
-        }
-      },
-      name: 'MuiFoo'
-    });
-    assert.deepEqual(props, {});
-  });
-  it('should return the properties', function () {
-    var props = getThemeProps({
-      theme: {
-        props: {
-          MuiFoo: {
-            disableRipple: true
-          }
-        }
-      },
-      name: 'MuiFoo'
-    });
-    assert.deepEqual(props, {
-      disableRipple: true
-    });
-  });
-});

package/styles/themeListener.test.js

@@ -1,26 +0,0 @@
-import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
-import { assert } from 'chai';
-import createBroadcast from 'brcast';
-import themeListener, { CHANNEL } from './themeListener';
-describe('themeListener', function () {
-  it('should be able to get the initial state', function () {
-    var broadcast = createBroadcast();
-    var initialState = {};
-    broadcast.setState(initialState);
-    assert.strictEqual(themeListener.initial(_defineProperty({}, CHANNEL, broadcast)), initialState);
-  });
-  it('should not complain if the context is not defined', function () {
-    assert.strictEqual(themeListener.initial({}), null);
-  });
-  it('should be able to subscribe to the event stream', function (done) {
-    var broadcast = createBroadcast();
-    var initialState = {};
-    var secondState = {};
-    broadcast.setState(initialState);
-    themeListener.subscribe(_defineProperty({}, CHANNEL, broadcast), function (state) {
-      assert.strictEqual(state, secondState);
-      done();
-    });
-    broadcast.setState(secondState);
-  });
-});