@progress/kendo-themes-html 5.0.0-next.4 → 5.1.0

package/lib/jsx-runtime.js

@@ -1,5 +1,7 @@
+/* eslint-disable no-new */
+/* global kendo */
 import { isFunction, isArray, isObject } from '../utils/object';
-import { classNames } from '../utils/styles';
+import { classNames, cssStyle } from '../utils/styles';
 
 const JSX_FRAGMENT = '#fragment';
 const JSX_TEXT = '#text';
@@ -7,21 +9,200 @@ const JSX_TEXT = '#text';
 const attrMap = {
     'class': 'className',
     themecolor: 'themeColor',
-    fillmode: 'fillMode'
+    fillmode: 'fillMode',
+
+    // Inputs
+    showtext: 'showText',
+    showvalue: 'showValue',
+    valueicon: 'valueIcon',
+    valueiconname: 'valueIconName',
+    showicon: 'showIcon',
+    iconposition: 'iconPosition',
+    iconname: 'iconName',
+    showarrow: 'showArrow',
+    arrowicon: 'arrowIcon',
+    arrowiconname: 'arrowIconName',
+    showarrowbutton: 'showArrowButton',
+    arrowbutton: 'arrowButton',
+    showdropdownbutton: 'showDropdownButton',
+    dropdownbutton: 'dropdownButton',
+    showspinbutton: 'showSpinButton',
+    spinbutton: 'spinButton',
+    showclearbutton: 'showClearButton',
+    clearbutton: 'clearButton',
+
+    showcheckbox: 'showCheckbox',
+
+    // Switch
+    onlabel: 'onLabel',
+    offlabel: 'offLabel',
+    trackrounded: 'trackRounded',
+    thumbrounded: 'thumbRounded',
+
+    // Chip
+    showavatar: 'showAvatar',
+
+    // Hierarchy
+    haschildren: 'hasChildren',
+
+    // Treeview
+    leafclassname: 'leafClassName',
+
+    // Template
+    contenttemplate: 'contentTemplate'
 };
 
-function attrToProps( element ) {
-    let attributes = element.attributes;
+const booleanAttr = new Set([
+    'hidden',
+
+    'hover',
+    'focus',
+    'active',
+    'readonly',
+    'disabled',
+
+    'checked',
+    'indeterminate',
+
+    'valid',
+    'invalid',
+    'required',
+
+    'selected',
+    'loading',
+
+    'showText',
+    'showValue',
+    'showIcon',
+    'showClearButton',
+    'showSpinButton',
+    'showArrow',
+
+    'showCheckbox',
+
+    'virtualization',
+    'root',
+
+    'open',
+    'expanded',
+    'hasChildren',
+
+    'showArrow',
+
+    'showAvatar',
+
+    'aria'
+]);
+
+const nullAttr = new Set([
+    'size',
+    'shape',
+    'rounded',
+    'fillMode',
+    'themeColor',
+
+    'trackRounded',
+    'thumbRounded'
+]);
+
+const skipAttr = new Set([
+    'is',
+    'aria',
+    'legacy'
+]);
+
+const setAttr = new Set([
+    // Global
+    'id',
+    'style',
+
+    // Related to forms
+    'type',
+    'value',
+    'placeholder',
+    'autocomplete'
+]);
+
+function htmlToProps( element ) {
+    let props = attrToProps( element.attributes );
+    let children = Array.from( element.childNodes );
+
+    props.children = [];
+
+    children.forEach( child => {
+        let childProps;
+        let nodeType = child.nodeType;
+
+        if ( nodeType === Node.TEXT_NODE ) {
+            let textContent = child.textContent.trim();
+
+            if ( textContent !== '' ) {
+                childProps = {
+                    type: JSX_TEXT,
+                    props: {
+                        text: textContent
+                    }
+                };
+
+                props.children.push( childProps );
+            }
+        }
+
+        if ( nodeType === Node.ELEMENT_NODE ) {
+            let componentName = child.getAttribute('is');
+            let component = kendo.Html[componentName];
+
+            if (isFunction( component )) {
+                component = new component( child );
+                childProps = component.render();
+                childProps._component = componentName;
+            } else {
+                childProps = {
+                    type: child.nodeName,
+                    props: htmlToProps( child )
+                };
+
+            }
+
+            props.children.push( childProps );
+        }
+
+    });
+
+    return props;
+}
+
+function attrToProps( attributes ) {
     let props = {};
 
     Array.from(attributes).forEach((attrObj) => {
         let attrName = attrObj.name;
+        let attrValue = attrObj.value;
 
         if (attrMap[attrName]) {
             attrName = attrMap[attrName];
         }
 
-        props[ attrName ] = attrObj.value;
+        // Set props as is
+        props[ attrName ] = attrValue;
+
+        // Ensure boolean value
+        if (booleanAttr.has(attrName) && typeof attrValue === 'string') {
+            switch (attrValue) {
+                case '':
+                case 'true':
+                    props[ attrName ] = true;
+                    break;
+                default:
+                    props[ attrName ] = false;
+                    break;
+            }
+        }
+
+        // Ensure null value
+        if (nullAttr.has(attrName) && attrValue === 'null') {
+            props[ attrName ] = null;
+        }
     });
 
     return props;
@@ -65,12 +246,28 @@ function jsxs( type, config ) {
 
 function renderDOM( jsxNode, container = null ) {
 
-    const nodeType = jsxNode.type;
+    // Handle native nodes
+    switch (jsxNode.nodeType) {
+        case Node.TEXT_NODE:
+        case Node.ELEMENT_NODE:
+        case Node.DOCUMENT_FRAGMENT_NODE: {
+
+            if ( container !== null ) {
+                container.appendChild( jsxNode );
+            }
+
+            return jsxNode;
+        }
+        default:
+            break;
+    }
+
+    const jsxNodeType = jsxNode.type;
     const { children = [], ...props } = jsxNode.props;
     let element;
     let textNode;
 
-    if ( nodeType === JSX_TEXT ) {
+    if ( jsxNodeType === JSX_TEXT ) {
         textNode = document.createTextNode( props.text || '' );
 
         if ( container !== null ) {
@@ -80,21 +277,40 @@ function renderDOM( jsxNode, container = null ) {
         return textNode;
     }
 
-    if ( nodeType === JSX_FRAGMENT ) {
+    if ( jsxNodeType === JSX_FRAGMENT ) {
         element = document.createDocumentFragment();
     } else {
-        element = document.createElement(nodeType);
+        element = document.createElement(jsxNodeType);
     }
 
     props.className = classNames( props.className );
+    props.style = cssStyle( props.style );
 
     for (let [ attr, val ] of Object.entries(props)) {
-        element[attr] = val;
+        if (skipAttr.has(attr)) {
+            continue;
+        }
+
+        if (setAttr.has(attr)) {
+            if (val !== '') {
+                element.setAttribute( attr, val );
+            }
+        } else {
+            element[attr] = val;
+        }
     }
 
-    children.forEach( child => {
-        renderDOM( child, element );
-    });
+    if (children.nodeType === Node.DOCUMENT_FRAGMENT_NODE) {
+        element.append( children );
+    } else {
+        children.forEach( child => {
+            if (child === null) {
+                return;
+            }
+
+            renderDOM( child, element );
+        });
+    }
 
     if ( container !== null ) {
         container.appendChild( element );
@@ -108,5 +324,6 @@ export {
     jsxs,
     JSX_FRAGMENT as Fragment,
     renderDOM,
-    attrToProps
+    attrToProps,
+    htmlToProps
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@progress/kendo-themes-html",
   "description": "A collection of HTML helpers used for developing Kendo UI themes",
-  "version": "5.0.0-next.4",
+  "version": "5.1.0",
   "author": "Progress",
   "license": "Apache-2.0",
   "keywords": [
@@ -34,13 +34,13 @@
     "dev": "rollup -cw"
   },
   "devDependencies": {
-    "@babel/core": "^7.15.5",
-    "@babel/preset-env": "^7.15.6",
-    "@babel/preset-react": "^7.14.5",
+    "@babel/core": "^7.16.7",
+    "@babel/preset-env": "^7.16.7",
+    "@babel/preset-react": "^7.16.7",
     "@rollup/plugin-babel": "^5.3.0",
-    "@rollup/plugin-commonjs": "^20.0.0",
-    "@rollup/plugin-node-resolve": "^13.0.5",
-    "rollup": "^2.57.0"
+    "@rollup/plugin-commonjs": "^21.0.1",
+    "@rollup/plugin-node-resolve": "^13.1.2",
+    "rollup": "^2.62.0"
   },
-  "gitHead": "77cbd2943ba55ea1aeac6da992c280dd37f95520"
+  "gitHead": "279941cb925d750fc123f66c3e15ce1e2b666191"
 }

package/src/autocomplete/README.md

@@ -0,0 +1,30 @@
+```html
+<!-- default rendering -->
+<span class="k-autocomplete k-input k-input-md k-rounded-md k-input-solid">
+    <input type="text" class="k-input-inner" value="..." placeholder="..." />
+</span>
+
+<!-- canonical rendering -->
+<span class="
+    k-autocomplete
+    k-input
+    k-input-{size}
+    k-rounded-{rounded}
+    k-input-{fillMode}
+
+    {valid && 'k-valid'}
+    {invalid && 'k-invalid'}
+    {loading && 'k-loading'}
+    {required && 'k-required'}
+    {disabled && 'k-disabled'}
+">
+    {showInputIcon && inputIconName !== '' && <span class="k-input-icon k-i-icon k-i-{inputIconName}"></span>}
+    {inputPrefix && <span class="k-input-prefix">...</span>}
+    <input type={type} class="k-input-inner" value={value} placeholder={placeholder} disabled={disabled} />
+    {inputPrefix && <span class="k-input-suffix">...</span>}
+    {showValidationIcon && valid && <span class="k-validation-icon k-icon k-i-check"></span>}
+    {showValidationIcon && invalid && <span class="k-validation-icon k-icon k-i-warning"></span>}
+    {showLoadingIcon && loading && <span class="k-icon k-i-loading"></span>}
+    {showClearValue && text !== '' && <span class="k-clear-value"><span class="k-icon k-i-x"></span></span>}
+</span>
+```

package/src/autocomplete/autocomplete.jsx

@@ -0,0 +1,160 @@
+import { globalDefaultProps } from '../component/index';
+import { Input, InputStatic, InputInnerInputStatic } from '../input/index';
+import { InputValidationIconStatic, InputLoadingIconStatic, InputClearValueStatic } from '../input/index';
+
+class Autocomplete extends Input {
+    render() {
+        return <AutocompleteStatic {...this.props} />;
+    }
+}
+
+function AutocompleteStatic(props) {
+
+    const {
+        className: ownClassName,
+
+        type,
+        value,
+        placeholder,
+        autocomplete,
+
+        prefix,
+        suffix,
+
+        size,
+        rounded,
+
+        fillMode,
+
+        hover,
+        focus,
+        valid,
+        invalid,
+        required,
+        disabled,
+
+        aria,
+        legacy,
+
+        ...htmlAttributes
+    } = props;
+
+    htmlAttributes.size = size;
+    htmlAttributes.rounded = rounded;
+    htmlAttributes.fillMode = fillMode;
+    htmlAttributes.hover = hover;
+    htmlAttributes.focus = focus;
+    htmlAttributes.valid = valid;
+    htmlAttributes.invalid = invalid;
+    htmlAttributes.required = required;
+    htmlAttributes.disabled = disabled;
+
+    const inputAttributes = {
+        type,
+        value,
+        placeholder,
+        autocomplete,
+
+        disabled
+    };
+
+    let autocompleteClasses = [
+        ownClassName,
+        'k-autocomplete'
+    ];
+
+    let ariaAttr = aria
+        ? {}
+        : {};
+
+    if (legacy) {
+
+        let legacyClasses = [
+            ownClassName,
+            'k-widget',
+            'k-autocomplete',
+            {
+                'k-state-hover': hover === true,
+                'k-state-focus': focus === true,
+                'k-state-invalid': invalid === true,
+                'k-state-required': required === true,
+                'k-state-disabled': disabled === true
+            }
+        ];
+
+        return (
+            <InputStatic className={legacyClasses} {...htmlAttributes}>
+                <input type={type} className="k-input" {...inputAttributes} />
+                <InputValidationIconStatic {...props} />
+                <InputLoadingIconStatic {...props} />
+                <InputClearValueStatic {...props} />
+            </InputStatic>
+        );
+    }
+
+    return (
+        <InputStatic className={autocompleteClasses} {...ariaAttr} {...htmlAttributes}>
+            {prefix}
+            <InputInnerInputStatic {...inputAttributes} />
+            {suffix}
+            <InputValidationIconStatic {...props} />
+            <InputLoadingIconStatic {...props} />
+            <InputClearValueStatic {...props} />
+        </InputStatic>
+    );
+}
+
+AutocompleteStatic.defaultProps = {
+    ...globalDefaultProps,
+
+    type: 'text',
+    value: '',
+    placeholder: '',
+    autocomplete: 'off',
+
+    showValidationIcon: true,
+    showLoadingIcon: true,
+    showClearButton: true,
+
+    size: 'medium',
+    rounded: 'medium',
+
+    fillMode: 'solid'
+};
+
+AutocompleteStatic.propTypes = {
+    children: typeof [],
+    className: typeof '',
+
+    type: typeof [ 'text', 'password' ],
+    value: typeof '',
+    placeholder: typeof '',
+    autocomplete: typeof [ 'on', 'off' ],
+
+    showValidationIcon: typeof true,
+    showLoadingIcon: typeof true,
+    showClearButton: typeof true,
+
+    prefix: typeof '#fragment',
+    suffix: typeof '#fragment',
+
+    size: typeof [ null, 'small', 'medium', 'large' ],
+    rounded: typeof [ null, 'small', 'medium', 'large', 'full' ],
+
+    fillMode: typeof [ null, 'solid', 'flat', 'outline' ],
+
+    hover: typeof false,
+    focus: typeof false,
+    valid: typeof false,
+    invalid: typeof false,
+    loading: typeof false,
+    required: typeof false,
+    disabled: typeof false,
+
+    aria: typeof false,
+    legacy: typeof false,
+
+    htmlAttributes: typeof []
+};
+
+export { Autocomplete, AutocompleteStatic };

package/src/autocomplete/index.js

@@ -0,0 +1 @@
+export * from './autocomplete.jsx';

package/src/avatar/README.md

@@ -0,0 +1,21 @@
+```html
+<!-- default rendering -->
+<div class="k-avatar k-avatar-md k-rounded-circle k-avatar-solid k-avatar-solid-primary">
+    <span class="k-avatar-image">
+        <img src="../../assets/avatar.jpg" />
+    </span>
+</div>
+
+<!-- canonical rendering -->
+<div class="
+    k-avatar
+    k-avatar-{size}
+    k-rounded-{rounded}
+    k-avatar-{fillMode}
+    k-avatar-{fillMode}-{themeColor}
+">
+    <span class="k-avatar-{type}">
+        {content}
+    </span>
+</div>
+```

package/src/avatar/avatar.jsx

@@ -0,0 +1,110 @@
+import * as styles from '../../utils/styles';
+import { Component, globalDefaultProps } from '../component/index';
+
+class Avatar extends Component {
+    render() {
+        return <AvatarStatic {...this.props} />;
+    }
+}
+
+function AvatarStatic(props) {
+    const {
+        className: ownClassName,
+
+        children,
+
+        type,
+
+        size,
+        rounded,
+        bordered,
+
+        fillMode,
+        themeColor,
+
+        aria,
+        legacy,
+
+        ...htmlAttributes
+    } = props;
+
+    let avatarClasses = [
+        ownClassName,
+        'k-avatar',
+        styles.sizeClass( size, 'k-avatar' ),
+        styles.roundedClass( rounded ),
+        styles.fillModeClass( fillMode, 'k-avatar' ),
+        styles.themeColorClass( fillMode, themeColor, 'k-avatar' ),
+        styles.borderedClass( bordered, 'k-avatar' ),
+    ];
+
+    let ariaAttr = aria
+        ? {}
+        : {};
+
+    if (legacy) {
+
+        let legacyClasses = [
+            ownClassName,
+            'k-avatar',
+            `k-avatar-${themeColor}`,
+            styles.roundedClass( rounded ),
+            styles.sizeClass( size, 'k-avatar' ),
+            styles.fillModeClass( fillMode, 'k-avatar' ),
+            styles.borderedClass( bordered, 'k-avatar' ),
+        ];
+
+        return (
+            <span className={legacyClasses} {...ariaAttr} {...htmlAttributes}>
+                <span className={`k-avatar-${type}`}>
+                    {children}
+                </span>
+            </span>
+        );
+    }
+
+    return (
+        <span className={avatarClasses} {...ariaAttr} {...htmlAttributes}>
+            <span className={`k-avatar-${type}`}>
+                {children}
+            </span>
+        </span>
+    );
+}
+
+AvatarStatic.defaultProps = {
+    ...globalDefaultProps,
+
+    className: '',
+    children: [],
+
+    type: '',
+
+    size: 'medium',
+    rounded: 'full',
+    bordered: false,
+
+    fillMode: 'solid',
+    themeColor: 'primary'
+};
+
+AvatarStatic.propTypes = {
+    className: typeof '',
+    children: typeof [],
+
+    type: typeof '',
+
+    size: typeof [ null, 'small', 'medium', 'large' ],
+    rounded: typeof [ null, 'small', 'medium', 'large', 'full' ],
+    bordered: typeof false,
+
+    fillMode: typeof [ null, 'solid', 'outline' ],
+    themeColor: typeof [ null, 'primary' ],
+
+    aria: typeof false,
+    legacy: typeof false,
+
+    htmlAttributes: typeof []
+};
+
+export { Avatar, AvatarStatic };

package/src/avatar/index.js

@@ -0,0 +1 @@
+export * from './avatar.jsx';

package/src/button/README.md

@@ -0,0 +1,22 @@
+```html
+<!-- default rendering -->
+<button type="button" class="k-button k-button-md k-rounded-md k-button-solid k-button-solid-base">
+    <span class="k-button-text">Text</span>
+</button>
+
+<!-- canonical rendering -->
+<button class="
+    k-button
+    {text === '' && iconName !== '' && 'k-icon-button'}
+    k-button-{size}
+    k-button-{shape}
+    k-rounded-{rounded}
+    k-button-{fillMode}
+    k-button-{fillMode}-{themeColor}
+
+    {disabled && 'k-disabled'}
+" type={type} disabled={disabled}>
+    {iconName !== '' && <span class="k-button-icon k-icon k-i-{iconName}"></span>}
+    {text !== '' && <span class="k-button-text">Button</span>}
+</button>
+```