Fix issue #10 When using an object to modify both the :value and :options props, the options is not always modified before the value

Fix the issue where updating the `options` to new ones with a higher `decimalPlacesRawValue` loses the additional decimal places
Now allows to update the `options` by passing an array of options (with objects and predefined option names)

When the `options` and `value` are both set at the same time, `vue-autonumeric` now always update the `options` first, before setting the `value`.
- This allows to use objects with the value and a predefined option name to modify the vue-autonumeric component.
- Note: There is a know bug yet; if you use multiple `vue-autonumeric` component sharing the same `v-model` but *different* options, changing the value/option *may* not work correctly.
  - This is due to the fact that when vue-autonumeric detects a value change, it `set()` it since it does not come from a user interaction.
  - However if one of the `vue-autonumeric` component has a `decimalPlaces` option set to `2`, and another set to `5`, then the first component will drop the additional decimal places when using `set()`...which in turn will make the other component aware of that new value change, and the second component will then use that new cropped value as well.

Signed-off-by: Alexandre Bonneau <alexandre.bonneau@linuxfr.eu>

Author: AlexandreBonneau

CHANGELOG.md

@@ -1,5 +1,15 @@
 ## Changelog for vue-autoNumeric
 
+### 1.1.0
++ Fix issue #10 When using an object to modify both the `:value` and `:options` props, the options is not always modified before the value
++ Fix the issue where updating the `options` to new ones with a higher `decimalPlacesRawValue` loses the additional decimal places
++ Now allows to update the `options` by passing an array of options (with objects and predefined option names)
++ When the `options` and `value` are both set at the same time, `vue-autonumeric` now always update the `options` first, before setting the `value`.
+  + This allows to use objects with the value and a predefined option name to modify the vue-autonumeric component.
+  + Note: There is a know bug yet; if you use multiple `vue-autonumeric` component sharing the same `v-model` but *different* options, changing the value/option *may* not work correctly.
+    + This is due to the fact that when vue-autonumeric detects a value change, it `set()` it since it does not come from a user interaction.
+    + However if one of the `vue-autonumeric` component has a `decimalPlaces` option set to `2`, and another set to `5`, then the first component will drop the additional decimal places when using `set()`...which in turn will make the other component aware of that new value change, and the second component will then use that new cropped value as well.
+
 ### 1.0.7
 + Fix issue #9 Modifying the `options` will always lose the decimal places precision after `2` places
   + This happens since `resetOnOptions` temporarily resets the configuration to the default one, which set the `decimalPlaces` option to `2`.

dist/vue-autonumeric.js

@@ -1,5 +1,5 @@
 /**
- * vue-autonumeric v1.0.7 (https://github.com/autoNumeric/vue-autoNumeric)
+ * vue-autonumeric v1.1.0 (https://github.com/autoNumeric/vue-autoNumeric)
  * © 2018 Alexandre Bonneau <alexandre.bonneau@linuxfr.eu>
  * Released under the MIT License.
  */
@@ -393,6 +393,15 @@ exports.default = {
     },
 
 
+    computed: {
+        anInfo: function anInfo() {
+            return {
+                value: this.value,
+                options: this.options
+            };
+        }
+    },
+
     methods: {
         updateVModel: function updateVModel(event) {
             if (this.anElement !== null) {
@@ -422,29 +431,40 @@ exports.default = {
     },
 
     watch: {
-        value: function value(newValue, oldValue) {
-            try {
-                if (!this.userInteraction) {
-                    if (newValue !== oldValue) {
-                        this.anElement.set(newValue);
+        anInfo: function anInfo(newValue, oldValue) {
+            if (oldValue.options && (0, _stringify2.default)(newValue.options) !== (0, _stringify2.default)(oldValue.options)) {
+                var optionsToUse = void 0;
+                if (this.resetOnOptions) {
+                    if (Array.isArray(newValue.options)) {
+                        newValue.options = _AutoNumeric2.default.mergeOptions(newValue.options);
                     }
-                }
-            } catch (error) {
-                console.error(error);
-            }
 
-            this.resetUserInteraction();
-        },
-        options: function options(newValue, oldValue) {
-            if ((0, _stringify2.default)(newValue) !== (0, _stringify2.default)(oldValue)) {
-                if (this.resetOnOptions) {
                     var decimalPlacesRawValue = this.anElement.getSettings().decimalPlacesRawValue;
-                    var optionsToReset = (0, _assign2.default)({}, _AutoNumeric2.default.getDefaultConfig(), { decimalPlacesRawValue: decimalPlacesRawValue });
+                    var newOptions = _AutoNumeric2.default._getOptionObject(newValue.options);
+                    if (newOptions.decimalPlaces && newOptions.decimalPlaces > decimalPlacesRawValue) {
+                        optionsToUse = (0, _assign2.default)({}, _AutoNumeric2.default.getDefaultConfig(), newOptions);
+                    } else {
+                        optionsToUse = (0, _assign2.default)({}, _AutoNumeric2.default.getDefaultConfig(), { decimalPlacesRawValue: decimalPlacesRawValue }, newOptions);
+                    }
+                } else {
+                    optionsToUse = newValue.options;
+                }
 
-                    this.anElement.update(optionsToReset);
+                this.anElement.update(optionsToUse);
+            }
+
+            if (newValue.value !== void 0) {
+                try {
+                    if (!this.userInteraction) {
+                        if (newValue.value !== oldValue.value) {
+                            this.anElement.set(newValue.value);
+                        }
+                    }
+                } catch (error) {
+                    console.error(error);
                 }
 
-                this.anElement.update(newValue);
+                this.resetUserInteraction();
             }
         }
     }