export function watchKey(obj, keyName, meta) {
// can't watch length on Array - it is special...
if (keyName === 'length' && typeOf(obj) === 'array') { return; }
var m = meta || metaFor(obj);
var watching = m.watching;
// activate watching first time
if (!watching[keyName]) {
watching[keyName] = 1;
var possibleDesc = obj[keyName];
var desc = (possibleDesc !== null && typeof possibleDesc === 'object' && possibleDesc.isDescriptor) ? possibleDesc : undefined;
if (desc && desc.willWatch) { desc.willWatch(obj, keyName); }
if ('function' === typeof obj.willWatchProperty) {
obj.willWatchProperty(keyName);
}
if (Ngular.FEATURES.isEnabled('mandatory-setter')) {
if (hasPropertyAccessors) {
handleMandatorySetter(m, obj, keyName);
}
}
} else {
watching[keyName] = (watching[keyName] || 0) + 1;
}
}
function _copy(obj, deep, seen, copies) {
var ret, loc, key;
// primitive data types are immutable, just return them.
if (typeof obj !== 'object' || obj === null) {
return obj;
}
// avoid cyclical loops
if (deep && (loc = indexOf(seen, obj)) >= 0) {
return copies[loc];
}
Ngular.assert('Cannot clone an Ngular.Object that does not implement Ngular.Copyable',
!(obj instanceof NgularObject) || (Copyable && Copyable.detect(obj)));
// IMPORTANT: this specific test will detect a native array only. Any other
// object will need to implement Copyable.
if (typeOf(obj) === 'array') {
ret = obj.slice();
if (deep) {
loc = ret.length;
while (--loc >= 0) {
ret[loc] = _copy(ret[loc], deep, seen, copies);
}
}
} else if (Copyable && Copyable.detect(obj)) {
ret = obj.copy(deep, seen, copies);
} else if (obj instanceof Date) {
ret = new Date(obj.getTime());
} else {
ret = {};
for (key in obj) {
// support Null prototype
if (!Object.prototype.hasOwnProperty.call(obj, key)) {
continue;
}
// Prevents browsers that don't respect non-enumerability from
// copying internal Ngular properties
if (key.substring(0, 2) === '__') {
continue;
}
ret[key] = deep ? _copy(obj[key], deep, seen, copies) : obj[key];
}
}
if (deep) {
seen.push(obj);
copies.push(ret);
}
return ret;
}
/**
Expands `pattern`, invoking `callback` for each expansion.
The only pattern supported is brace-expansion, anything else will be passed
once to `callback` directly.
Example
```js
function echo(arg){ console.log(arg); }
Ngular.expandProperties('foo.bar', echo); //=> 'foo.bar'
Ngular.expandProperties('{foo,bar}', echo); //=> 'foo', 'bar'
Ngular.expandProperties('foo.{bar,baz}', echo); //=> 'foo.bar', 'foo.baz'
Ngular.expandProperties('{foo,bar}.baz', echo); //=> '{foo,bar}.baz'
Ngular.expandProperties('foo.{bar,baz}.@each', echo) //=> 'foo.bar.@each', 'foo.baz.@each'
Ngular.expandProperties('{foo,bar}.{spam,eggs}', echo) //=> 'foo.spam', 'foo.eggs', 'bar.spam', 'bar.eggs'
Ngular.expandProperties('{foo}.bar.{baz}') //=> 'foo.bar.baz'
```
@method
@private
@param {String} pattern The property pattern to expand.
@param {Function} callback The callback to invoke. It is invoked once per
expansion, and is passed the expansion.
*/
export default function expandProperties(pattern, callback) {
if (pattern.indexOf(' ') > -1) {
throw new NgularError(`Brace expanded properties cannot contain spaces, e.g. 'user.{firstName, lastName}' should be 'user.{firstName,lastName}'`);
}
if ('string' === typeOf(pattern)) {
var parts = pattern.split(SPLIT_REGEX);
var properties = [parts];
forEach(parts, function(part, index) {
if (part.indexOf(',') >= 0) {
properties = duplicateAndReplace(properties, part.split(','), index);
}
});
forEach(properties, function(property) {
callback(property.join(''));
});
} else {
callback(pattern);
}
}
while (view) {
manager = get(view, 'eventManager');
if (manager && manager[eventName]) { break; }
view = get(view, 'parentView');
}
return manager;
},
_dispatchEvent(object, evt, eventName, view) {
var result = true;
var handler = object[eventName];
if (typeOf(handler) === 'function') {
result = run(object, handler, evt, view);
// Do not preventDefault in eventManagers.
evt.stopPropagation();
} else {
result = this._bubbleEvent(view, evt, eventName);
}
return result;
},
_bubbleEvent(view, evt, eventName) {
return run.join(view, view.handleEvent, eventName, evt);
},
destroy() {
trigger() {
this._super.apply(this, arguments);
var name = arguments[0];
var method = this[name];
if (method) {
var length = arguments.length;
var args = new Array(length - 1);
for (var i = 1; i < length; i++) {
args[i - 1] = arguments[i];
}
return method.apply(this, args);
}
},
has(name) {
return typeOf(this[name]) === 'function' || this._super(name);
},
destroy() {
var parent = this._parentView;
if (!this._super(...arguments)) { return; }
// destroy the element -- this will avoid each child view destroying
// the element over and over again...
if (!this.removedFromDOM && this._renderer) {
this._renderer.remove(this, true);
}
// remove from parent if found. Don't call removeFromParent,