Cleaning data casting the values and keys to the proper type while keeping
the rest of properties on the data
@param  {StepChartData} originalData Data as provided on the container
@private
516233
function cleanData(originalData) {
            return originalData.reduce((acc, d) => {
                d.value = +d[valueLabel];
                d.key = String(d[nameLabel]);

                return [...acc, d];
            }, []);
        }
695809
function primitive (data) {
    var type;

    switch (data) {
      case null:
      case undefined:
      case false:
      case true:
        return true;
    }

    type = typeof data;
    return type === 'string' || type === 'number' || (haveSymbols && type === 'symbol');
  }
326664
function fixdata(data) {
		var o = '',
			l = 0,
			w = 10240;
		for (; l < data.byteLength / w; ++l)
			o += String.fromCharCode.apply(null, new Uint8Array(data.slice(l * w, l * w + w)));
		o += String.fromCharCode.apply(null, new Uint8Array(data.slice(l * w)));
		return o;
	}
489492
function setOriginalAttributeData( $originalData )
    {
        $this->ContentObjectAttributeData['DataTypeCustom']['original_data'] = $originalData;

        $domTree = $this->domTree();
        $imageOriginalArray = $domTree->getElementsByTagName( "original" );
        if ( $imageOriginalArray->length > 0 )
        {
            $imageOriginalNode = $imageOriginalArray->item( 0 );
            $this->createOriginalAttributeXMLData( $imageOriginalNode, $originalData );
        }
    }
810535
private Object correctDataType(Object value, String dataType) {
		if(value == null ){return null;}
		return value;
	}
58761
function transform( data ) {
	var rows = data.rows;
	var out;
	var i;
	out = new Array( rows.length );
	for ( i = 0; i < rows.length; i++ ) {
		out[ i ] = rows[ i ].key[ 1 ];
	}
	return out;
}
399814
function (oldData) {
    // Nothing changed
    if (AFRAME.utils.deepEqual(oldData, this.data)) {
      return;
    }

    if (oldData.pxToWorldRatio !== this.data.pxToWorldRatio) {
      const geomComponent = this.el.components.geometry;
      const width = geomComponent.data.width * this.data.pxToWorldRatio;
      const height = geomComponent.data.height * this.data.pxToWorldRatio;
      setDimensions(this._canvasContainerId, this.el, width, height);
    }

    // Everything after this requires a map instance
    if (!this._mapInstance) {
      return;
    }

    if (oldData.style !== this.data.style) {
      const style = processStyle(this.data.style);
      this._mapInstance.setStyle(style);
    }

    if (oldData.minZoom !== this.data.minZoom) {
      this._mapInstance.setMinZoom(this.data.minZoom);
    }

    if (oldData.maxZoom !== this.data.maxZoom) {
      this._mapInstance.setmaxZoom(this.data.maxZoom);
    }

    if (oldData.maxBounds !== this.data.maxBounds) {
      this._mapInstance.setmaxBounds(this.data.maxBounds);
    }

    const jumpOptions = {};

    if (oldData.zoom !== this.data.zoom) {
      jumpOptions.zoom = this.data.zoom;
      // we also need to set the center otherwise the mapbox library goes crazy
      jumpOptions.center = this.data.center || oldData.center;
    }

    if (!AFRAME.utils.deepEqual(oldData.center, this.data.center)) {
      jumpOptions.center = this.data.center;
    }

    if (oldData.bearing !== this.data.bearing) {
      jumpOptions.bearing = this.data.bearing;
    }

    if (oldData.pitch !== this.data.pitch) {
      jumpOptions.pitch = this.data.pitch;
    }

    if (Object.keys(jumpOptions).length > 0) {
      // A way to signal when these async actions have completed
      this._mapInstance.once('moveend', _ => {
        this.el.emit(MAP_MOVE_END_EVENT);
      });
      this._mapInstance.jumpTo(jumpOptions); // moveend
    }
  }
952289
function(new_data, original_data) {
        var key;
        for (key in new_data) {
            if (new_data[key].constructor === Object) {
                original_data[key] = this._recursive_extend(
                    new_data[key],
                    original_data[key]
                );
            } else {
                original_data[key] = new_data[key];
            }
        }
        return original_data;
    }
1184183
function redataComponent(boundRedata, OriginalComponent) {
    var WrapperComponent = function (_PureComponent) {
        _inherits(WrapperComponent, _PureComponent);

        function WrapperComponent(props) {
            _classCallCheck(this, WrapperComponent);

            // Initialise state with undefined data and WrappedComponent state.
            var _this = _possibleConstructorReturn(this, (WrapperComponent.__proto__ || Object.getPrototypeOf(WrapperComponent)).call(this, props));

            var originalComponentState = {
                state: undefined,
                nextState: undefined
            };

            _this.state = {
                data: undefined,
                originalComponentState: originalComponentState
            };

            _this._handleOnRedataUpdate = _this._handleOnRedataUpdate.bind(_this);
            _this._handleOnOriginalComponentStateUpdate = _this._handleOnOriginalComponentStateUpdate.bind(_this);

            // If it's in the browser, check if there is data coming from server side rendering.
            var serverData = _this._loadFromServerRender();

            // Finalise configuration of our redata, and provide it publicly, so that it can be called directly in Server Side Rendering.
            _this.redata = boundRedata(serverData);

            // If nothing came from server, redata.
            serverData === undefined && _this.redata({
                props: {},
                nextProps: props,
                state: originalComponentState.state,
                nextState: originalComponentState.nextState,
                data: serverData
            }, _this._handleOnRedataUpdate);
            return _this;
        }

        _createClass(WrapperComponent, [{
            key: 'componentDidMount',
            value: function componentDidMount() {
                this._isMounted = true;
            }
        }, {
            key: 'componentWillUpdate',
            value: function componentWillUpdate(nextProps) {
                // console.log('WrapperComponent::componentWillUpdate');
                var _state$originalCompon = this.state.originalComponentState,
                    state = _state$originalCompon.state,
                    nextState = _state$originalCompon.nextState;

                // Flow params into redata.

                this.redata({ props: this.props, nextProps: nextProps, state: state, nextState: nextState, data: this.state.data }, this._handleOnRedataUpdate);

                // If OriginalComponent state is changing, store nextState in state.
                state !== nextState && this._safeSetState({
                    originalComponentState: {
                        state: nextState,
                        nextState: nextState
                    }
                });
            }
        }, {
            key: 'render',
            value: function render() {
                // Render extended passing the received props and the spreaded data.
                return _react2.default.createElement(ExtendedComponent, _extends({}, this.props, this.state.data, {
                    onRedataOriginalComponentStateUpdate: this._handleOnOriginalComponentStateUpdate }));
            }
        }, {
            key: '_safeSetState',
            value: function _safeSetState(state) {
                if (this._isMounted) {
                    this.setState(state);
                } else {
                    this.state = _extends({}, this.state, state);
                }
            }
        }, {
            key: '_loadFromServerRender',
            value: function _loadFromServerRender() {
                // If data was already available from server.
                if (typeof window !== 'undefined' && window.__redata && window.__redata.store) {
                    return window.__redata.store[this._componentUniqueId()];
                }

                return undefined;
            }
        }, {
            key: '_componentUniqueId',
            value: function _componentUniqueId() {
                // TODO: investigate how to consistently generate this
                return 'foo';
            }
        }, {
            key: '_handleOnRedataUpdate',
            value: function _handleOnRedataUpdate(data) {
                console.log('_handleOnRedataUpdate', data);

                this._safeSetState({ data: data });
            }
        }, {
            key: '_handleOnOriginalComponentStateUpdate',
            value: function _handleOnOriginalComponentStateUpdate(state, nextState) {
                this._safeSetState({
                    originalComponentState: { state: state, nextState: nextState }
                });
            }
        }]);

        return WrapperComponent;
    }(_react.PureComponent);

    WrapperComponent.displayName = 'Redata(' + getDisplayName(OriginalComponent) + ')';

    // Extend the OriginalComponent, so we get access to lifecycle methods and, consequently, the state changes.

    var ExtendedComponent = function (_OriginalComponent) {
        _inherits(ExtendedComponent, _OriginalComponent);

        function ExtendedComponent() {
            _classCallCheck(this, ExtendedComponent);

            return _possibleConstructorReturn(this, (ExtendedComponent.__proto__ || Object.getPrototypeOf(ExtendedComponent)).apply(this, arguments));
        }

        _createClass(ExtendedComponent, [{
            key: 'componentWillUpdate',
            value: function componentWillUpdate(nextProps, nextState) {
                console.log('ExtendedComponent::componentWillUpdate. Will redata?', !(0, _shallowequal2.default)(this.state, nextState));

                // If OriginalComponent has a componentWillUpdate method, call it first.
                _get(ExtendedComponent.prototype.__proto__ || Object.getPrototypeOf(ExtendedComponent.prototype), 'componentWillUpdate', this) && _get(ExtendedComponent.prototype.__proto__ || Object.getPrototypeOf(ExtendedComponent.prototype), 'componentWillUpdate', this).call(this, nextProps, nextState);

                // If state changed, inform onRedataOriginalComponentStateUpdate.
                !(0, _shallowequal2.default)(this.state, nextState) && this.props.onRedataOriginalComponentStateUpdate(this.state, nextState);
            }
        }]);

        return ExtendedComponent;
    }(OriginalComponent);

    ExtendedComponent.propTypes = {
        // Using a hard to collide prop, which is used to hook into state updates of the OriginalComponent.
        onRedataOriginalComponentStateUpdate: _react.PropTypes.func.isRequired
    };

    return WrapperComponent;
}
587586
function() {
    // Normalize to array
    var originalValues = lang.isArray(this.value) ? this.value : [this.value];
    
    // Match checks to value
    for(var i=0, j=this.checkboxes.length; i<j; i++) {
        this.checkboxes[i].checked = false;
        for(var k=0, len=originalValues.length; k<len; k++) {
            if(this.checkboxes[i].value === originalValues[k]) {
                this.checkboxes[i].checked = true;
            }
        }
    }
}
493049
function (data) {
    data = data || {};

    this.category = data.hasOwnProperty('category') ? data.category : 'No category';
    this.id = data.hasOwnProperty('id') ? data.id : '';
    this.group = data.hasOwnProperty('group') ? data.group : '';
    this.lines = data.hasOwnProperty('lines') ? data.lines : 0;
    this.name = data.hasOwnProperty('name') ? data.name : '';
    this.options = data.hasOwnProperty('options') ? data.options : {};
    this.origin = data.hasOwnProperty('origin') ? data.origin : '';
    this.resources = data.hasOwnProperty('resources') ? data.resources : Object.assign({}, getDefaultOptions().resources);
    this.usage = data.hasOwnProperty('usage') ? data.usage : [];
    this.viewId = data.hasOwnProperty('viewId') ? data.viewId : '';
}
1014966
function DefaultData(projectConfig) {
	var defaultData = require(path.resolve(projectConfig.paths.src.views.data, '_default.json'));

	return {
		apply: function apply(data) {
			return merge.recursive(defaultData, data);
		}
	};
}
654318
def clean_data(input_value):

    ''' 
    '''

# pass normal json/yaml datatypes
    if input_value.__class__.__name__ in ['bool', 'str', 'float', 'int', 'NoneType']:
        pass

# transform byte data to base64 encoded string
    elif isinstance(input_value, bytes):
        from base64 import b64encode
        input_value = b64encode(input_value).decode()

# convert tuples and sets into lists
    elif isinstance(input_value, tuple) or isinstance(input_value, set):
        new_list = []
        new_list.extend(input_value)
        input_value = transform_data(clean_data, new_list)

# recurse through dictionaries and lists
    elif isinstance(input_value, dict) or isinstance(input_value, list):
        input_value = transform_data(clean_data, input_value)

# convert to string all python objects and callables
    else:
        input_value = str(input_value)

    return input_value
518479
function normalizeStyleData (data: VNodeData): ?Object {
  const style = normalizeStyleBinding(data.style)
  // static style is pre-processed into an object during compilation
  // and is always a fresh object, so it's safe to merge into it
  return data.staticStyle
    ? extend(data.staticStyle, style)
    : style
}
306635
function (rawData) {
    var oldData = this.data;
    if (!Object.keys(schema).length) { return; }
    this.buildData(rawData);
    this.update(oldData);
  }
550486
function camelCaseData(data) {
  const result = {};
  const keys = Object.keys(data);
  keys.forEach((k) => {
    const key = camelCase(k);
    const value = data[k];
    if (isObject(value)) {
      result[key] = camelCaseData(value);
    } else {
      result[key] = value;
    }
  });
  return result;
}
249347
function(oldData){

            var object3D = this.el.object3D.children[0];
            var data = this.data;

            if(data.eye === "both"){
              object3D.layers.set(0);
            }
            else{
              object3D.layers.set(data.eye === 'left' ? 1:2);
            }

       }