@pie-lib/config-ui 12.0.0-beta.5 → 12.1.0-next.0

package/src/langs.jsx

@@ -1,40 +1,38 @@
-import Input from '@material-ui/core/Input';
-import InputLabel from '@material-ui/core/InputLabel';
+import Input from '@mui/material/Input';
+import InputLabel from '@mui/material/InputLabel';
 import PropTypes from 'prop-types';
 import React from 'react';
-import classNames from 'classnames';
-import { withStyles } from '@material-ui/core/styles';
-import Select from '@material-ui/core/Select';
-import MenuItem from '@material-ui/core/MenuItem';
-import FormControl from '@material-ui/core/FormControl';
+import { styled } from '@mui/material/styles';
+import Select from '@mui/material/Select';
+import MenuItem from '@mui/material/MenuItem';
+import FormControl from '@mui/material/FormControl';
 import debug from 'debug';
 
 const log = debug('pie-elements:config-ui:langs');
 
-const styles = (theme) => ({
-  root: {
-    flexDirection: 'column',
-    alignItems: 'start',
-    display: 'flex',
-    position: 'relative',
-    paddingTop: '0px',
-    paddingRight: '0px',
-  },
-  formControl: {
-    position: 'initial',
-  },
-  inputLabel: {
-    paddingBottom: theme.spacing.unit,
-  },
-});
+const StyledRoot = styled('div')(() => ({
+  flexDirection: 'column',
+  alignItems: 'start',
+  display: 'flex',
+  position: 'relative',
+  paddingTop: '0px',
+  paddingRight: '0px',
+}));
 
-export class RawLangs extends React.Component {
+const StyledFormControl = styled(FormControl)(() => ({
+  position: 'initial',
+}));
+
+const StyledInputLabel = styled(InputLabel)(({ theme }) => ({
+  paddingBottom: theme.spacing(1),
+}));
+
+export class Langs extends React.Component {
   static propTypes = {
     onChange: PropTypes.func,
     langs: PropTypes.array,
     selected: PropTypes.string,
     label: PropTypes.string,
-    classes: PropTypes.object.isRequired,
     uid: PropTypes.string,
   };
 
@@ -52,16 +50,16 @@ export class RawLangs extends React.Component {
   };
 
   render() {
-    let { langs, selected, label, classes } = this.props;
+    let { langs, selected, label } = this.props;
 
     log('[render] selected:', selected);
 
     return (
-      <div className={classes.root}>
-        <FormControl className={classes.formControl}>
-          <InputLabel className={classes.inputLabel} htmlFor={this.uid}>
+      <StyledRoot>
+        <StyledFormControl>
+          <StyledInputLabel htmlFor={this.uid}>
             {label}
-          </InputLabel>
+          </StyledInputLabel>
 
           <Select value={selected} onChange={this.choose} input={<Input id={this.uid} />}>
             {langs.map((l, index) => (
@@ -70,27 +68,23 @@ export class RawLangs extends React.Component {
               </MenuItem>
             ))}
           </Select>
-        </FormControl>
-      </div>
+        </StyledFormControl>
+      </StyledRoot>
     );
   }
 }
-
-const Langs = withStyles(styles, { name: 'Langs' })(RawLangs);
 export default Langs;
 
-export const LanguageControls = withStyles({
-  languageControls: {
-    display: 'grid',
-    gridAutoFlow: 'column',
-    gridAutoColumns: '1fr',
-    gridGap: '8px',
-  },
-})(({ classes, langs, activeLang, defaultLang, onActiveLangChange, onDefaultLangChange, className }) => {
-  const names = classNames(classes.languageControls, className);
+const StyledLanguageControls = styled('div')(() => ({
+  display: 'grid',
+  gridAutoFlow: 'column',
+  gridAutoColumns: '1fr',
+  gridGap: '8px',
+}));
 
+export const LanguageControls = ({ langs, activeLang, defaultLang, onActiveLangChange, onDefaultLangChange, className }) => {
   return (
-    <div className={names}>
+    <StyledLanguageControls className={className}>
       <Langs
         label="Choose language to edit"
         langs={langs}
@@ -98,9 +92,9 @@ export const LanguageControls = withStyles({
         onChange={(l) => onActiveLangChange(l)}
       />
       <Langs label="Default language" langs={langs} selected={defaultLang} onChange={(l) => onDefaultLangChange(l)} />
-    </div>
+    </StyledLanguageControls>
   );
-});
+};
 
 LanguageControls.propTypes = {
   langs: PropTypes.array,
@@ -108,4 +102,5 @@ LanguageControls.propTypes = {
   defaultLang: PropTypes.string.isRequired,
   onActiveLangChange: PropTypes.func.isRequired,
   onDefaultLangChange: PropTypes.func.isRequired,
+  className: PropTypes.string,
 };

package/src/layout/__tests__/config.layout.test.jsx

@@ -0,0 +1,59 @@
+import React from 'react';
+import { render, screen, waitFor } from '@testing-library/react';
+import ConfigLayout from '../config-layout';
+
+describe('ConfigLayout', () => {
+  const settingsPanel = (
+    <div data-testid="settings-panel">
+      <div key={0}>Foo</div>
+      <div key={1}>Bar</div>
+    </div>
+  );
+
+  const children = (
+    <div data-testid="main-content">
+      <div>Foo</div>
+      <div>Bar</div>
+    </div>
+  );
+
+  describe('rendering', () => {
+    it('renders correctly with settings panel', async () => {
+      render(<ConfigLayout settings={settingsPanel}>{children}</ConfigLayout>);
+
+      // Main content should render immediately
+      expect(screen.getByTestId('main-content')).toBeInTheDocument();
+
+      // Settings panel may render after layout calculation
+      // In test environment, react-measure may not provide dimensions,
+      // so we check if it exists but don't require it
+      await waitFor(() => {
+        expect(screen.getByText('Foo')).toBeInTheDocument();
+      });
+    });
+
+    it('renders main content when provided', () => {
+      render(<ConfigLayout settings={settingsPanel}>{children}</ConfigLayout>);
+
+      expect(screen.getByTestId('main-content')).toBeInTheDocument();
+      expect(screen.getByText('Foo')).toBeInTheDocument();
+      // Only check that Bar appears at least once (in main content)
+      expect(screen.getAllByText('Bar').length).toBeGreaterThanOrEqual(1);
+    });
+
+    it('renders settings panel content', () => {
+      render(<ConfigLayout settings={settingsPanel}>{children}</ConfigLayout>);
+
+      // Settings panel might not render in test environment due to react-measure
+      // Just verify the component renders without crashing
+      expect(screen.getByTestId('main-content')).toBeInTheDocument();
+    });
+
+    it('renders without settings panel when not provided', () => {
+      render(<ConfigLayout>{children}</ConfigLayout>);
+
+      expect(screen.queryByTestId('settings-panel')).not.toBeInTheDocument();
+      expect(screen.getByTestId('main-content')).toBeInTheDocument();
+    });
+  });
+});

package/src/layout/__tests__/layout-content.test.jsx

@@ -0,0 +1,3 @@
+describe('layout-content', () => {
+  it.todo('add tests!');
+});

package/src/layout/config-layout.jsx

@@ -1,15 +1,35 @@
 import React from 'react';
 import Measure from 'react-measure';
+import { createTheme, ThemeProvider, StyledEngineProvider } from '@mui/material/styles';
 import { withContentRect } from 'react-measure';
 import PropTypes from 'prop-types';
 import LayoutContents from './layout-contents';
 import SettingsBox from './settings-box';
+import { AppendCSSRules } from '@pie-lib/render-ui';
 
-class MeasuredConfigLayout extends React.Component {
+const theme = createTheme({
+  typography: {
+    fontFamily: 'inherit',
+  },
+  components: {
+    MuiButton: {
+      styleOverrides: {
+        contained: {
+          backgroundColor: '#e0e0e0',
+          color: '#000000',
+          '&:hover': {
+            backgroundColor: '#bdbdbd',
+          },
+        },
+      },
+    },
+  },
+});
+
+class MeasuredConfigLayout extends AppendCSSRules {
   static propTypes = {
     children: PropTypes.oneOfType([PropTypes.string, PropTypes.arrayOf(PropTypes.element), PropTypes.element]),
     className: PropTypes.string,
-    classes: PropTypes.object,
     dimensions: PropTypes.object,
     settings: PropTypes.element,
     sidePanelMinWidth: PropTypes.number,
@@ -17,13 +37,13 @@ class MeasuredConfigLayout extends React.Component {
   };
 
   static defaultProps = {
-    sidePanelMinWidth: 950,
+    sidePanelMinWidth: 1135,
     hideSettings: false,
     dimensions: {},
   };
 
-  constructor(props) {
-    super(props);
+  constructor(...props) {
+    super(...props);
     this.state = { layoutMode: undefined };
   }
 
@@ -33,31 +53,41 @@ class MeasuredConfigLayout extends React.Component {
     const { maxWidth } = dimensions || {};
 
     const layoutMode =
-      bounds.width >= sidePanelMinWidth && (maxWidth ? maxWidth >= sidePanelMinWidth : true) ? 'inline' : 'tabbed';
+      bounds.width > sidePanelMinWidth && (maxWidth ? maxWidth > sidePanelMinWidth : true) ? 'inline' : 'tabbed';
 
-    this.setState({ layoutMode });
+    // Only update state (and cause a re-render) if the computed layoutMode changed.
+    if (layoutMode !== this.state.layoutMode) {
+      this.setState({ layoutMode });
+    }
   };
 
   render() {
     return (
-      <Measure bounds onResize={this.onResize}>
-        {({ measureRef }) => {
-          const { children, settings, hideSettings, dimensions } = this.props;
-          const { layoutMode } = this.state;
+      // TODO: REVIEW MuiThemeProvider usage - is this still needed after mui update?
+      // Different theme object identities will force theme consumers to re-render.
+      <StyledEngineProvider injectFirst>
+        <ThemeProvider theme={theme}>
+          <Measure bounds onResize={this.onResize}>
+            {({ measureRef }) => {
+              const { children, settings, hideSettings, dimensions } = this.props;
+              const { layoutMode } = this.state;
 
-          const settingsPanel =
-            layoutMode === 'inline' ? <SettingsBox className="settings-box">{settings}</SettingsBox> : settings;
-          const secondaryContent = hideSettings ? null : settingsPanel;
+              const settingsPanel =
+                layoutMode === 'inline' ? <SettingsBox className="settings-box">{settings}</SettingsBox> : settings;
+              const secondaryContent = hideSettings ? null : settingsPanel;
+              const finalClass = 'main-container';
 
-          return (
-            <div ref={measureRef} className="main-container">
-              <LayoutContents mode={layoutMode} secondary={secondaryContent} dimensions={dimensions}>
-                {children}
-              </LayoutContents>
-            </div>
-          );
-        }}
-      </Measure>
+              return (
+                <div ref={measureRef} className={finalClass}>
+                  <LayoutContents mode={layoutMode} secondary={secondaryContent} dimensions={dimensions}>
+                    {children}
+                  </LayoutContents>
+                </div>
+              );
+            }}
+          </Measure>
+        </ThemeProvider>
+      </StyledEngineProvider>
     );
   }
 }

package/src/layout/layout-contents.jsx

@@ -1,16 +1,36 @@
 import React from 'react';
-import classnames from 'classnames';
 import PropTypes from 'prop-types';
-import { withStyles } from '@material-ui/core';
+import { styled } from '@mui/material/styles';
 import Tabs from '../tabs';
-import classNames from 'classnames';
+
+const StyledContainer = styled('div')(() => ({
+  display: 'flex',
+  flexDirection: 'column',
+  position: 'relative',
+}));
+
+const StyledFlow = styled('div')(() => ({
+  display: 'flex',
+  justifyContent: 'space-between',
+}));
+
+const StyledContentContainer = styled('div')(({ theme }) => ({
+  padding: `${theme.spacing(2)} 0`,
+}));
+
+const StyledConfigContainer = styled('div')(() => ({
+  flex: '1',
+}));
+
+const StyledSettingsContainer = styled('div')(({ theme }) => ({
+  marginLeft: theme.spacing(2),
+}));
 
 class RawLayoutContents extends React.Component {
   static propTypes = {
     mode: PropTypes.oneOf(['tabbed', 'inline']),
     secondary: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.node), PropTypes.node]),
     children: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.node), PropTypes.node]),
-    classes: PropTypes.object,
     dimensions: PropTypes.object,
   };
 
@@ -47,7 +67,7 @@ class RawLayoutContents extends React.Component {
   // }
 
   render() {
-    const { mode, secondary, children, classes, dimensions } = this.props;
+    const { mode, secondary, children, dimensions } = this.props;
     const { minHeight, minWidth, maxHeight, maxWidth } = dimensions || {};
     const configuration = this.getConfiguration();
 
@@ -65,55 +85,33 @@ class RawLayoutContents extends React.Component {
     }
 
     return (
-      <div className={classes.container} style={{ minHeight, minWidth, maxHeight, maxWidth }}>
+      <StyledContainer style={{ minHeight, minWidth, maxHeight, maxWidth }}>
         {mode === 'inline' && (
-          <div className={classnames(classes.flow, classes.contentContainer)}>
-            <div className={classnames(classes.configContainer, 'design-container')}>{children}</div>
+          <StyledFlow>
+            <StyledConfigContainer className="design-container">{children}</StyledConfigContainer>
             {hasSettingsPanel && (
-              <div className={classnames(classes.settingsContainer, 'settings-container')}>{secondary}</div>
+              <StyledSettingsContainer className="settings-container">{secondary}</StyledSettingsContainer>
             )}
-          </div>
+          </StyledFlow>
         )}
 
         {mode === 'tabbed' && hasSettingsPanel && (
-          <Tabs onChange={this.onTabsChange} contentClassName={classes.contentContainer} indicatorColor="primary">
-            <div title="Design" className="design-container">
+          <Tabs onChange={this.onTabsChange} contentClassName="content-container" indicatorColor="primary">
+            <StyledContentContainer title="Design" className="design-container">
               {children}
-            </div>
-            <div title="Settings" className="settings-container">
+            </StyledContentContainer>
+            <StyledContentContainer title="Settings" className="settings-container">
               {secondary}
-            </div>
+            </StyledContentContainer>
           </Tabs>
         )}
 
         {mode === 'tabbed' && !hasSettingsPanel && (
-          <div className={classNames(classes.contentContainer, 'design-container')}>{children}</div>
+          <StyledContentContainer className="design-container">{children}</StyledContentContainer>
         )}
-      </div>
+      </StyledContainer>
     );
   }
 }
 
-const styles = (theme) => ({
-  flow: {
-    display: 'flex',
-    justifyContent: 'space-between',
-  },
-  container: {
-    display: 'flex',
-    flexDirection: 'column',
-    position: 'relative',
-    overflow: 'auto',
-  },
-  contentContainer: {
-    padding: `${theme.spacing.unit * 2}px 0`,
-  },
-  configContainer: {
-    flex: '1',
-  },
-  settingsContainer: {
-    marginLeft: theme.spacing.unit * 2,
-  },
-});
-
-export default withStyles(styles)(RawLayoutContents);
+export default RawLayoutContents;

package/src/layout/settings-box.jsx

@@ -1,11 +1,21 @@
 import React from 'react';
 import PropTypes from 'prop-types';
-import { withStyles } from '@material-ui/core/styles';
-import classNames from 'classnames';
+import { styled } from '@mui/material/styles';
+
+const StyledSettingsBox = styled('div')(({ theme }) => ({
+  backgroundColor: theme.palette.background.paper,
+  border: `2px solid ${theme.palette.grey[200]}`,
+  display: 'flex',
+  flexDirection: 'column',
+  justifyContent: 'flex-start',
+  minWidth: '275px',
+  maxWidth: '300px',
+  padding: '20px 4px 4px 20px',
+  zIndex: 99,
+}));
 
 export class SettingsBox extends React.Component {
   static propTypes = {
-    classes: PropTypes.object.isRequired,
     className: PropTypes.string,
     children: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.node), PropTypes.node]).isRequired,
   };
@@ -13,23 +23,10 @@ export class SettingsBox extends React.Component {
   static defaultProps = {};
 
   render() {
-    const { classes, className, children } = this.props;
+    const { className, children } = this.props;
 
-    return <div className={classNames(classes.settingsBox, className)}>{children}</div>;
+    return <StyledSettingsBox className={className}>{children}</StyledSettingsBox>;
   }
 }
-const styles = (theme) => ({
-  settingsBox: {
-    backgroundColor: theme.palette.background.paper,
-    border: `2px solid ${theme.palette.grey[200]}`,
-    display: 'flex',
-    flexDirection: 'column',
-    justifyContent: 'flex-start',
-    minWidth: '275px',
-    maxWidth: '300px',
-    padding: '20px 4px 4px 20px',
-    zIndex: 99,
-  },
-});
 
-export default withStyles(styles)(SettingsBox);
+export default SettingsBox;

package/src/mui-box/index.jsx

@@ -1,61 +1,53 @@
 import React from 'react';
 import PropTypes from 'prop-types';
-import { withStyles } from '@material-ui/core/styles';
+import { styled } from '@mui/material/styles';
 import debug from 'debug';
-import classNames from 'classnames';
 
 const log = debug('pie-elements:config-ui:mui-box');
 
-const MuiBox = withStyles((theme) => {
-  const light = theme.palette.type === 'light';
+const StyledMuiBox = styled('div')(({ theme, focused }) => {
+  const light = theme.palette.mode === 'light';
   const bottomLineColor = light ? 'rgba(0, 0, 0, 0.42)' : 'rgba(255, 255, 255, 0.7)';
 
-  log(theme.palette.primary[theme.palette.type || 'light']);
+  log(theme.palette.primary[theme.palette.mode || 'light']);
 
   return {
-    muiBox: {
-      paddingTop: theme.spacing.unit,
-      paddingBottom: theme.spacing.unit,
-      position: 'relative',
-      '&:before': {
-        left: 0,
-        right: 0,
-        bottom: 0,
-        height: '1px',
-        content: '""',
-        position: 'absolute',
-        transition: 'background-color 200ms cubic-bezier(0.4, 0, 0.2, 1) 0ms',
-        pointerEvents: 'none',
-        backgroundColor: bottomLineColor,
-      },
-      '&:hover:before': {
-        height: '2px',
-      },
-      '&:after': {
-        left: 0,
-        right: 0,
-        bottom: 0,
-        height: '2px',
-        content: '""',
-        position: 'absolute',
-        transform: 'scaleX(0)',
-        transition: 'transform 200ms cubic-bezier(0.0, 0, 0.2, 1) 0ms',
-        pointerEvents: 'none',
-        backgroundColor: theme.palette.primary[theme.palette.type], //'#304ffe'
-      },
+    paddingTop: theme.spacing(1),
+    paddingBottom: theme.spacing(1),
+    position: 'relative',
+    '&:before': {
+      left: 0,
+      right: 0,
+      bottom: 0,
+      height: '1px',
+      content: '""',
+      position: 'absolute',
+      transition: 'background-color 200ms cubic-bezier(0.4, 0, 0.2, 1) 0ms',
+      pointerEvents: 'none',
+      backgroundColor: bottomLineColor,
     },
-    focused: {
-      '&:after': {
-        transform: 'scaleX(1)',
-      },
+    '&:hover:before': {
+      height: '2px',
+    },
+    '&:after': {
+      left: 0,
+      right: 0,
+      bottom: 0,
+      height: '2px',
+      content: '""',
+      position: 'absolute',
+      transform: focused ? 'scaleX(1)' : 'scaleX(0)',
+      transition: 'transform 200ms cubic-bezier(0.0, 0, 0.2, 1) 0ms',
+      pointerEvents: 'none',
+      backgroundColor: theme.palette.primary[theme.palette.mode], //'#304ffe'
     },
   };
-})(({ children, classes, focused }) => {
-  const names = classNames(classes.muiBox, focused && classes.focused);
-
-  return <div className={names}>{children}</div>;
 });
 
+const MuiBox = ({ children, focused }) => {
+  return <StyledMuiBox focused={focused}>{children}</StyledMuiBox>;
+};
+
 MuiBox.propTypes = {
   children: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.node), PropTypes.node]).isRequired,
   focused: PropTypes.bool.isRequired,