// Deep observer plugin for Knockout http://knockoutjs.com/// (c) Ziad Jeeroburkhan// License: MIT (http://www.opensource.org/licenses/mit-license.php)// Version 1.3.0 ko.subscribable.fn['watch'] = function (targetOrEvaluatorCallback, options, evaluatorCallback, context) {    /// <summary>    ///     Track and manage changes within the chained observable down to any given level.    /// </summary>    /// <param name="options" type="object">    ///     false -> Disables tracking on the chained observable.    ///     { depth: 2 } -> Track all nested subscribables down to the 2nd level(default is 1).<br/>    ///     { depth: -1 } -> Track all nested subscribables.<br/>    ///     { hide: [...] } -> Property or array of properties to be ignored.<br/>    ///     { hideArrays: true } -> Ignore all nested arrays.<br/>    ///     { hideWrappedValues: true } -> Ignore observables wrapped under yet another parent observable.<br/>    ///     { mutable: true } -> Dynamically adapt to changes made to the target structure through its own subscribables.<br/>    ///     { watchedOnly: true } -> Watch only subscribables tagged with .watch().<br/>    ///     { beforeWatch: function(parents, child) {...} } -> Function called prior to creating a subscription. Returning false aborts the operation and ignores its children.<br/>    ///     { wrap: true } -> Wrap all fields into observables. This happens on the fly for new array items(or child objects when mutable is set to true).<br/>    ///     { beforeWrap: function(parents, field, value) {...} } -> Function called prior to wrapping a value into an observable. Returning false leaves it as it is.<br/>    ///     { tagParentsWithName: true } -> Add the property '_fieldName' under each parent for easy identification.<br/>    ///     { keepOldValues: 3 } -> Keep the last three values for each subscribable under the property 'oldValues'.<br/>    ///     { seal: true } -> Prevent any subsequent watcher from watching down the target tree.<br/>    /// </param>    /// <param name="evaluatorCallback" type="function">    ///     The  callback function called during changes. Any return value is assigned to the chained observable.    /// </param>     var targetType = typeof targetOrEvaluatorCallback;     if (targetType === 'boolean' || targetType === 'undefined') {        // Turn on or off the watcher for the specified target along with any of its children.        ko.watch(this, { enabled: targetOrEvaluatorCallback !== false });    } else if (targetType === 'function' && !ko.isSubscribable(targetOrEvaluatorCallback)) {        // Target the chained subscribable itself if no target subscribable or object was passed.        ko.watch(this, options || {}, targetOrEvaluatorCallback, context || this);    } else {        ko.watch(targetOrEvaluatorCallback, options, evaluatorCallback, context || this);    }     return this;}; ko['watch'] = function (target, options, evaluatorCallback, context) {    /// <summary>    ///     Track and manage changes within a specific target object down to any given level.    /// </summary>    /// <param name="target">    ///     An object or function containing targeted subscribables or the subscribable itself.    /// </param>    /// <param name="options" type="object">    ///     { depth: 2 } -> Track all nested subscribables down to the 2nd level(default is 1).<br/>    ///     { depth: -1 } -> Track all nested subscribables.<br/>    ///     { hide: [...] } -> Property or array of properties to be ignored.<br/>    ///     { hideArrays: true } -> Ignore all nested arrays.<br/>    ///     { hideWrappedValues: true } -> Ignore observables wrapped under yet another parent observable.<br/>    ///     { mutable: true } -> Dynamically adapt to changes made to the target structure through its own subscribables.<br/>    ///     { watchedOnly: true } -> Watch only subscribables tagged with .watch().<br/>    ///     { beforeWatch: function(parents, child) {...} } -> Function called prior to creating a subscription. Returning false aborts the operation and ignores its children.<br/>    ///     { wrap: true } -> Wrap all fields into observables. This happens on the fly for new array items(or child objects when mutable is set to true).<br/>    ///     { beforeWrap: function(parents, field, value) {...} } -> Function called prior to wrapping a value into an observable. Returning false leaves it as it is.<br/>    ///     { tagParentsWithName: true } -> Add the property '_fieldName' under each parent for easy identification.<br/>    ///     { keepOldValues: 3 } -> Keep the last three values for each subscribable under the property 'oldValues'.<br/>    ///     { seal: true } -> Prevent any subsequent watcher from watching down the target tree.<br/>    /// </param>    /// <param name="evaluatorCallback" type="function">    ///     The callback function called during changes.    /// </param>     if (typeof options === 'function') {        context = context || evaluatorCallback;        evaluatorCallback = options;        options = {};    }     context = context || this;     function watchChildren(child, parent, grandParents, unwatch, keepOffParentList) {         if (child && options.depth !== 0 && (options.depth === -1 || grandParents.length < (options.depth || 1))) {             // Proceed on watched children only when in watched-only mode.            if (options.watchedOnly && !child.watchable && child != target)                return;             // Setting the target as false prevents it from being watched later on.            if (options.enabled === false || options.enabled === true)                child.watchable = options.enabled;             // Ignore watch-disabled objects.            if (child.watchable === false)                return;             // Prevent subsequent watchers from watching the target when sealed.            if (options.seal === true)                child.watchable = false;             // Bypass circular references.            if (child === parent || ko.utils.arrayIndexOf(grandParents, child) > -1)                return;             // Merge parents. Using a fresh array so it is not referenced in the next recursion if any.            var parents = [].concat(grandParents, parent && parent !== target ? parent : []);             // Ignore hidden objects. Also applies to any of their children.            if (options.hide)                if (typeof options.hide === 'object'                    ? options.hide === child                    : ko.utils.arrayIndexOf(options.hide, child) > -1)                    return;             if (ko.isSubscribable(child)) {                if (evaluatorCallback) {                    if (unwatch === true || !options.beforeWatch || options.beforeWatch.call(context, parents, child) !== false) {                        if (typeof child.pop === 'function') {                            // Child is an observable array. Watch all item changes within it.                            child.subscribe(function (changes) {                                ko.utils.arrayForEach(changes, function (item) {                                     var returnValue = evaluatorCallback.call(context, parents, child, item);                                    if (returnValue !== undefined)                                        context(returnValue);                                     if (!item.moved) {                                        // Deleted or brand new item. Unwatch or watch it.                                        setTimeout(function () {                                            watchChildren(item.value, (keepOffParentList ? null : child), parents, item.status === 'deleted');                                        }, 0);                                    }                                });                            }, undefined, 'arrayChange');                             watchChildren(child(), (keepOffParentList ? null : child), parents, unwatch, true);                             return true;                         } else {                             if (unwatch === true) {                                // A subscribable was removed from an array or mutable object.                                // Clean up all its change subscriptions through either H or _subscriptions                                // depending on whether the Knockout code is minified or not.                                var subsc = child.H || child._subscriptions;                                 if (subsc) {                                    if (subsc.change)                                        for (var i = subsc.change.length - 1; i >= 0; i--)                                            if (subsc.change[i]._watcher === context)                                                subsc.change[i].dispose();                                     if (subsc.beforeChange && options.keepOldValues > 0)                                        // Also clean up any before-change subscriptions used for tracking old values.                                        for (var i = subsc.beforeChange.length - 1; i >= 0; i--)                                            if (subsc.beforeChange[i]._watcher === context)                                                subsc.beforeChange[i].dispose();                                }                                 watchChildren(child(), (keepOffParentList ? null : child), parents, true, true);                             } else {                                 if (options.enabled === true && child.watchable === false)                                    // Only waking up an existing watcher. Let's not add another.                                    return;                                 if (options.keepOldValues > 0 || options.mutable) {                                    child.subscribe(function (oldValue) {                                        if (options.keepOldValues > 0) {                                            // Add old value to history list before every update.                                            var values = (child['oldValues']                                                ? child['oldValues']                                                : child['oldValues'] = []);                                             values.unshift(oldValue);                                             while (values.length > options.keepOldValues)                                                values.pop();                                        }                                         if (options.mutable && typeof oldValue === 'object')                                            // Clean up all subscriptions for the old child object.                                            watchChildren(oldValue, (keepOffParentList ? null : child), parents, true, true);                                     }, null, 'beforeChange')._watcher = context;                                }                                 child.subscribe(function () {                                    if (child.watchable !== false) {                                        var returnValue = evaluatorCallback.call(context, parents, child);                                         if (returnValue !== undefined)                                            context(returnValue);                                         if (options.mutable && typeof child() === 'object')                                            // Watch the new comer object.                                            watchChildren(child(), (keepOffParentList ? null : child), parents);                                    }                                 }, null, 'change')._watcher = context;                                 if (options.hideWrappedValues !== true)                                    watchChildren(child(), (keepOffParentList ? null : child), parents);                            }                        }                    }                }             } else {                switch (Object.prototype.toString.call(child)) {                    case '[object Object]':                        ko.utils.objectForEach(child, function (property, sub) {                            if (options.wrap) {                                // Wrap simple objects and arrays into observables.                                var type = Object.prototype.toString.call(sub);                                if (type !== '[object Function]' && type !== '[object Object]') {                                    if (!options.beforeWrap || options.beforeWrap.call(context, parents, child, sub) !== false) {                                        sub = child[property] = type === '[object Array]'                                            ? ko.observableArray(sub)                                            : ko.observable(sub);                                    }                                }                            }                             var subHasChildren = watchChildren(sub, (keepOffParentList ? null : child), parents, unwatch);                             if (subHasChildren && options.tagParentsWithName === true && !sub['_fieldName'])                                sub['_fieldName'] = property;                        });                        return true;                     case '[object Array]':                        if (options.hideArrays !== true)                            for (var i = 0; i < child.length; i++)                                watchChildren(child[i], (keepOffParentList ? null : child), parents, unwatch);                        return true;                }            }        }    }     // Use a computed when targeting a non-watchable function.    if (typeof target === 'function' && !ko.isSubscribable(target))        return ko.computed(target, evaluatorCallback, options);     watchChildren(target, null, []);};