@nativescript/core 8.9.0-alpha.2 → 8.9.0-napi-es5.0

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';
-const contextKey = 'context';
+var contextKey = 'context';
 // this regex is used to get parameters inside [] for example:
 // from $parents['ListView'] will return 'ListView'
 // from $parents[1] will return 1
-const paramsRegex = /\[\s*(['"])*(\w*)\1\s*\]/;
-const bc = bindingConstants;
-const emptyArray = [];
-const propertiesCache = {};
+var paramsRegex = /\[\s*(['"])*(\w*)\1\s*\]/;
+var bc = bindingConstants;
+var emptyArray = [];
+var propertiesCache = {};
 function getProperties(property) {
     if (!property) {
         return emptyArray;
     }
-    let result = propertiesCache[property];
+    var 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 '['
-    const parentsMatches = property.match(parentsRegex);
+    var parentsMatches = property.match(parentsRegex);
     result = property.replace(parentsRegex, 'parentsMatch').replace(/\]/g, '').split(/\.|\[/);
-    let parentsMatchesCounter = 0;
-    for (let i = 0, resultLength = result.length; i < resultLength; i++) {
+    var parentsMatchesCounter = 0;
+    for (var 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.
-    const t = eventOrGestureName.trim().toLowerCase();
+    var 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,43 +70,44 @@ 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') {
-        const eventOrGestureName = getEventOrGestureName(name);
-        const evt = `${eventOrGestureName}Event`;
+        var eventOrGestureName = getEventOrGestureName(name);
+        var evt = "".concat(eventOrGestureName, "Event");
         return (view.constructor && evt in view.constructor) || isGesture(eventOrGestureName);
     }
     return false;
 }
-export class Binding {
-    constructor(target, options) {
+var Binding = /** @class */ (function () {
+    function Binding(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: ${options.targetProperty} for target: ${target}`);
+            throw new Error("Invalid property: ".concat(options.targetProperty, " for target: ").concat(target));
         }
         if (options.twoWay) {
-            const target = this.targetOptions.instance.get();
-            if (target instanceof Observable) {
-                target.on(`${this.targetOptions.property}Change`, this.onTargetPropertyChanged, this);
+            var target_1 = this.targetOptions.instance.get();
+            if (target_1 instanceof Observable) {
+                target_1.on("".concat(this.targetOptions.property, "Change"), this.onTargetPropertyChanged, this);
             }
         }
     }
-    onTargetPropertyChanged(data) {
+    Binding.prototype.onTargetPropertyChanged = function (data) {
         this.updateTwoWay(data.value);
-    }
-    loadedHandlerVisualTreeBinding(args) {
-        const target = args.object;
+    };
+    Binding.prototype.loadedHandlerVisualTreeBinding = function (args) {
+        var target = args.object;
         target.off('loaded', this.loadedHandlerVisualTreeBinding, this);
-        const context = target.bindingContext;
+        var context = target.bindingContext;
         if (context !== undefined && context !== null) {
             this.update(context);
         }
-    }
-    clearSource() {
-        this.propertyChangeListeners.forEach((observable, index, map) => {
-            removeWeakEventListener(observable, Observable.propertyChangeEvent, this.onSourcePropertyChanged, this);
+    };
+    Binding.prototype.clearSource = function () {
+        var _this = this;
+        this.propertyChangeListeners.forEach(function (observable, index, map) {
+            removeWeakEventListener(observable, Observable.propertyChangeEvent, _this.onSourcePropertyChanged, _this);
         });
         this.propertyChangeListeners.clear();
         // if (this.source) {
@@ -116,10 +117,10 @@ export class Binding {
             this.sourceOptions.instance = undefined;
             this.sourceOptions = undefined;
         }
-    }
-    sourceAsObject(source) {
+    };
+    Binding.prototype.sourceAsObject = function (source) {
         /* tslint:disable */
-        const objectType = typeof source;
+        var objectType = typeof source;
         if (objectType === 'number') {
             source = new Number(source);
         }
@@ -131,14 +132,14 @@ export class Binding {
         }
         /* tslint:enable */
         return source;
-    }
-    bindingContextChanged(data) {
-        const target = this.targetOptions.instance.get();
+    };
+    Binding.prototype.bindingContextChanged = function (data) {
+        var target = this.targetOptions.instance.get();
         if (!target) {
             this.unbind();
             return;
         }
-        const value = data.value;
+        var value = data.value;
         if (value !== null && value !== undefined) {
             this.update(value);
         }
@@ -148,36 +149,36 @@ export class Binding {
             this.clearBinding();
         }
         // TODO: if oneWay - call target.unbind();
-    }
-    bind(source) {
-        const target = this.targetOptions.instance.get();
+    };
+    Binding.prototype.bind = function (source) {
+        var target = this.targetOptions.instance.get();
         if (this.sourceIsBindingContext && target instanceof Observable && this.targetOptions.property !== 'bindingContext') {
             target.on('bindingContextChange', this.bindingContextChanged, this);
         }
         this.update(source);
-    }
-    update(source) {
+    };
+    Binding.prototype.update = function (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);
-            const sourceValue = this.getSourcePropertyValue();
+            var sourceValue = this.getSourcePropertyValue();
             this.updateTarget(sourceValue);
             this.addPropertyChangeListeners(this.source, this.sourceProperties);
         }
         else if (!this.sourceIsBindingContext) {
             // TODO: if oneWay - call target.unbind();
-            const sourceValue = this.getSourcePropertyValue();
+            var sourceValue = this.getSourcePropertyValue();
             this.updateTarget(sourceValue ? sourceValue : source);
         }
-    }
-    unbind() {
-        const target = this.targetOptions.instance.get();
+    };
+    Binding.prototype.unbind = function () {
+        var target = this.targetOptions.instance.get();
         if (target instanceof Observable) {
             if (this.options.twoWay) {
-                target.off(`${this.targetOptions.property}Change`, this.onTargetPropertyChanged, this);
+                target.off("".concat(this.targetOptions.property, "Change"), this.onTargetPropertyChanged, this);
             }
             if (this.sourceIsBindingContext && this.targetOptions.property !== 'bindingContext') {
                 target.off('bindingContextChange', this.bindingContextChanged, this);
@@ -191,24 +192,24 @@ export class Binding {
             return;
         }
         this.clearSource();
-    }
+    };
     // Consider returning single {} instead of array for performance.
-    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];
+    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];
             if (property === bc.bindingValueKey) {
                 currentObjectChanged = true;
             }
             if (property === bc.parentValueKey || property.indexOf(bc.parentsValueKey) === 0) {
-                const parentView = this.getParentView(this.target.get(), property).view;
+                var parentView = this.getParentView(this.target.get(), property).view;
                 if (parentView) {
                     currentObject = parentView.bindingContext;
                 }
                 else {
-                    const targetInstance = this.target.get();
+                    var targetInstance = this.target.get();
                     targetInstance.off('loaded', this.loadedHandlerVisualTreeBinding, this);
                     targetInstance.on('loaded', this.loadedHandlerVisualTreeBinding, this);
                 }
@@ -227,17 +228,17 @@ export class Binding {
             currentObjectChanged = false;
         }
         return result;
-    }
-    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;
+    };
+    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;
             prop += '$' + propName;
-            const currentObject = objectsAndProperties[i].instance;
+            var 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, `${propName}Change`, this.onSourcePropertyChanged, this);
+                addWeakEventListener(currentObject, "".concat(propName, "Change"), this.onSourcePropertyChanged, this);
                 addWeakEventListener(currentObject, Observable.propertyChangeEvent, this.onSourcePropertyChanged, this);
                 this.propertyChangeListeners.set(prop, currentObject);
             }
@@ -246,37 +247,37 @@ export class Binding {
                 this.propertyChangeListeners.set(prop, currentObject);
             }
         }
-    }
-    prepareExpressionForUpdate() {
+    };
+    Binding.prototype.prepareExpressionForUpdate = function () {
         // 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.
-        const escapedSourceProperty = escapeRegexSymbols(this.options.sourceProperty);
-        const expRegex = new RegExp(escapedSourceProperty, 'g');
-        const resultExp = this.options.expression.replace(expRegex, bc.newPropertyValueKey);
+        var escapedSourceProperty = escapeRegexSymbols(this.options.sourceProperty);
+        var expRegex = new RegExp(escapedSourceProperty, 'g');
+        var resultExp = this.options.expression.replace(expRegex, bc.newPropertyValueKey);
         return resultExp;
-    }
-    updateTwoWay(value) {
+    };
+    Binding.prototype.updateTwoWay = function (value) {
         if (this.updating || !this.options.twoWay) {
             return;
         }
-        let newValue = value;
+        var newValue = value;
         if (__UI_USE_EXTERNAL_RENDERER__) {
         }
         else if (this.options.expression) {
-            const changedModel = {};
-            const targetInstance = this.target.get();
-            let sourcePropertyName = '';
+            var changedModel = {};
+            var targetInstance = this.target.get();
+            var sourcePropertyName = '';
             if (this.sourceOptions) {
                 sourcePropertyName = this.sourceOptions.property;
             }
             else if (typeof this.options.sourceProperty === 'string' && this.options.sourceProperty.indexOf('.') === -1) {
                 sourcePropertyName = this.options.sourceProperty;
             }
-            const updateExpression = this.prepareExpressionForUpdate();
+            var updateExpression = this.prepareExpressionForUpdate();
             this.prepareContextForExpression(targetInstance, changedModel, updateExpression);
             /**
              * Wait for 'prepareContextForExpression' to assign keys first and override any possible occurences.
@@ -287,22 +288,22 @@ export class Binding {
             if (sourcePropertyName !== '') {
                 changedModel[sourcePropertyName] = value;
             }
-            const expressionValue = this._getExpressionValue(updateExpression, true, changedModel);
+            var 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);
-    }
-    _getExpressionValue(expression, isBackConvert, changedModel) {
-        let result = null;
+    };
+    Binding.prototype._getExpressionValue = function (expression, isBackConvert, changedModel) {
+        var result = null;
         if (!__UI_USE_EXTERNAL_RENDERER__) {
-            let context;
-            const targetInstance = this.target.get();
-            const addedProps = [];
+            var context = void 0;
+            var targetInstance = this.target.get();
+            var addedProps = [];
             try {
-                let exp;
+                var exp = void 0;
                 try {
                     exp = parseExpression(expression);
                 }
@@ -311,8 +312,8 @@ export class Binding {
                 }
                 if (exp) {
                     context = (this.source && this.source.get && this.source.get()) || global;
-                    const resources = bindableResources.get();
-                    for (const prop in resources) {
+                    var resources = bindableResources.get();
+                    for (var prop in resources) {
                         if (resources.hasOwnProperty(prop) && !context.hasOwnProperty(prop)) {
                             context[prop] = resources[prop];
                             addedProps.push(prop);
@@ -332,18 +333,19 @@ export class Binding {
                 result = new Error(e + ' at ' + targetInstance);
             }
             // Clear added props
-            for (const prop of addedProps) {
+            for (var _i = 0, addedProps_1 = addedProps; _i < addedProps_1.length; _i++) {
+                var prop = addedProps_1[_i];
                 delete context[prop];
             }
             addedProps.length = 0;
         }
         return result;
-    }
-    onSourcePropertyChanged(data) {
-        const sourceProps = this.sourceProperties;
-        const sourcePropsLength = sourceProps.length;
-        let changedPropertyIndex = sourceProps.indexOf(data.propertyName);
-        let parentProps = '';
+    };
+    Binding.prototype.onSourcePropertyChanged = function (data) {
+        var sourceProps = this.sourceProperties;
+        var sourcePropsLength = sourceProps.length;
+        var changedPropertyIndex = sourceProps.indexOf(data.propertyName);
+        var parentProps = '';
         if (changedPropertyIndex > -1) {
             parentProps = '$' + sourceProps.slice(0, changedPropertyIndex + 1).join('$');
             while (this.propertyChangeListeners.get(parentProps) !== data.object) {
@@ -353,11 +355,11 @@ export class Binding {
         }
         if (__UI_USE_EXTERNAL_RENDERER__ || !this.options.expression) {
             if (changedPropertyIndex > -1) {
-                const props = sourceProps.slice(changedPropertyIndex + 1);
-                const propsLength = props.length;
+                var props = sourceProps.slice(changedPropertyIndex + 1);
+                var propsLength = props.length;
                 if (propsLength > 0) {
-                    let value = data.value;
-                    for (let i = 0; i < propsLength; i++) {
+                    var value = data.value;
+                    for (var i = 0; i < propsLength; i++) {
                         value = value[props[i]];
                     }
                     this.updateTarget(value);
@@ -368,7 +370,7 @@ export class Binding {
             }
         }
         else {
-            const expressionValue = this._getExpressionValue(this.options.expression, false, undefined);
+            var expressionValue = this._getExpressionValue(this.options.expression, false, undefined);
             if (expressionValue instanceof Error) {
                 Trace.write(expressionValue.message, Trace.categories.Binding, Trace.messageType.error);
             }
@@ -378,38 +380,39 @@ export class Binding {
         }
         // 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) {
-            const probablyChangedObject = this.propertyChangeListeners.get(parentProps);
+            var 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 (let i = sourcePropsLength - 1; i > changedPropertyIndex; i--) {
-                    const prop = '$' + sourceProps.slice(0, i + 1).join('$');
+                for (var i = sourcePropsLength - 1; i > changedPropertyIndex; i--) {
+                    var 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);
                     }
                 }
-                const newProps = sourceProps.slice(changedPropertyIndex + 1);
+                var newProps = sourceProps.slice(changedPropertyIndex + 1);
                 // add new weak event listeners
-                const newObject = data.object[sourceProps[changedPropertyIndex]];
+                var newObject = data.object[sourceProps[changedPropertyIndex]];
                 if (!types.isNullOrUndefined(newObject) && typeof newObject === 'object') {
                     this.addPropertyChangeListeners(new WeakRef(newObject), newProps, parentProps);
                 }
             }
         }
-    }
-    prepareContextForExpression(target, model, expression, addedProps = []) {
-        let success = true;
-        let parentViewAndIndex;
-        let parentView;
-        let expressionCP = expression;
+    };
+    Binding.prototype.prepareContextForExpression = function (target, model, expression, addedProps) {
+        if (addedProps === void 0) { addedProps = []; }
+        var success = true;
+        var parentViewAndIndex;
+        var parentView;
+        var expressionCP = expression;
         if (expressionCP.indexOf(bc.bindingValueKey) > -1) {
             model[bc.bindingValueKey] = model;
             addedProps.push(bc.bindingValueKey);
         }
-        const parentsArray = expressionCP.match(parentsRegex);
+        var parentsArray = expressionCP.match(parentsRegex);
         if (parentsArray) {
-            for (let i = 0; i < parentsArray.length; i++) {
+            for (var 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]);
@@ -434,14 +437,14 @@ export class Binding {
             }
         }
         return success;
-    }
-    getSourcePropertyValue() {
+    };
+    Binding.prototype.getSourcePropertyValue = function () {
         if (__UI_USE_EXTERNAL_RENDERER__) {
         }
         else if (this.options.expression) {
-            const changedModel = {};
+            var changedModel = {};
             changedModel[bc.bindingValueKey] = this.source ? this.source.get() : undefined;
-            const expressionValue = this._getExpressionValue(this.options.expression, false, changedModel);
+            var expressionValue = this._getExpressionValue(this.options.expression, false, changedModel);
             if (expressionValue instanceof Error) {
                 Trace.write(expressionValue.message, Trace.categories.Binding, Trace.messageType.error);
             }
@@ -450,7 +453,7 @@ export class Binding {
             }
         }
         if (this.sourceOptions) {
-            const sourceOptionsInstance = this.sourceOptions.instance.get();
+            var sourceOptionsInstance = this.sourceOptions.instance.get();
             if (this.sourceOptions.property === bc.bindingValueKey) {
                 return sourceOptionsInstance;
             }
@@ -465,40 +468,40 @@ export class Binding {
             }
         }
         return null;
-    }
-    clearBinding() {
+    };
+    Binding.prototype.clearBinding = function () {
         this.clearSource();
         this.updateTarget(unsetValue);
-    }
-    updateTarget(value) {
+    };
+    Binding.prototype.updateTarget = function (value) {
         if (this.updating) {
             return;
         }
         this.updateOptions(this.targetOptions, types.isNullOrUndefined(value) ? unsetValue : value);
-    }
-    updateSource(value) {
+    };
+    Binding.prototype.updateSource = function (value) {
         if (this.updating || !this.source || !this.source.get()) {
             return;
         }
         this.updateOptions(this.sourceOptions, value);
-    }
-    getParentView(target, property) {
+    };
+    Binding.prototype.getParentView = function (target, property) {
         if (!target) {
             return { view: null, index: null };
         }
-        let result;
+        var result;
         if (property === bc.parentValueKey) {
             result = target.parent;
         }
-        let index = null;
+        var index = null;
         if (property.indexOf(bc.parentsValueKey) === 0) {
             result = target.parent;
-            const indexParams = paramsRegex.exec(property);
+            var indexParams = paramsRegex.exec(property);
             if (indexParams && indexParams.length > 1) {
                 index = indexParams[2];
             }
             if (!isNaN(index)) {
-                let indexAsInt = parseInt(index);
+                var indexAsInt = parseInt(index);
                 while (indexAsInt > 0) {
                     result = result.parent;
                     indexAsInt--;
@@ -511,21 +514,21 @@ export class Binding {
             }
         }
         return { view: result, index: index };
-    }
-    resolveOptions(obj, properties) {
-        const objectsAndProperties = this.resolveObjectsAndProperties(obj, properties);
+    };
+    Binding.prototype.resolveOptions = function (obj, properties) {
+        var objectsAndProperties = this.resolveObjectsAndProperties(obj, properties);
         if (objectsAndProperties.length > 0) {
-            const resolvedObj = objectsAndProperties[objectsAndProperties.length - 1].instance;
-            const prop = objectsAndProperties[objectsAndProperties.length - 1].property;
+            var resolvedObj = objectsAndProperties[objectsAndProperties.length - 1].instance;
+            var prop = objectsAndProperties[objectsAndProperties.length - 1].property;
             return {
                 instance: new WeakRef(this.sourceAsObject(resolvedObj)),
                 property: prop,
             };
         }
         return null;
-    }
-    updateOptions(options, value) {
-        let optionsInstance;
+    };
+    Binding.prototype.updateOptions = function (options, value) {
+        var optionsInstance;
         if (options && options.instance) {
             optionsInstance = options.instance.get();
         }
@@ -551,6 +554,8 @@ export class Binding {
             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