/// Knockout Mapping plugin v2.4.1/// (c) 2013 Steven Sanderson, Roy Jacobs - http://knockoutjs.com//// License: MIT (http://www.opensource.org/licenses/mit-license.php)(function (factory) {    // Module systems magic dance.     if (typeof require === "function" && typeof exports === "object" && typeof module === "object") {        // CommonJS or Node: hard-coded dependency on "knockout"        factory(require("knockout"), exports);    } else if (typeof define === "function" && define["amd"]) {        // AMD anonymous module with hard-coded dependency on "knockout"        define(["knockout", "exports"], factory);    } else {        // <script> tag: use the global `ko` object, attaching a `mapping` property        factory(ko, ko.mapping = {});    }}(function (ko, exports) {    var DEBUG = true;    var mappingProperty = "__ko_mapping__";    var realKoDependentObservable = ko.dependentObservable;    var mappingNesting = 0;    var dependentObservables;    var visitedObjects;    var recognizedRootProperties = ["create", "update", "key", "arrayChanged"];    var emptyReturn = {};     var _defaultOptions = {        include: ["_destroy"],        ignore: [],        copy: [],        observe: []    };    var defaultOptions = _defaultOptions;     // Author: KennyTM @ StackOverflow    function unionArrays(x, y) {        var obj = {};        for (var i = x.length - 1; i >= 0; --i) obj[x[i]] = x[i];        for (var i = y.length - 1; i >= 0; --i) obj[y[i]] = y[i];        var res = [];         for (var k in obj) {            res.push(obj[k]);        };         return res;    }     function extendObject(destination, source) {        var destType;         for (var key in source) {            if (source.hasOwnProperty(key) && source[key]) {                destType = exports.getType(destination[key]);                if (key && destination[key] && destType !== "array" && destType !== "string") {                    extendObject(destination[key], source[key]);                } else {                    var bothArrays = exports.getType(destination[key]) === "array" && exports.getType(source[key]) === "array";                    if (bothArrays) {                        destination[key] = unionArrays(destination[key], source[key]);                    } else {                        destination[key] = source[key];                    }                }            }        }    }     function merge(obj1, obj2) {        var merged = {};        extendObject(merged, obj1);        extendObject(merged, obj2);         return merged;    }     exports.isMapped = function (viewModel) {        var unwrapped = ko.utils.unwrapObservable(viewModel);        return unwrapped && unwrapped[mappingProperty];    }     exports.fromJS = function (jsObject /*, inputOptions, target*/) {        if (arguments.length == 0) throw new Error("When calling ko.fromJS, pass the object you want to convert.");         try {            if (!mappingNesting++) {                dependentObservables = [];                visitedObjects = new objectLookup();            }             var options;            var target;             if (arguments.length == 2) {                if (arguments[1][mappingProperty]) {                    target = arguments[1];                } else {                    options = arguments[1];                }            }            if (arguments.length == 3) {                options = arguments[1];                target = arguments[2];            }             if (target) {                options = merge(options, target[mappingProperty]);            }            options = fillOptions(options);             var result = updateViewModel(target, jsObject, options);            if (target) {                result = target;            }             // Evaluate any dependent observables that were proxied.            // Do this after the model's observables have been created            if (!--mappingNesting) {                while (dependentObservables.length) {                    var DO = dependentObservables.pop();                    if (DO) {                        DO();                         // Move this magic property to the underlying dependent observable                        DO.__DO["throttleEvaluation"] = DO["throttleEvaluation"];                    }                }            }             // Save any new mapping options in the view model, so that updateFromJS can use them later.            result[mappingProperty] = merge(result[mappingProperty], options);             return result;        } catch (e) {            mappingNesting = 0;            throw e;        }    };     exports.fromJSON = function (jsonString /*, options, target*/) {        var parsed = ko.utils.parseJson(jsonString);        arguments[0] = parsed;        return exports.fromJS.apply(this, arguments);    };     exports.updateFromJS = function (viewModel) {        throw new Error("ko.mapping.updateFromJS, use ko.mapping.fromJS instead. Please note that the order of parameters is different!");    };     exports.updateFromJSON = function (viewModel) {        throw new Error("ko.mapping.updateFromJSON, use ko.mapping.fromJSON instead. Please note that the order of parameters is different!");    };     exports.toJS = function (rootObject, options) {        if (!defaultOptions) exports.resetDefaultOptions();         if (arguments.length == 0) throw new Error("When calling ko.mapping.toJS, pass the object you want to convert.");        if (exports.getType(defaultOptions.ignore) !== "array") throw new Error("ko.mapping.defaultOptions().ignore should be an array.");        if (exports.getType(defaultOptions.include) !== "array") throw new Error("ko.mapping.defaultOptions().include should be an array.");        if (exports.getType(defaultOptions.copy) !== "array") throw new Error("ko.mapping.defaultOptions().copy should be an array.");         // Merge in the options used in fromJS        options = fillOptions(options, rootObject[mappingProperty]);         // We just unwrap everything at every level in the object graph        return exports.visitModel(rootObject, function (x) {            return ko.utils.unwrapObservable(x)        }, options);    };     exports.toJSON = function (rootObject, options) {        var plainJavaScriptObject = exports.toJS(rootObject, options);        return ko.utils.stringifyJson(plainJavaScriptObject);    };     exports.defaultOptions = function () {        if (arguments.length > 0) {            defaultOptions = arguments[0];        } else {            return defaultOptions;        }    };     exports.resetDefaultOptions = function () {        defaultOptions = {            include: _defaultOptions.include.slice(0),            ignore: _defaultOptions.ignore.slice(0),            copy: _defaultOptions.copy.slice(0)        };    };     exports.getType = function (x) {        if ((x) && (typeof (x) === "object")) {            if (x.constructor === Date) return "date";            if (x.constructor === Array) return "array";        }        return typeof x;    }     function fillOptions(rawOptions, otherOptions) {        var options = merge({}, rawOptions);         // Move recognized root-level properties into a root namespace        for (var i = recognizedRootProperties.length - 1; i >= 0; i--) {            var property = recognizedRootProperties[i];             // Carry on, unless this property is present            if (!options[property]) continue;             // Move the property into the root namespace            if (!(options[""] instanceof Object)) options[""] = {};            options[""][property] = options[property];            delete options[property];        }         if (otherOptions) {            options.ignore = mergeArrays(otherOptions.ignore, options.ignore);            options.include = mergeArrays(otherOptions.include, options.include);            options.copy = mergeArrays(otherOptions.copy, options.copy);            options.observe = mergeArrays(otherOptions.observe, options.observe);        }        options.ignore = mergeArrays(options.ignore, defaultOptions.ignore);        options.include = mergeArrays(options.include, defaultOptions.include);        options.copy = mergeArrays(options.copy, defaultOptions.copy);        options.observe = mergeArrays(options.observe, defaultOptions.observe);         options.mappedProperties = options.mappedProperties || {};        options.copiedProperties = options.copiedProperties || {};        return options;    }     function mergeArrays(a, b) {        if (exports.getType(a) !== "array") {            if (exports.getType(a) === "undefined") a = [];            else a = [a];        }        if (exports.getType(b) !== "array") {            if (exports.getType(b) === "undefined") b = [];            else b = [b];        }         return ko.utils.arrayGetDistinctValues(a.concat(b));    }     // When using a 'create' callback, we proxy the dependent observable so that it doesn't immediately evaluate on creation.    // The reason is that the dependent observables in the user-specified callback may contain references to properties that have not been mapped yet.    function withProxyDependentObservable(dependentObservables, callback) {        var localDO = ko.dependentObservable;        ko.dependentObservable = function (read, owner, options) {            options = options || {};             if (read && typeof read == "object") { // mirrors condition in knockout implementation of DO's                options = read;            }             var realDeferEvaluation = options.deferEvaluation;             var isRemoved = false;             // We wrap the original dependent observable so that we can remove it from the 'dependentObservables' list we need to evaluate after mapping has            // completed if the user already evaluated the DO themselves in the meantime.            var wrap = function (DO) {                // Temporarily revert ko.dependentObservable, since it is used in ko.isWriteableObservable                var tmp = ko.dependentObservable;                ko.dependentObservable = realKoDependentObservable;                var isWriteable = ko.isWriteableObservable(DO);                ko.dependentObservable = tmp;                 var wrapped = realKoDependentObservable({                    read: function () {                        if (!isRemoved) {                            ko.utils.arrayRemoveItem(dependentObservables, DO);                            isRemoved = true;                        }                        return DO.apply(DO, arguments);                    },                    write: isWriteable && function (val) {                        return DO(val);                    },                    deferEvaluation: true                });                if (DEBUG) wrapped._wrapper = true;                wrapped.__DO = DO;                return wrapped;            };             options.deferEvaluation = true; // will either set for just options, or both read/options.            var realDependentObservable = new realKoDependentObservable(read, owner, options);             if (!realDeferEvaluation) {                realDependentObservable = wrap(realDependentObservable);                dependentObservables.push(realDependentObservable);            }             return realDependentObservable;        }        ko.dependentObservable.fn = realKoDependentObservable.fn;        ko.computed = ko.dependentObservable;        var result = callback();        ko.dependentObservable = localDO;        ko.computed = ko.dependentObservable;        return result;    }     function updateViewModel(mappedRootObject, rootObject, options, parentName, parent, parentPropertyName, mappedParent) {        var isArray = exports.getType(ko.utils.unwrapObservable(rootObject)) === "array";         parentPropertyName = parentPropertyName || "";         // If this object was already mapped previously, take the options from there and merge them with our existing ones.        if (exports.isMapped(mappedRootObject)) {            var previousMapping = ko.utils.unwrapObservable(mappedRootObject)[mappingProperty];            options = merge(previousMapping, options);        }         var callbackParams = {            data: rootObject,            parent: mappedParent || parent        };         var hasCreateCallback = function () {            return options[parentName] && options[parentName].create instanceof Function;        };         var createCallback = function (data) {            return withProxyDependentObservable(dependentObservables, function () {                 if (ko.utils.unwrapObservable(parent) instanceof Array) {                    return options[parentName].create({                        data: data || callbackParams.data,                        parent: callbackParams.parent,                        skip: emptyReturn                    });                } else {                    return options[parentName].create({                        data: data || callbackParams.data,                        parent: callbackParams.parent                    });                }            });        };         var hasUpdateCallback = function () {            return options[parentName] && options[parentName].update instanceof Function;        };         var updateCallback = function (obj, data) {            var params = {                data: data || callbackParams.data,                parent: callbackParams.parent,                target: ko.utils.unwrapObservable(obj)            };             if (ko.isWriteableObservable(obj)) {                params.observable = obj;            }             return options[parentName].update(params);        }         var alreadyMapped = visitedObjects.get(rootObject);        if (alreadyMapped) {            return alreadyMapped;        }         parentName = parentName || "";         if (!isArray) {            // For atomic types, do a direct update on the observable            if (!canHaveProperties(rootObject)) {                switch (exports.getType(rootObject)) {                    case "function":                        if (hasUpdateCallback()) {                            if (ko.isWriteableObservable(rootObject)) {                                rootObject(updateCallback(rootObject));                                mappedRootObject = rootObject;                            } else {                                mappedRootObject = updateCallback(rootObject);                            }                        } else {                            mappedRootObject = rootObject;                        }                        break;                    default:                        if (ko.isWriteableObservable(mappedRootObject)) {                            if (hasUpdateCallback()) {                                var valueToWrite = updateCallback(mappedRootObject);                                mappedRootObject(valueToWrite);                                return valueToWrite;                            } else {                                var valueToWrite = ko.utils.unwrapObservable(rootObject);                                mappedRootObject(valueToWrite);                                return valueToWrite;                            }                        } else {                            var hasCreateOrUpdateCallback = hasCreateCallback() || hasUpdateCallback();                             if (hasCreateCallback()) {                                mappedRootObject = createCallback();                            } else {                                mappedRootObject = ko.observable(ko.utils.unwrapObservable(rootObject));                            }                             if (hasUpdateCallback()) {                                mappedRootObject(updateCallback(mappedRootObject));                            }                             if (hasCreateOrUpdateCallback) return mappedRootObject;                        }                }             } else {                mappedRootObject = ko.utils.unwrapObservable(mappedRootObject);                if (!mappedRootObject) {                    if (hasCreateCallback()) {                        var result = createCallback();                         if (hasUpdateCallback()) {                            result = updateCallback(result);                        }                         return result;                    } else {                        if (hasUpdateCallback()) {                            return updateCallback(result);                        }                         mappedRootObject = {};                    }                }                 if (hasUpdateCallback()) {                    mappedRootObject = updateCallback(mappedRootObject);                }                 visitedObjects.save(rootObject, mappedRootObject);                if (hasUpdateCallback()) return mappedRootObject;                 // For non-atomic types, visit all properties and update recursively                visitPropertiesOrArrayEntries(rootObject, function (indexer) {                    var fullPropertyName = parentPropertyName.length ? parentPropertyName + "." + indexer : indexer;                     if (ko.utils.arrayIndexOf(options.ignore, fullPropertyName) != -1) {                        return;                    }                     if (ko.utils.arrayIndexOf(options.copy, fullPropertyName) != -1) {                        mappedRootObject[indexer] = rootObject[indexer];                        return;                    }                     if (typeof rootObject[indexer] != "object" && typeof rootObject[indexer] != "array" && options.observe.length > 0 && ko.utils.arrayIndexOf(options.observe, fullPropertyName) == -1) {                        mappedRootObject[indexer] = rootObject[indexer];                        options.copiedProperties[fullPropertyName] = true;                        return;                    }                     // In case we are adding an already mapped property, fill it with the previously mapped property value to prevent recursion.                    // If this is a property that was generated by fromJS, we should use the options specified there                    var prevMappedProperty = visitedObjects.get(rootObject[indexer]);                    var retval = updateViewModel(mappedRootObject[indexer], rootObject[indexer], options, indexer, mappedRootObject, fullPropertyName, mappedRootObject);                    var value = prevMappedProperty || retval;                     if (options.observe.length > 0 && ko.utils.arrayIndexOf(options.observe, fullPropertyName) == -1) {                        mappedRootObject[indexer] = value();                        options.copiedProperties[fullPropertyName] = true;                        return;                    }                     if (ko.isWriteableObservable(mappedRootObject[indexer])) {                        value = ko.utils.unwrapObservable(value);                        if (mappedRootObject[indexer]() !== value) {                            mappedRootObject[indexer](value);                        }                    } else {                        value = mappedRootObject[indexer] === undefined ? value : ko.utils.unwrapObservable(value);                        mappedRootObject[indexer] = value;                    }                     options.mappedProperties[fullPropertyName] = true;                });            }        } else { //mappedRootObject is an array            var changes = [];             var hasKeyCallback = false;            var keyCallback = function (x) {                return x;            }            if (options[parentName] && options[parentName].key) {                keyCallback = options[parentName].key;                hasKeyCallback = true;            }             if (!ko.isObservable(mappedRootObject)) {                // When creating the new observable array, also add a bunch of utility functions that take the 'key' of the array items into account.                mappedRootObject = ko.observableArray([]);                 mappedRootObject.mappedRemove = function (valueOrPredicate) {                    var predicate = typeof valueOrPredicate == "function" ? valueOrPredicate : function (value) {

Lines 1–500 of 807. Load more