mirror of
https://github.com/openhardwaremonitor/openhardwaremonitor
synced 2025-08-22 09:57:20 +00:00
687 lines
22 KiB
JavaScript
687 lines
22 KiB
JavaScript
// Knockout Mapping plugin v2.1.2
|
|
// (c) 2012 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 _defaultOptions = {
|
|
include: ["_destroy"],
|
|
ignore: [],
|
|
copy: []
|
|
};
|
|
var defaultOptions = _defaultOptions;
|
|
|
|
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.");
|
|
|
|
// When mapping is completed, even with an exception, reset the nesting level
|
|
window.setTimeout(function () {
|
|
mappingNesting = 0;
|
|
}, 0);
|
|
|
|
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 = mergeOptions(target[mappingProperty], options);
|
|
} else {
|
|
options = mergeOptions(options);
|
|
}
|
|
options.mappedProperties = options.mappedProperties || {};
|
|
|
|
var result = updateViewModel(target, jsObject, options);
|
|
if (target) {
|
|
result = target;
|
|
}
|
|
|
|
// Evaluate any dependent observables that were proxied.
|
|
// Do this in a timeout to defer execution. Basically, any user code that explicitly looks up the DO will perform the first evaluation. Otherwise,
|
|
// it will be done by this code.
|
|
if (!--mappingNesting) {
|
|
window.setTimeout(function () {
|
|
while (dependentObservables.length) {
|
|
var DO = dependentObservables.pop();
|
|
if (DO) DO();
|
|
}
|
|
}, 0);
|
|
}
|
|
|
|
// Save any new mapping options in the view model, so that updateFromJS can use them later.
|
|
result[mappingProperty] = mergeOptions(result[mappingProperty], options);
|
|
|
|
return result;
|
|
};
|
|
|
|
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 (arguments.length == 0) throw new Error("When calling ko.mapping.toJS, pass the object you want to convert.");
|
|
// Merge in the options used in fromJS
|
|
options = mergeOptions(rootObject[mappingProperty], options);
|
|
|
|
// We just unwrap everything at every level in the object graph
|
|
return 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.visitModel = function (rootObject, callback, options) {
|
|
if (arguments.length == 0) throw new Error("When calling ko.mapping.visitModel, pass the object you want to visit.");
|
|
// Merge in the options used in fromJS
|
|
options = mergeOptions(rootObject[mappingProperty], options);
|
|
|
|
return visitModel(rootObject, callback, options);
|
|
};
|
|
|
|
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 == (new Date).constructor) return "date";
|
|
if (x.constructor == (new Array).constructor) return "array";
|
|
}
|
|
return typeof x;
|
|
}
|
|
|
|
function extendOptionsArray(distArray, sourceArray) {
|
|
return ko.utils.arrayGetDistinctValues(
|
|
ko.utils.arrayPushAll(distArray, sourceArray)
|
|
);
|
|
}
|
|
|
|
function extendOptionsObject(target, options) {
|
|
var type = exports.getType,
|
|
name, special = { "include": true, "ignore": true, "copy": true },
|
|
t, o, i = 1, l = arguments.length;
|
|
if (type(target) !== "object") {
|
|
target = {};
|
|
}
|
|
for (; i < l; i++) {
|
|
options = arguments[i];
|
|
if (type(options) !== "object") {
|
|
options = {};
|
|
}
|
|
for (name in options) {
|
|
t = target[name]; o = options[name];
|
|
if (name !== "constructor" && special[name] && type(o) !== "array") {
|
|
if (type(o) !== "string") {
|
|
throw new Error("ko.mapping.defaultOptions()." + name + " should be an array or string.");
|
|
}
|
|
o = [o];
|
|
}
|
|
switch (type(o)) {
|
|
case "object": // Recurse
|
|
t = type(t) === "object" ? t : {};
|
|
target[name] = extendOptionsObject(t, o);
|
|
break;
|
|
case "array":
|
|
t = type(t) === "array" ? t : [];
|
|
target[name] = extendOptionsArray(t, o);
|
|
break;
|
|
default:
|
|
target[name] = o;
|
|
}
|
|
}
|
|
}
|
|
return target;
|
|
}
|
|
|
|
function mergeOptions() {
|
|
var options = ko.utils.arrayPushAll([{}, defaultOptions], arguments); // Always use empty object as target to avoid changing default options
|
|
options = extendOptionsObject.apply(this, options);
|
|
return options;
|
|
}
|
|
|
|
// 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) {
|
|
var wrapped = realKoDependentObservable({
|
|
read: function () {
|
|
if (!isRemoved) {
|
|
ko.utils.arrayRemoveItem(dependentObservables, DO);
|
|
isRemoved = true;
|
|
}
|
|
return DO.apply(DO, arguments);
|
|
},
|
|
write: function (val) {
|
|
return DO(val);
|
|
},
|
|
deferEvaluation: true
|
|
});
|
|
if(DEBUG) wrapped._wrapper = true;
|
|
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) {
|
|
var isArray = ko.utils.unwrapObservable(rootObject) instanceof Array;
|
|
|
|
// If nested object was already mapped previously, take the options from it
|
|
if (parentName !== undefined && exports.isMapped(mappedRootObject)) {
|
|
options = ko.utils.unwrapObservable(mappedRootObject)[mappingProperty];
|
|
parentName = "";
|
|
parentPropertyName = "";
|
|
}
|
|
|
|
parentName = parentName || "";
|
|
parentPropertyName = parentPropertyName || "";
|
|
|
|
var callbackParams = {
|
|
data: rootObject,
|
|
parent: parent
|
|
};
|
|
|
|
var getCallback = function (name) {
|
|
var callback;
|
|
if (parentName === "") {
|
|
callback = options[name];
|
|
} else if (callback = options[parentName]) {
|
|
callback = callback[name]
|
|
}
|
|
return callback;
|
|
};
|
|
|
|
var hasCreateCallback = function () {
|
|
return getCallback("create") instanceof Function;
|
|
};
|
|
|
|
var createCallback = function (data) {
|
|
return withProxyDependentObservable(dependentObservables, function () {
|
|
return getCallback("create")({
|
|
data: data || callbackParams.data,
|
|
parent: callbackParams.parent
|
|
});
|
|
});
|
|
};
|
|
|
|
var hasUpdateCallback = function () {
|
|
return getCallback("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 getCallback("update")(params);
|
|
}
|
|
|
|
var alreadyMapped = visitedObjects.get(rootObject);
|
|
if (alreadyMapped) {
|
|
return alreadyMapped;
|
|
}
|
|
|
|
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()) {
|
|
mappedRootObject(updateCallback(mappedRootObject));
|
|
} else {
|
|
mappedRootObject(ko.utils.unwrapObservable(rootObject));
|
|
}
|
|
} else {
|
|
if (hasCreateCallback()) {
|
|
mappedRootObject = createCallback();
|
|
} else {
|
|
mappedRootObject = ko.observable(ko.utils.unwrapObservable(rootObject));
|
|
}
|
|
|
|
if (hasUpdateCallback()) {
|
|
mappedRootObject(updateCallback(mappedRootObject));
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
} 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);
|
|
|
|
// For non-atomic types, visit all properties and update recursively
|
|
visitPropertiesOrArrayEntries(rootObject, function (indexer) {
|
|
var fullPropertyName = getPropertyName(parentPropertyName, rootObject, indexer);
|
|
|
|
if (ko.utils.arrayIndexOf(options.ignore, fullPropertyName) != -1) {
|
|
return;
|
|
}
|
|
|
|
if (ko.utils.arrayIndexOf(options.copy, fullPropertyName) != -1) {
|
|
mappedRootObject[indexer] = rootObject[indexer];
|
|
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 value = prevMappedProperty || updateViewModel(mappedRootObject[indexer], rootObject[indexer], options, indexer, mappedRootObject, fullPropertyName);
|
|
|
|
if (ko.isWriteableObservable(mappedRootObject[indexer])) {
|
|
mappedRootObject[indexer](ko.utils.unwrapObservable(value));
|
|
} else {
|
|
mappedRootObject[indexer] = value;
|
|
}
|
|
|
|
options.mappedProperties[fullPropertyName] = true;
|
|
});
|
|
}
|
|
} else {
|
|
var changes = [];
|
|
|
|
var hasKeyCallback = getCallback("key") instanceof Function;
|
|
var keyCallback = hasKeyCallback ? getCallback("key") : function (x) {
|
|
return x;
|
|
};
|
|
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) {
|
|
return value === keyCallback(valueOrPredicate);
|
|
};
|
|
return mappedRootObject.remove(function (item) {
|
|
return predicate(keyCallback(item));
|
|
});
|
|
}
|
|
|
|
mappedRootObject.mappedRemoveAll = function (arrayOfValues) {
|
|
var arrayOfKeys = filterArrayByKey(arrayOfValues, keyCallback);
|
|
return mappedRootObject.remove(function (item) {
|
|
return ko.utils.arrayIndexOf(arrayOfKeys, keyCallback(item)) != -1;
|
|
});
|
|
}
|
|
|
|
mappedRootObject.mappedDestroy = function (valueOrPredicate) {
|
|
var predicate = typeof valueOrPredicate == "function" ? valueOrPredicate : function (value) {
|
|
return value === keyCallback(valueOrPredicate);
|
|
};
|
|
return mappedRootObject.destroy(function (item) {
|
|
return predicate(keyCallback(item));
|
|
});
|
|
}
|
|
|
|
mappedRootObject.mappedDestroyAll = function (arrayOfValues) {
|
|
var arrayOfKeys = filterArrayByKey(arrayOfValues, keyCallback);
|
|
return mappedRootObject.destroy(function (item) {
|
|
return ko.utils.arrayIndexOf(arrayOfKeys, keyCallback(item)) != -1;
|
|
});
|
|
}
|
|
|
|
mappedRootObject.mappedIndexOf = function (item) {
|
|
var keys = filterArrayByKey(mappedRootObject(), keyCallback);
|
|
var key = keyCallback(item);
|
|
return ko.utils.arrayIndexOf(keys, key);
|
|
}
|
|
|
|
mappedRootObject.mappedCreate = function (value) {
|
|
if (mappedRootObject.mappedIndexOf(value) !== -1) {
|
|
throw new Error("There already is an object with the key that you specified.");
|
|
}
|
|
|
|
var item = hasCreateCallback() ? createCallback(value) : value;
|
|
if (hasUpdateCallback()) {
|
|
var newValue = updateCallback(item, value);
|
|
if (ko.isWriteableObservable(item)) {
|
|
item(newValue);
|
|
} else {
|
|
item = newValue;
|
|
}
|
|
}
|
|
mappedRootObject.push(item);
|
|
return item;
|
|
}
|
|
}
|
|
|
|
var currentArrayKeys = filterArrayByKey(ko.utils.unwrapObservable(mappedRootObject), keyCallback).sort();
|
|
var newArrayKeys = filterArrayByKey(rootObject, keyCallback);
|
|
if (hasKeyCallback) newArrayKeys.sort();
|
|
var editScript = ko.utils.compareArrays(currentArrayKeys, newArrayKeys);
|
|
|
|
var ignoreIndexOf = {};
|
|
|
|
var newContents = [];
|
|
for (var i = 0, j = editScript.length; i < j; i++) {
|
|
var key = editScript[i];
|
|
var mappedItem;
|
|
var fullPropertyName = getPropertyName(parentPropertyName, rootObject, i);
|
|
switch (key.status) {
|
|
case "added":
|
|
var item = getItemByKey(ko.utils.unwrapObservable(rootObject), key.value, keyCallback);
|
|
mappedItem = updateViewModel(undefined, item, options, parentName, mappedRootObject, fullPropertyName);
|
|
if(!hasCreateCallback()) {
|
|
mappedItem = ko.utils.unwrapObservable(mappedItem);
|
|
}
|
|
|
|
var index = ignorableIndexOf(ko.utils.unwrapObservable(rootObject), item, ignoreIndexOf);
|
|
newContents[index] = mappedItem;
|
|
ignoreIndexOf[index] = true;
|
|
break;
|
|
case "retained":
|
|
var item = getItemByKey(ko.utils.unwrapObservable(rootObject), key.value, keyCallback);
|
|
mappedItem = getItemByKey(mappedRootObject, key.value, keyCallback);
|
|
updateViewModel(mappedItem, item, options, parentName, mappedRootObject, fullPropertyName);
|
|
|
|
var index = ignorableIndexOf(ko.utils.unwrapObservable(rootObject), item, ignoreIndexOf);
|
|
newContents[index] = mappedItem;
|
|
ignoreIndexOf[index] = true;
|
|
break;
|
|
case "deleted":
|
|
mappedItem = getItemByKey(mappedRootObject, key.value, keyCallback);
|
|
break;
|
|
}
|
|
|
|
changes.push({
|
|
event: key.status,
|
|
item: mappedItem
|
|
});
|
|
}
|
|
|
|
mappedRootObject(newContents);
|
|
|
|
var arrayChangedCallback = getCallback("arrayChanged");
|
|
if (arrayChangedCallback instanceof Function) {
|
|
ko.utils.arrayForEach(changes, function (change) {
|
|
arrayChangedCallback(change.event, change.item);
|
|
});
|
|
}
|
|
}
|
|
|
|
return mappedRootObject;
|
|
}
|
|
|
|
function ignorableIndexOf(array, item, ignoreIndices) {
|
|
for (var i = 0, j = array.length; i < j; i++) {
|
|
if (ignoreIndices[i] === true) continue;
|
|
if (array[i] === item) return i;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
function mapKey(item, callback) {
|
|
var mappedItem;
|
|
if (callback) mappedItem = callback(item);
|
|
if (exports.getType(mappedItem) === "undefined") mappedItem = item;
|
|
|
|
return ko.utils.unwrapObservable(mappedItem);
|
|
}
|
|
|
|
function getItemByKey(array, key, callback) {
|
|
var filtered = ko.utils.arrayFilter(ko.utils.unwrapObservable(array), function (item) {
|
|
return mapKey(item, callback) === key;
|
|
});
|
|
|
|
if (filtered.length == 0) throw new Error("When calling ko.update*, the key '" + key + "' was not found!");
|
|
if ((filtered.length > 1) && (canHaveProperties(filtered[0]))) throw new Error("When calling ko.update*, the key '" + key + "' was not unique!");
|
|
|
|
return filtered[0];
|
|
}
|
|
|
|
function filterArrayByKey(array, callback) {
|
|
return ko.utils.arrayMap(ko.utils.unwrapObservable(array), function (item) {
|
|
if (callback) {
|
|
return mapKey(item, callback);
|
|
} else {
|
|
return item;
|
|
}
|
|
});
|
|
}
|
|
|
|
function visitPropertiesOrArrayEntries(rootObject, visitorCallback) {
|
|
if (rootObject instanceof Array) {
|
|
for (var i = 0; i < rootObject.length; i++)
|
|
visitorCallback(i);
|
|
} else {
|
|
for (var propertyName in rootObject)
|
|
visitorCallback(propertyName);
|
|
}
|
|
};
|
|
|
|
function canHaveProperties(object) {
|
|
var type = exports.getType(object);
|
|
return (type === "object" || type === "array") && (object !== null) && (type !== "undefined");
|
|
}
|
|
|
|
// Based on the parentName, this creates a fully classified name of a property
|
|
|
|
function getPropertyName(parentName, parent, indexer) {
|
|
var propertyName = parentName || "";
|
|
if (parent instanceof Array) {
|
|
if (parentName) {
|
|
propertyName += "[" + indexer + "]";
|
|
}
|
|
} else {
|
|
if (parentName) {
|
|
propertyName += ".";
|
|
}
|
|
propertyName += indexer;
|
|
}
|
|
return propertyName;
|
|
}
|
|
|
|
function visitModel(rootObject, callback, options, parentName, fullParentName) {
|
|
// If nested object was already mapped previously, take the options from it
|
|
if (parentName !== undefined && exports.isMapped(rootObject)) {
|
|
//options = ko.utils.unwrapObservable(rootObject)[mappingProperty];
|
|
options = mergeOptions(ko.utils.unwrapObservable(rootObject)[mappingProperty], options);
|
|
parentName = "";
|
|
}
|
|
|
|
if (parentName === undefined) { // the first call
|
|
visitedObjects = new objectLookup();
|
|
}
|
|
|
|
parentName = parentName || "";
|
|
|
|
var mappedRootObject;
|
|
var unwrappedRootObject = ko.utils.unwrapObservable(rootObject);
|
|
if (!canHaveProperties(unwrappedRootObject)) {
|
|
return callback(rootObject, fullParentName);
|
|
} else {
|
|
// Only do a callback, but ignore the results
|
|
callback(rootObject, fullParentName);
|
|
mappedRootObject = unwrappedRootObject instanceof Array ? [] : {};
|
|
}
|
|
|
|
visitedObjects.save(rootObject, mappedRootObject);
|
|
|
|
var origFullParentName = fullParentName;
|
|
visitPropertiesOrArrayEntries(unwrappedRootObject, function (indexer) {
|
|
if (options.ignore && ko.utils.arrayIndexOf(options.ignore, indexer) != -1) return;
|
|
|
|
var propertyValue = unwrappedRootObject[indexer];
|
|
var fullPropertyName = getPropertyName(parentName, unwrappedRootObject, indexer);
|
|
|
|
// If we don't want to explicitly copy the unmapped property...
|
|
if (ko.utils.arrayIndexOf(options.copy, indexer) === -1) {
|
|
// ...find out if it's a property we want to explicitly include
|
|
if (ko.utils.arrayIndexOf(options.include, indexer) === -1) {
|
|
// Options contains all the properties that were part of the original object.
|
|
// If a property does not exist, and it is not because it is part of an array (e.g. "myProp[3]"), then it should not be unmapped.
|
|
if (options.mappedProperties && !options.mappedProperties[fullPropertyName] && !(unwrappedRootObject instanceof Array)) {
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
fullParentName = getPropertyName(origFullParentName, unwrappedRootObject, indexer);
|
|
|
|
var propertyType = exports.getType(ko.utils.unwrapObservable(propertyValue));
|
|
switch (propertyType) {
|
|
case "object":
|
|
case "array":
|
|
case "undefined":
|
|
var previouslyMappedValue = visitedObjects.get(propertyValue);
|
|
mappedRootObject[indexer] = (exports.getType(previouslyMappedValue) !== "undefined") ? previouslyMappedValue : visitModel(propertyValue, callback, options, fullPropertyName, fullParentName);
|
|
break;
|
|
default:
|
|
mappedRootObject[indexer] = callback(propertyValue, fullParentName);
|
|
}
|
|
});
|
|
|
|
return mappedRootObject;
|
|
}
|
|
|
|
function objectLookup() {
|
|
var keys = [];
|
|
var values = [];
|
|
this.save = function (key, value) {
|
|
var existingIndex = ko.utils.arrayIndexOf(keys, key);
|
|
if (existingIndex >= 0) values[existingIndex] = value;
|
|
else {
|
|
keys.push(key);
|
|
values.push(value);
|
|
}
|
|
};
|
|
this.get = function (key) {
|
|
var existingIndex = ko.utils.arrayIndexOf(keys, key);
|
|
return (existingIndex >= 0) ? values[existingIndex] : undefined;
|
|
};
|
|
};
|
|
})); |