@nativescript/core 8.9.0-napi-es5.0 → 8.9.0-napi.1

package/ui/core/bindable/index.js

@@ -8,29 +8,29 @@ import { Trace } from '../../../trace';
 import { parseExpression, convertExpressionToValue } from './bindable-expressions';
 import * as types from '../../../utils/types';
 import * as bindableResources from './bindable-resources';
-var contextKey = 'context';
+const contextKey = 'context';
 // this regex is used to get parameters inside [] for example:
 // from $parents['ListView'] will return 'ListView'
 // from $parents[1] will return 1
-var paramsRegex = /\[\s*(['"])*(\w*)\1\s*\]/;
-var bc = bindingConstants;
-var emptyArray = [];
-var propertiesCache = {};
+const paramsRegex = /\[\s*(['"])*(\w*)\1\s*\]/;
+const bc = bindingConstants;
+const emptyArray = [];
+const propertiesCache = {};
 function getProperties(property) {
     if (!property) {
         return emptyArray;
     }
-    var result = propertiesCache[property];
+    let result = propertiesCache[property];
     if (result) {
         return result;
     }
     // first replace all '$parents[..]' with a safe string
     // second removes all ] since they are not important for property access and not needed
     // then split properties either on '.' or '['
-    var parentsMatches = property.match(parentsRegex);
+    const parentsMatches = property.match(parentsRegex);
     result = property.replace(parentsRegex, 'parentsMatch').replace(/\]/g, '').split(/\.|\[/);
-    var parentsMatchesCounter = 0;
-    for (var i = 0, resultLength = result.length; i < resultLength; i++) {
+    let parentsMatchesCounter = 0;
+    for (let i = 0, resultLength = result.length; i < resultLength; i++) {
         if (result[i] === 'parentsMatch') {
             result[i] = parentsMatches[parentsMatchesCounter++];
         }
@@ -60,7 +60,7 @@ export function isGesture(eventOrGestureName) {
     // this is used exclusively by the XML flavour, and my best guess is that
     // maybe it's to handle how getEventOrGestureName("onTap") might pass "Tap"
     // into this.
-    var t = eventOrGestureName.trim().toLowerCase();
+    const t = eventOrGestureName.trim().toLowerCase();
     // Would be nice to have a convenience function for getting all GestureState
     // names in `gestures-common.ts`, but when I tried introducing it, it created
     // a circular dependency that crashed the automated tests app.
@@ -70,44 +70,43 @@ export function isGesture(eventOrGestureName) {
 // in controls. They will just override this one and provide their own event support.
 export function isEventOrGesture(name, view) {
     if (typeof name === 'string') {
-        var eventOrGestureName = getEventOrGestureName(name);
-        var evt = "".concat(eventOrGestureName, "Event");
+        const eventOrGestureName = getEventOrGestureName(name);
+        const evt = `${eventOrGestureName}Event`;
         return (view.constructor && evt in view.constructor) || isGesture(eventOrGestureName);
     }
     return false;
 }
-var Binding = /** @class */ (function () {
-    function Binding(target, options) {
+export class Binding {
+    constructor(target, options) {
         this.propertyChangeListeners = new Map();
         this.target = new WeakRef(target);
         this.options = options;
         this.sourceProperties = getProperties(options.sourceProperty);
         this.targetOptions = this.resolveOptions(target, getProperties(options.targetProperty));
         if (!this.targetOptions) {
-            throw new Error("Invalid property: ".concat(options.targetProperty, " for target: ").concat(target));
+            throw new Error(`Invalid property: ${options.targetProperty} for target: ${target}`);
         }
         if (options.twoWay) {
-            var target_1 = this.targetOptions.instance.get();
-            if (target_1 instanceof Observable) {
-                target_1.on("".concat(this.targetOptions.property, "Change"), this.onTargetPropertyChanged, this);
+            const target = this.targetOptions.instance.get();
+            if (target instanceof Observable) {
+                target.on(`${this.targetOptions.property}Change`, this.onTargetPropertyChanged, this);
             }
         }
     }
-    Binding.prototype.onTargetPropertyChanged = function (data) {
+    onTargetPropertyChanged(data) {
         this.updateTwoWay(data.value);
-    };
-    Binding.prototype.loadedHandlerVisualTreeBinding = function (args) {
-        var target = args.object;
+    }
+    loadedHandlerVisualTreeBinding(args) {
+        const target = args.object;
         target.off('loaded', this.loadedHandlerVisualTreeBinding, this);
-        var context = target.bindingContext;
+        const context = target.bindingContext;
         if (context !== undefined && context !== null) {
             this.update(context);
         }
-    };
-    Binding.prototype.clearSource = function () {
-        var _this = this;
-        this.propertyChangeListeners.forEach(function (observable, index, map) {
-            removeWeakEventListener(observable, Observable.propertyChangeEvent, _this.onSourcePropertyChanged, _this);
+    }
+    clearSource() {
+        this.propertyChangeListeners.forEach((observable, index, map) => {
+            removeWeakEventListener(observable, Observable.propertyChangeEvent, this.onSourcePropertyChanged, this);
         });
         this.propertyChangeListeners.clear();
         // if (this.source) {
@@ -117,10 +116,10 @@ var Binding = /** @class */ (function () {
             this.sourceOptions.instance = undefined;
             this.sourceOptions = undefined;
         }
-    };
-    Binding.prototype.sourceAsObject = function (source) {
+    }
+    sourceAsObject(source) {
         /* tslint:disable */
-        var objectType = typeof source;
+        const objectType = typeof source;
         if (objectType === 'number') {
             source = new Number(source);
         }
@@ -132,14 +131,14 @@ var Binding = /** @class */ (function () {
         }
         /* tslint:enable */
         return source;
-    };
-    Binding.prototype.bindingContextChanged = function (data) {
-        var target = this.targetOptions.instance.get();
+    }
+    bindingContextChanged(data) {
+        const target = this.targetOptions.instance.get();
         if (!target) {
             this.unbind();
             return;
         }
-        var value = data.value;
+        const value = data.value;
         if (value !== null && value !== undefined) {
             this.update(value);
         }
@@ -149,36 +148,36 @@ var Binding = /** @class */ (function () {
             this.clearBinding();
         }
         // TODO: if oneWay - call target.unbind();
-    };
-    Binding.prototype.bind = function (source) {
-        var target = this.targetOptions.instance.get();
+    }
+    bind(source) {
+        const target = this.targetOptions.instance.get();
         if (this.sourceIsBindingContext && target instanceof Observable && this.targetOptions.property !== 'bindingContext') {
             target.on('bindingContextChange', this.bindingContextChanged, this);
         }
         this.update(source);
-    };
-    Binding.prototype.update = function (source) {
+    }
+    update(source) {
         this.clearSource();
         source = this.sourceAsObject(source);
         if (!types.isNullOrUndefined(source)) {
             // TODO: if oneWay - call target.unbind();
             this.source = new WeakRef(source);
             this.sourceOptions = this.resolveOptions(source, this.sourceProperties);
-            var sourceValue = this.getSourcePropertyValue();
+            const sourceValue = this.getSourcePropertyValue();
             this.updateTarget(sourceValue);
             this.addPropertyChangeListeners(this.source, this.sourceProperties);
         }
         else if (!this.sourceIsBindingContext) {
             // TODO: if oneWay - call target.unbind();
-            var sourceValue = this.getSourcePropertyValue();
+            const sourceValue = this.getSourcePropertyValue();
             this.updateTarget(sourceValue ? sourceValue : source);
         }
-    };
-    Binding.prototype.unbind = function () {
-        var target = this.targetOptions.instance.get();
+    }
+    unbind() {
+        const target = this.targetOptions.instance.get();
         if (target instanceof Observable) {
             if (this.options.twoWay) {
-                target.off("".concat(this.targetOptions.property, "Change"), this.onTargetPropertyChanged, this);
+                target.off(`${this.targetOptions.property}Change`, this.onTargetPropertyChanged, this);
             }
             if (this.sourceIsBindingContext && this.targetOptions.property !== 'bindingContext') {
                 target.off('bindingContextChange', this.bindingContextChanged, this);
@@ -192,24 +191,24 @@ var Binding = /** @class */ (function () {
             return;
         }
         this.clearSource();
-    };
+    }
     // Consider returning single {} instead of array for performance.
-    Binding.prototype.resolveObjectsAndProperties = function (source, properties) {
-        var result = [];
-        var currentObject = source;
-        var currentObjectChanged = false;
-        for (var i = 0, propsArrayLength = properties.length; i < propsArrayLength; i++) {
-            var property = properties[i];
+    resolveObjectsAndProperties(source, properties) {
+        const result = [];
+        let currentObject = source;
+        let currentObjectChanged = false;
+        for (let i = 0, propsArrayLength = properties.length; i < propsArrayLength; i++) {
+            const property = properties[i];
             if (property === bc.bindingValueKey) {
                 currentObjectChanged = true;
             }
             if (property === bc.parentValueKey || property.indexOf(bc.parentsValueKey) === 0) {
-                var parentView = this.getParentView(this.target.get(), property).view;
+                const parentView = this.getParentView(this.target.get(), property).view;
                 if (parentView) {
                     currentObject = parentView.bindingContext;
                 }
                 else {
-                    var targetInstance = this.target.get();
+                    const targetInstance = this.target.get();
                     targetInstance.off('loaded', this.loadedHandlerVisualTreeBinding, this);
                     targetInstance.on('loaded', this.loadedHandlerVisualTreeBinding, this);
                 }
@@ -228,17 +227,17 @@ var Binding = /** @class */ (function () {
             currentObjectChanged = false;
         }
         return result;
-    };
-    Binding.prototype.addPropertyChangeListeners = function (source, sourceProperty, parentProperies) {
-        var objectsAndProperties = this.resolveObjectsAndProperties(source.get(), sourceProperty);
-        var prop = parentProperies || '';
-        for (var i = 0, length_1 = objectsAndProperties.length; i < length_1; i++) {
-            var propName = objectsAndProperties[i].property;
+    }
+    addPropertyChangeListeners(source, sourceProperty, parentProperies) {
+        const objectsAndProperties = this.resolveObjectsAndProperties(source.get(), sourceProperty);
+        let prop = parentProperies || '';
+        for (let i = 0, length = objectsAndProperties.length; i < length; i++) {
+            const propName = objectsAndProperties[i].property;
             prop += '$' + propName;
-            var currentObject = objectsAndProperties[i].instance;
+            const currentObject = objectsAndProperties[i].instance;
             if (!this.propertyChangeListeners.has(prop) && currentObject instanceof Observable && currentObject._isViewBase) {
                 // Add listener for properties created with after 3.0 version
-                addWeakEventListener(currentObject, "".concat(propName, "Change"), this.onSourcePropertyChanged, this);
+                addWeakEventListener(currentObject, `${propName}Change`, this.onSourcePropertyChanged, this);
                 addWeakEventListener(currentObject, Observable.propertyChangeEvent, this.onSourcePropertyChanged, this);
                 this.propertyChangeListeners.set(prop, currentObject);
             }
@@ -247,37 +246,37 @@ var Binding = /** @class */ (function () {
                 this.propertyChangeListeners.set(prop, currentObject);
             }
         }
-    };
-    Binding.prototype.prepareExpressionForUpdate = function () {
+    }
+    prepareExpressionForUpdate() {
         // this regex is used to create a valid RegExp object from a string that has some special regex symbols like [,(,$ and so on.
         // Basically this method replaces all matches of 'source property' in expression with '$newPropertyValue'.
         // For example: with an expression similar to:
         // text="{{ sourceProperty = $parents['ListView'].test, expression = $parents['ListView'].test + 2}}"
         // update expression will be '$newPropertyValue + 2'
         // then on expression execution the new value will be taken and target property will be updated with the value of the expression.
-        var escapedSourceProperty = escapeRegexSymbols(this.options.sourceProperty);
-        var expRegex = new RegExp(escapedSourceProperty, 'g');
-        var resultExp = this.options.expression.replace(expRegex, bc.newPropertyValueKey);
+        const escapedSourceProperty = escapeRegexSymbols(this.options.sourceProperty);
+        const expRegex = new RegExp(escapedSourceProperty, 'g');
+        const resultExp = this.options.expression.replace(expRegex, bc.newPropertyValueKey);
         return resultExp;
-    };
-    Binding.prototype.updateTwoWay = function (value) {
+    }
+    updateTwoWay(value) {
         if (this.updating || !this.options.twoWay) {
             return;
         }
-        var newValue = value;
+        let newValue = value;
         if (__UI_USE_EXTERNAL_RENDERER__) {
         }
         else if (this.options.expression) {
-            var changedModel = {};
-            var targetInstance = this.target.get();
-            var sourcePropertyName = '';
+            const changedModel = {};
+            const targetInstance = this.target.get();
+            let sourcePropertyName = '';
             if (this.sourceOptions) {
                 sourcePropertyName = this.sourceOptions.property;
             }
             else if (typeof this.options.sourceProperty === 'string' && this.options.sourceProperty.indexOf('.') === -1) {
                 sourcePropertyName = this.options.sourceProperty;
             }
-            var updateExpression = this.prepareExpressionForUpdate();
+            const updateExpression = this.prepareExpressionForUpdate();
             this.prepareContextForExpression(targetInstance, changedModel, updateExpression);
             /**
              * Wait for 'prepareContextForExpression' to assign keys first and override any possible occurences.
@@ -288,22 +287,22 @@ var Binding = /** @class */ (function () {
             if (sourcePropertyName !== '') {
                 changedModel[sourcePropertyName] = value;
             }
-            var expressionValue = this._getExpressionValue(updateExpression, true, changedModel);
+            const expressionValue = this._getExpressionValue(updateExpression, true, changedModel);
             if (expressionValue instanceof Error) {
                 Trace.write(expressionValue.message, Trace.categories.Binding, Trace.messageType.error);
             }
             newValue = expressionValue;
         }
         this.updateSource(newValue);
-    };
-    Binding.prototype._getExpressionValue = function (expression, isBackConvert, changedModel) {
-        var result = null;
+    }
+    _getExpressionValue(expression, isBackConvert, changedModel) {
+        let result = null;
         if (!__UI_USE_EXTERNAL_RENDERER__) {
-            var context = void 0;
-            var targetInstance = this.target.get();
-            var addedProps = [];
+            let context;
+            const targetInstance = this.target.get();
+            const addedProps = [];
             try {
-                var exp = void 0;
+                let exp;
                 try {
                     exp = parseExpression(expression);
                 }
@@ -312,8 +311,8 @@ var Binding = /** @class */ (function () {
                 }
                 if (exp) {
                     context = (this.source && this.source.get && this.source.get()) || global;
-                    var resources = bindableResources.get();
-                    for (var prop in resources) {
+                    const resources = bindableResources.get();
+                    for (const prop in resources) {
                         if (resources.hasOwnProperty(prop) && !context.hasOwnProperty(prop)) {
                             context[prop] = resources[prop];
                             addedProps.push(prop);
@@ -333,19 +332,18 @@ var Binding = /** @class */ (function () {
                 result = new Error(e + ' at ' + targetInstance);
             }
             // Clear added props
-            for (var _i = 0, addedProps_1 = addedProps; _i < addedProps_1.length; _i++) {
-                var prop = addedProps_1[_i];
+            for (const prop of addedProps) {
                 delete context[prop];
             }
             addedProps.length = 0;
         }
         return result;
-    };
-    Binding.prototype.onSourcePropertyChanged = function (data) {
-        var sourceProps = this.sourceProperties;
-        var sourcePropsLength = sourceProps.length;
-        var changedPropertyIndex = sourceProps.indexOf(data.propertyName);
-        var parentProps = '';
+    }
+    onSourcePropertyChanged(data) {
+        const sourceProps = this.sourceProperties;
+        const sourcePropsLength = sourceProps.length;
+        let changedPropertyIndex = sourceProps.indexOf(data.propertyName);
+        let parentProps = '';
         if (changedPropertyIndex > -1) {
             parentProps = '$' + sourceProps.slice(0, changedPropertyIndex + 1).join('$');
             while (this.propertyChangeListeners.get(parentProps) !== data.object) {
@@ -355,11 +353,11 @@ var Binding = /** @class */ (function () {
         }
         if (__UI_USE_EXTERNAL_RENDERER__ || !this.options.expression) {
             if (changedPropertyIndex > -1) {
-                var props = sourceProps.slice(changedPropertyIndex + 1);
-                var propsLength = props.length;
+                const props = sourceProps.slice(changedPropertyIndex + 1);
+                const propsLength = props.length;
                 if (propsLength > 0) {
-                    var value = data.value;
-                    for (var i = 0; i < propsLength; i++) {
+                    let value = data.value;
+                    for (let i = 0; i < propsLength; i++) {
                         value = value[props[i]];
                     }
                     this.updateTarget(value);
@@ -370,7 +368,7 @@ var Binding = /** @class */ (function () {
             }
         }
         else {
-            var expressionValue = this._getExpressionValue(this.options.expression, false, undefined);
+            const expressionValue = this._getExpressionValue(this.options.expression, false, undefined);
             if (expressionValue instanceof Error) {
                 Trace.write(expressionValue.message, Trace.categories.Binding, Trace.messageType.error);
             }
@@ -380,39 +378,38 @@ var Binding = /** @class */ (function () {
         }
         // we need to do this only if nested objects are used as source and some middle object has changed.
         if (changedPropertyIndex > -1 && changedPropertyIndex < sourcePropsLength - 1) {
-            var probablyChangedObject = this.propertyChangeListeners.get(parentProps);
+            const probablyChangedObject = this.propertyChangeListeners.get(parentProps);
             if (probablyChangedObject && probablyChangedObject !== data.object[sourceProps[changedPropertyIndex]]) {
                 // remove all weakevent listeners after change, because changed object replaces object that is hooked for
                 // propertyChange event
-                for (var i = sourcePropsLength - 1; i > changedPropertyIndex; i--) {
-                    var prop = '$' + sourceProps.slice(0, i + 1).join('$');
+                for (let i = sourcePropsLength - 1; i > changedPropertyIndex; i--) {
+                    const prop = '$' + sourceProps.slice(0, i + 1).join('$');
                     if (this.propertyChangeListeners.has(prop)) {
                         removeWeakEventListener(this.propertyChangeListeners.get(prop), Observable.propertyChangeEvent, this.onSourcePropertyChanged, this);
                         this.propertyChangeListeners.delete(prop);
                     }
                 }
-                var newProps = sourceProps.slice(changedPropertyIndex + 1);
+                const newProps = sourceProps.slice(changedPropertyIndex + 1);
                 // add new weak event listeners
-                var newObject = data.object[sourceProps[changedPropertyIndex]];
+                const newObject = data.object[sourceProps[changedPropertyIndex]];
                 if (!types.isNullOrUndefined(newObject) && typeof newObject === 'object') {
                     this.addPropertyChangeListeners(new WeakRef(newObject), newProps, parentProps);
                 }
             }
         }
-    };
-    Binding.prototype.prepareContextForExpression = function (target, model, expression, addedProps) {
-        if (addedProps === void 0) { addedProps = []; }
-        var success = true;
-        var parentViewAndIndex;
-        var parentView;
-        var expressionCP = expression;
+    }
+    prepareContextForExpression(target, model, expression, addedProps = []) {
+        let success = true;
+        let parentViewAndIndex;
+        let parentView;
+        let expressionCP = expression;
         if (expressionCP.indexOf(bc.bindingValueKey) > -1) {
             model[bc.bindingValueKey] = model;
             addedProps.push(bc.bindingValueKey);
         }
-        var parentsArray = expressionCP.match(parentsRegex);
+        const parentsArray = expressionCP.match(parentsRegex);
         if (parentsArray) {
-            for (var i = 0; i < parentsArray.length; i++) {
+            for (let i = 0; i < parentsArray.length; i++) {
                 // This prevents later checks to mistake $parents[] for $parent
                 expressionCP = expressionCP.replace(parentsArray[i], '');
                 parentViewAndIndex = this.getParentView(target, parentsArray[i]);
@@ -437,14 +434,14 @@ var Binding = /** @class */ (function () {
             }
         }
         return success;
-    };
-    Binding.prototype.getSourcePropertyValue = function () {
+    }
+    getSourcePropertyValue() {
         if (__UI_USE_EXTERNAL_RENDERER__) {
         }
         else if (this.options.expression) {
-            var changedModel = {};
+            const changedModel = {};
             changedModel[bc.bindingValueKey] = this.source ? this.source.get() : undefined;
-            var expressionValue = this._getExpressionValue(this.options.expression, false, changedModel);
+            const expressionValue = this._getExpressionValue(this.options.expression, false, changedModel);
             if (expressionValue instanceof Error) {
                 Trace.write(expressionValue.message, Trace.categories.Binding, Trace.messageType.error);
             }
@@ -453,7 +450,7 @@ var Binding = /** @class */ (function () {
             }
         }
         if (this.sourceOptions) {
-            var sourceOptionsInstance = this.sourceOptions.instance.get();
+            const sourceOptionsInstance = this.sourceOptions.instance.get();
             if (this.sourceOptions.property === bc.bindingValueKey) {
                 return sourceOptionsInstance;
             }
@@ -468,40 +465,40 @@ var Binding = /** @class */ (function () {
             }
         }
         return null;
-    };
-    Binding.prototype.clearBinding = function () {
+    }
+    clearBinding() {
         this.clearSource();
         this.updateTarget(unsetValue);
-    };
-    Binding.prototype.updateTarget = function (value) {
+    }
+    updateTarget(value) {
         if (this.updating) {
             return;
         }
         this.updateOptions(this.targetOptions, types.isNullOrUndefined(value) ? unsetValue : value);
-    };
-    Binding.prototype.updateSource = function (value) {
+    }
+    updateSource(value) {
         if (this.updating || !this.source || !this.source.get()) {
             return;
         }
         this.updateOptions(this.sourceOptions, value);
-    };
-    Binding.prototype.getParentView = function (target, property) {
+    }
+    getParentView(target, property) {
         if (!target) {
             return { view: null, index: null };
         }
-        var result;
+        let result;
         if (property === bc.parentValueKey) {
             result = target.parent;
         }
-        var index = null;
+        let index = null;
         if (property.indexOf(bc.parentsValueKey) === 0) {
             result = target.parent;
-            var indexParams = paramsRegex.exec(property);
+            const indexParams = paramsRegex.exec(property);
             if (indexParams && indexParams.length > 1) {
                 index = indexParams[2];
             }
             if (!isNaN(index)) {
-                var indexAsInt = parseInt(index);
+                let indexAsInt = parseInt(index);
                 while (indexAsInt > 0) {
                     result = result.parent;
                     indexAsInt--;
@@ -514,21 +511,21 @@ var Binding = /** @class */ (function () {
             }
         }
         return { view: result, index: index };
-    };
-    Binding.prototype.resolveOptions = function (obj, properties) {
-        var objectsAndProperties = this.resolveObjectsAndProperties(obj, properties);
+    }
+    resolveOptions(obj, properties) {
+        const objectsAndProperties = this.resolveObjectsAndProperties(obj, properties);
         if (objectsAndProperties.length > 0) {
-            var resolvedObj = objectsAndProperties[objectsAndProperties.length - 1].instance;
-            var prop = objectsAndProperties[objectsAndProperties.length - 1].property;
+            const resolvedObj = objectsAndProperties[objectsAndProperties.length - 1].instance;
+            const prop = objectsAndProperties[objectsAndProperties.length - 1].property;
             return {
                 instance: new WeakRef(this.sourceAsObject(resolvedObj)),
                 property: prop,
             };
         }
         return null;
-    };
-    Binding.prototype.updateOptions = function (options, value) {
-        var optionsInstance;
+    }
+    updateOptions(options, value) {
+        let optionsInstance;
         if (options && options.instance) {
             optionsInstance = options.instance.get();
         }
@@ -554,8 +551,6 @@ var Binding = /** @class */ (function () {
             Trace.write('Binding error while setting property ' + options.property + ' of ' + optionsInstance + ': ' + ex, Trace.categories.Binding, Trace.messageType.error);
         }
         this.updating = false;
-    };
-    return Binding;
-}());
-export { Binding };
+    }
+}
 //# sourceMappingURL=index.js.map