Vue Switch Props

$(function(){
    $("#switchContainer").dxSwitch({
        // ...
        elementAttr: {
            id: "elementId",
            class: "class-name"
        }
    });
});

<template>
    <DxSwitch ...
        :element-attr="switchAttributes">
    </DxSwitch>
</template>

<script>
import DxSwitch from 'devextreme-vue/switch';

export default {
    components: {
        DxSwitch
    },
    data() {
        return {
            switchAttributes: {
                id: 'elementId',
                class: 'class-name'
            }
        }
    }
}
</script>

import React from 'react';

import Switch from 'devextreme-react/switch';

class App extends React.Component {
    switchAttributes = {
        id: 'elementId',
        class: 'class-name'
    }

    render() {
        return (
            <Switch ...
                elementAttr={this.switchAttributes}>
            </Switch>
        );
    }
}
export default App;

$(() => {
    const switch = $('#switch').dxSwitch({
        // ...
    }).dxSwitch('instance');

    $('#button').dxButton({
        // ...
        onClick () {
            if (switch.option('isDirty')) {
                DevExpress.ui.notify("Do not forget to save changes", "warning", 500);
            }
        }
    });
});

<template>
    <DxSwitch ...
        :ref="switchRef"
    >
    </DxSwitch>
    <DxButton ...
        @click="onClick"
    />
</template>

<script>
import 'devextreme/dist/css/dx.light.css';
import DxSwitch from 'devextreme-vue/switch';
import DxButton from 'devextreme-vue/button';
import notify from 'devextreme/ui/notify';

export default {
    components: {
        DxSwitch,
        DxButton
    },

    data() {
        return {
            switchRef
        }
    },

    methods: {
        onClick () {
            if (this.switch.option('isDirty')) {
                notify("Do not forget to save changes", "warning", 500);
            }
        }
    },

    computed: {
        switch: function() {
            return this.$refs[switchRef].instance;
        }
    }
}
</script>

import React, { useRef } from 'react';
import Switch from 'devextreme-react/switch';
import Button from 'devextreme-react/button';
import 'devextreme/dist/css/dx.light.css';

const App = () => {
    const switchRef = useRef(null);

    const onClick = () => {
        if (this.switchRef.current.instance().option('isDirty')) {
            notify("Do not forget to save changes", "warning", 500);
        }
    };

    return (
        <Switch ...
            ref={switchRef}
        >
        </Switch>
        <Button ...
            onClick={onClick}
        />
    );
};

export default App;

import Switch from 'devextreme-react/switch';

class App extends React.Component {
    constructor(props) {
        super(props);

        this.saveInstance = this.saveInstance.bind(this);
    }

    saveInstance(e) {
        this.switchInstance = e.component;
    }

    render() {
        return (
            <div>
                <Switch onInitialized={this.saveInstance} />
            </div>
        );
    }
}

$(function() {
    $("#switchContainer").dxSwitch({
        // ...
        onOptionChanged: function(e) {
            if(e.name === "changedProperty") {
                // handle the property change here
            }
        }
    });
});

<template> 
    <DxSwitch ...
        @option-changed="handlePropertyChange"
    />            
</template> 

<script>  
import 'devextreme/dist/css/dx.light.css'; 
import DxSwitch from 'devextreme-vue/switch'; 

export default { 
    components: { 
        DxSwitch
    }, 
    // ...
    methods: { 
        handlePropertyChange: function(e) {
            if(e.name === "changedProperty") {
                // handle the property change here
            }
        }
    } 
} 
</script> 

import React from 'react';  
import 'devextreme/dist/css/dx.light.css'; 

import Switch from 'devextreme-react/switch'; 

const handlePropertyChange = (e) => {
    if(e.name === "changedProperty") {
        // handle the property change here
    }
}

export default function App() { 
    return ( 
        <Switch ...
            onOptionChanged={handlePropertyChange}
        />        
    ); 
} 

$(function() {
    $("#switchContainer").dxSwitch({
        // ...
        validationMessagePosition: 'right'
    }).dxValidator({
        validationRules: [{
            type: 'required',
            message: 'Required',
        }],
    });
});

<dx-switch ...
    validationMessagePosition="right">
    <dx-validator>
        <dxi-validation-rule
            type="required"
            message="Required"
        >
        </dxi-validation-rule>
    </dx-validator>
</dx-switch>

<template>
    <DxSwitch ...
        validation-message-position="right"
    >
        <DxValidator>
            <DxRequiredRule message="Required" />
        </DxValidator>
    </DxSwitch>
</template>

<script>
    // ...
</script>

import React from 'react';
// ...

function App() {
    return (
        <Switch ...
            validationMessagePosition="right"
        >
            <Validator>
                <RequiredRule message="Required" />
            </Validator>
        </Switch>
    ); 

};
export default App;

$(function() {
    const switch = $("#switchContainer").dxSwitch({
        // ...
    }).dxSwitch("instance");

    function setInvalidStatus(message) {
        switch.option({
            validationStatus: "invalid",
            validationErrors: [{ message: message }]
        });
    }
});

<template>
    <DxSwitch ...
        :validation-status="validationStatus"
        :validation-errors="validationErrors"
    />
</template>

<script>
    // ...
    export default {
        // ...
        data() {
            return {
                validationStatus: "valid",
                validationErrors: []
            }
        },
        methods: {
            setInvalidStatus(message) {
                this.validationStatus = "invalid";
                this.validationErrors = [{ message: message }];
            }
        }
    }
</script>

import React, { useState } from 'react';
// ...

function App() {
    const [validationStatus, setValidationStatus] = useState("valid");
    const [validationErrors, setValidationErrors] = useState([]);

    const setInvalidStatus = message => {
        setValidationStatus("invalid");
        setValidationErrors([{ message: message }]);
    }

    return (
        <Switch
            validationStatus={validationStatus}
            validationErrors={validationErrors}
        />
    ); 

};
export default App;