├── .gitignore
├── HISTORY.md
├── LICENSE
├── Package.nuspec
├── README.md
├── build
    ├── build-linux
    ├── output
    │   ├── knockout.mapping-latest.debug.js
    │   └── knockout.mapping-latest.js
    ├── tools
    │   ├── curl.exe
    │   └── searchReplace.js
    └── version-header.js
├── knockout.mapping.js
└── spec
    ├── issues.js
    ├── lib
        ├── json2.js
        ├── qunit-1.10.0.css
        └── qunit-1.10.0.js
    ├── mappingBehaviors.js
    ├── proxyDependentObservableBehaviors.js
    └── runner.html


/.gitignore:
--------------------------------------------------------------------------------
 1 | *.suo
 2 | *.csproj.user
 3 | bin
 4 | obj
 5 | *.pdb
 6 | _ReSharper*
 7 | *.ReSharper.user
 8 | *.ReSharper
 9 | desktop.ini
10 | .eprj


--------------------------------------------------------------------------------
/HISTORY.md:
--------------------------------------------------------------------------------
 1 | Release 2.4.1 - February 8th, 2013
 2 | 
 3 | * Added mappedGet for observable arrays
 4 | * Issue #134: Throttle issue using mapping
 5 | * Issue #135: Why is custom update for observableArray firing twice when using mapping plugin?
 6 | 
 7 | Release 2.4.0 - February 4th, 2013
 8 | 
 9 | * Removed asynchronous processing that was used to reset mapping nesting
10 | * Improved getType performance
11 | 
12 | Release 2.3.5 - December 10th, 2012
13 | 
14 | * Issue #121: Added functionality so that explicit declared none observable members on a ViewModel will remain none observable after mapping
15 | 
16 | Release 2.3.4 - November 22nd, 2012
17 | 
18 | * Issue #114: Added new "observe" array to options
19 | 
20 | Release 2.3.3 - October 30th, 2012
21 | 
22 | * Fixed issue #105, #111: Update callback is not being called
23 | * Fixed issue #107: String values in mapping cause infinite recursion in extendObject
24 | 
25 | Release 2.3.2 - August 20th, 2012
26 | 
27 | * Fixed issue #86: Don't update properties on object with update callback
28 | 
29 | Release 2.3.1 - August 6th, 2012
30 | 
31 | * Fixed issue #33: Create method in mappings receive meaningless options.parent for observableArray properties
32 | * Fixed issue #99: Updating throttled observable
33 | * Fixed issue #100: private variable leaks onto window object
34 | 
35 | Release 2.3.0 - July 31st, 2012
36 | 
37 | * Added support for not mapping certain array elements (return "options.skip" from your create callback)
38 | * Fixed issue #91: "wrap" function makes computed writable
39 | * Fixed issue #94: Bug/problem with ignore argument in mapping.fromJS
40 | 
41 | Release 2.2.4


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT) - http://www.opensource.org/licenses/mit-license.php
 2 | 
 3 | Copyright (c) Steven Sanderson, Roy Jacobs
 4 | http://knockoutjs.com/documentation/plugins-mapping.html
 5 | 
 6 | Permission is hereby granted, free of charge, to any person obtaining a copy
 7 | of this software and associated documentation files (the "Software"), to deal
 8 | in the Software without restriction, including without limitation the rights
 9 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 | copies of the Software, and to permit persons to whom the Software is
11 | furnished to do so, subject to the following conditions:
12 | 
13 | The above copyright notice and this permission notice shall be included in
14 | all copies or substantial portions of the Software.
15 | 
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 | THE SOFTWARE.
23 | 


--------------------------------------------------------------------------------
/Package.nuspec:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0"?>
 2 | <package xmlns="http://schemas.microsoft.com/packaging/2010/07/nuspec.xsd">
 3 |   <metadata>
 4 |     <id>Knockout.Mapping</id>
 5 |     <version>2.4.1</version>
 6 |     <authors>Roy Jacobs</authors>
 7 |     <licenseUrl>http://www.opensource.org/licenses/mit-license.php</licenseUrl>
 8 |     <projectUrl>http://knockoutjs.com/documentation/plugins-mapping.html</projectUrl>
 9 |     <requireLicenseAcceptance>false</requireLicenseAcceptance>
10 |     <description>The mapping plugin gives you a straightforward way to map plain JavaScript objects into a view model with the appropriate Knockout observables. This is an alternative to manually writing your own JavaScript code that constructs a view model based on some data you've fetched from the server.</description>
11 |     <dependencies>
12 |       <dependency id="knockoutjs" version="2.0.0" />
13 |     </dependencies>
14 |   </metadata>
15 |   <files>
16 |     <file src="build\output\*.*" target="Content\scripts" /> 
17 |   </files>
18 | </package>


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | Object mapping plugin for [Knockout](http://knockoutjs.com/) - Find the documentation [here](http://knockoutjs.com/documentation/plugins-mapping.html).
2 | READ THIS
3 | ---
4 | Due to lack of time this project is currently not actively maintained. Feel free to be a hero-- step up and [fork this repo](https://github.com/SteveSanderson/knockout.mapping/fork)!
5 | 


--------------------------------------------------------------------------------
/build/build-linux:
--------------------------------------------------------------------------------
 1 | #!/bin/sh
 2 | 
 3 | SourceFiles=
 4 | 
 5 | # Now call Google Closure Compiler to produce a minified version
 6 | cp ../knockout.mapping.js output/knockout.mapping-latest.debug.js
 7 | sed -i~ -e "s/var DEBUG=true;/\/**@const*\/var DEBUG=false;/g" output/knockout.mapping-latest.debug.js
 8 | curl -d output_info=compiled_code -d output_format=text -d compilation_level=SIMPLE_OPTIMIZATIONS --data-urlencode js_code@output/knockout.mapping-latest.debug.js "http://closure-compiler.appspot.com/compile" >> output/knockout.mapping-latest.js~
 9 | cat version-header.js output/knockout.mapping-latest.js~ > output/knockout.mapping-latest.js
10 | 
11 | cat version-header.js ../knockout.mapping.js > output/knockout.mapping-latest.debug.js
12 | 
13 | rm -f output/*.js~


--------------------------------------------------------------------------------
/build/output/knockout.mapping-latest.debug.js:
--------------------------------------------------------------------------------
  1 | /// Knockout Mapping plugin v2.4.1
  2 | /// (c) 2013 Steven Sanderson, Roy Jacobs - http://knockoutjs.com/
  3 | /// License: MIT (http://www.opensource.org/licenses/mit-license.php)
  4 | (function (factory) {
  5 | 	// Module systems magic dance.
  6 | 
  7 | 	if (typeof require === "function" && typeof exports === "object" && typeof module === "object") {
  8 | 		// CommonJS or Node: hard-coded dependency on "knockout"
  9 | 		factory(require("knockout"), exports);
 10 | 	} else if (typeof define === "function" && define["amd"]) {
 11 | 		// AMD anonymous module with hard-coded dependency on "knockout"
 12 | 		define(["knockout", "exports"], factory);
 13 | 	} else {
 14 | 		// <script> tag: use the global `ko` object, attaching a `mapping` property
 15 | 		factory(ko, ko.mapping = {});
 16 | 	}
 17 | }(function (ko, exports) {
 18 | 	var DEBUG=true;
 19 | 	var mappingProperty = "__ko_mapping__";
 20 | 	var realKoDependentObservable = ko.dependentObservable;
 21 | 	var mappingNesting = 0;
 22 | 	var dependentObservables;
 23 | 	var visitedObjects;
 24 | 	var recognizedRootProperties = ["create", "update", "key", "arrayChanged"];
 25 | 	var emptyReturn = {};
 26 | 
 27 | 	var _defaultOptions = {
 28 | 		include: ["_destroy"],
 29 | 		ignore: [],
 30 | 		copy: [],
 31 | 		observe: []
 32 | 	};
 33 | 	var defaultOptions = _defaultOptions;
 34 | 
 35 | 	// Author: KennyTM @ StackOverflow
 36 | 	function unionArrays (x, y) {
 37 | 		var obj = {};
 38 | 		for (var i = x.length - 1; i >= 0; -- i) obj[x[i]] = x[i];
 39 | 		for (var i = y.length - 1; i >= 0; -- i) obj[y[i]] = y[i];
 40 | 		var res = [];
 41 | 
 42 | 		for (var k in obj) {
 43 | 			res.push(obj[k]);
 44 | 		};
 45 | 
 46 | 		return res;
 47 | 	}
 48 | 
 49 | 	function extendObject(destination, source) {
 50 | 		var destType;
 51 | 
 52 | 		for (var key in source) {
 53 | 			if (source.hasOwnProperty(key) && source[key]) {
 54 | 				destType = exports.getType(destination[key]);
 55 | 				if (key && destination[key] && destType !== "array" && destType !== "string") {
 56 | 					extendObject(destination[key], source[key]);
 57 | 				} else {
 58 | 					var bothArrays = exports.getType(destination[key]) === "array" && exports.getType(source[key]) === "array";
 59 | 					if (bothArrays) {
 60 | 						destination[key] = unionArrays(destination[key], source[key]);
 61 | 					} else {
 62 | 						destination[key] = source[key];
 63 | 					}
 64 | 				}
 65 | 			}
 66 | 		}
 67 | 	}
 68 | 
 69 | 	function merge(obj1, obj2) {
 70 | 		var merged = {};
 71 | 		extendObject(merged, obj1);
 72 | 		extendObject(merged, obj2);
 73 | 
 74 | 		return merged;
 75 | 	}
 76 | 
 77 | 	exports.isMapped = function (viewModel) {
 78 | 		var unwrapped = ko.utils.unwrapObservable(viewModel);
 79 | 		return unwrapped && unwrapped[mappingProperty];
 80 | 	}
 81 | 
 82 | 	exports.fromJS = function (jsObject /*, inputOptions, target*/ ) {
 83 | 		if (arguments.length == 0) throw new Error("When calling ko.fromJS, pass the object you want to convert.");
 84 | 
 85 | 		try {
 86 | 			if (!mappingNesting++) {
 87 | 				dependentObservables = [];
 88 | 				visitedObjects = new objectLookup();
 89 | 			}
 90 | 
 91 | 			var options;
 92 | 			var target;
 93 | 
 94 | 			if (arguments.length == 2) {
 95 | 				if (arguments[1][mappingProperty]) {
 96 | 					target = arguments[1];
 97 | 				} else {
 98 | 					options = arguments[1];
 99 | 				}
100 | 			}
101 | 			if (arguments.length == 3) {
102 | 				options = arguments[1];
103 | 				target = arguments[2];
104 | 			}
105 | 
106 | 			if (target) {
107 | 				options = merge(options, target[mappingProperty]);
108 | 			}
109 | 			options = fillOptions(options);
110 | 
111 | 			var result = updateViewModel(target, jsObject, options);
112 | 			if (target) {
113 | 				result = target;
114 | 			}
115 | 
116 | 			// Evaluate any dependent observables that were proxied.
117 | 			// Do this after the model's observables have been created
118 | 			if (!--mappingNesting) {
119 | 				while (dependentObservables.length) {
120 | 					var DO = dependentObservables.pop();
121 | 					if (DO) {
122 | 						DO();
123 | 						
124 | 						// Move this magic property to the underlying dependent observable
125 | 						DO.__DO["throttleEvaluation"] = DO["throttleEvaluation"];
126 | 					}
127 | 				}
128 | 			}
129 | 
130 | 			// Save any new mapping options in the view model, so that updateFromJS can use them later.
131 | 			result[mappingProperty] = merge(result[mappingProperty], options);
132 | 
133 | 			return result;
134 | 		} catch(e) {
135 | 			mappingNesting = 0;
136 | 			throw e;
137 | 		}
138 | 	};
139 | 
140 | 	exports.fromJSON = function (jsonString /*, options, target*/ ) {
141 | 		var parsed = ko.utils.parseJson(jsonString);
142 | 		arguments[0] = parsed;
143 | 		return exports.fromJS.apply(this, arguments);
144 | 	};
145 | 
146 | 	exports.updateFromJS = function (viewModel) {
147 | 		throw new Error("ko.mapping.updateFromJS, use ko.mapping.fromJS instead. Please note that the order of parameters is different!");
148 | 	};
149 | 
150 | 	exports.updateFromJSON = function (viewModel) {
151 | 		throw new Error("ko.mapping.updateFromJSON, use ko.mapping.fromJSON instead. Please note that the order of parameters is different!");
152 | 	};
153 | 
154 | 	exports.toJS = function (rootObject, options) {
155 | 		if (!defaultOptions) exports.resetDefaultOptions();
156 | 
157 | 		if (arguments.length == 0) throw new Error("When calling ko.mapping.toJS, pass the object you want to convert.");
158 | 		if (exports.getType(defaultOptions.ignore) !== "array") throw new Error("ko.mapping.defaultOptions().ignore should be an array.");
159 | 		if (exports.getType(defaultOptions.include) !== "array") throw new Error("ko.mapping.defaultOptions().include should be an array.");
160 | 		if (exports.getType(defaultOptions.copy) !== "array") throw new Error("ko.mapping.defaultOptions().copy should be an array.");
161 | 
162 | 		// Merge in the options used in fromJS
163 | 		options = fillOptions(options, rootObject[mappingProperty]);
164 | 
165 | 		// We just unwrap everything at every level in the object graph
166 | 		return exports.visitModel(rootObject, function (x) {
167 | 			return ko.utils.unwrapObservable(x)
168 | 		}, options);
169 | 	};
170 | 
171 | 	exports.toJSON = function (rootObject, options) {
172 | 		var plainJavaScriptObject = exports.toJS(rootObject, options);
173 | 		return ko.utils.stringifyJson(plainJavaScriptObject);
174 | 	};
175 | 
176 | 	exports.defaultOptions = function () {
177 | 		if (arguments.length > 0) {
178 | 			defaultOptions = arguments[0];
179 | 		} else {
180 | 			return defaultOptions;
181 | 		}
182 | 	};
183 | 
184 | 	exports.resetDefaultOptions = function () {
185 | 		defaultOptions = {
186 | 			include: _defaultOptions.include.slice(0),
187 | 			ignore: _defaultOptions.ignore.slice(0),
188 | 			copy: _defaultOptions.copy.slice(0)
189 | 		};
190 | 	};
191 | 
192 | 	exports.getType = function(x) {
193 | 		if ((x) && (typeof (x) === "object")) {
194 | 			if (x.constructor === Date) return "date";
195 | 			if (x.constructor === Array) return "array";
196 | 		}
197 | 		return typeof x;
198 | 	}
199 | 
200 | 	function fillOptions(rawOptions, otherOptions) {
201 | 		var options = merge({}, rawOptions);
202 | 
203 | 		// Move recognized root-level properties into a root namespace
204 | 		for (var i = recognizedRootProperties.length - 1; i >= 0; i--) {
205 | 			var property = recognizedRootProperties[i];
206 | 			
207 | 			// Carry on, unless this property is present
208 | 			if (!options[property]) continue;
209 | 			
210 | 			// Move the property into the root namespace
211 | 			if (!(options[""] instanceof Object)) options[""] = {};
212 | 			options[""][property] = options[property];
213 | 			delete options[property];
214 | 		}
215 | 
216 | 		if (otherOptions) {
217 | 			options.ignore = mergeArrays(otherOptions.ignore, options.ignore);
218 | 			options.include = mergeArrays(otherOptions.include, options.include);
219 | 			options.copy = mergeArrays(otherOptions.copy, options.copy);
220 | 			options.observe = mergeArrays(otherOptions.observe, options.observe);
221 | 		}
222 | 		options.ignore = mergeArrays(options.ignore, defaultOptions.ignore);
223 | 		options.include = mergeArrays(options.include, defaultOptions.include);
224 | 		options.copy = mergeArrays(options.copy, defaultOptions.copy);
225 | 		options.observe = mergeArrays(options.observe, defaultOptions.observe);
226 | 
227 | 		options.mappedProperties = options.mappedProperties || {};
228 | 		options.copiedProperties = options.copiedProperties || {};
229 | 		return options;
230 | 	}
231 | 
232 | 	function mergeArrays(a, b) {
233 | 		if (exports.getType(a) !== "array") {
234 | 			if (exports.getType(a) === "undefined") a = [];
235 | 			else a = [a];
236 | 		}
237 | 		if (exports.getType(b) !== "array") {
238 | 			if (exports.getType(b) === "undefined") b = [];
239 | 			else b = [b];
240 | 		}
241 | 
242 | 		return ko.utils.arrayGetDistinctValues(a.concat(b));
243 | 	}
244 | 
245 | 	// When using a 'create' callback, we proxy the dependent observable so that it doesn't immediately evaluate on creation.
246 | 	// The reason is that the dependent observables in the user-specified callback may contain references to properties that have not been mapped yet.
247 | 	function withProxyDependentObservable(dependentObservables, callback) {
248 | 		var localDO = ko.dependentObservable;
249 | 		ko.dependentObservable = function (read, owner, options) {
250 | 			options = options || {};
251 | 
252 | 			if (read && typeof read == "object") { // mirrors condition in knockout implementation of DO's
253 | 				options = read;
254 | 			}
255 | 
256 | 			var realDeferEvaluation = options.deferEvaluation;
257 | 
258 | 			var isRemoved = false;
259 | 
260 | 			// We wrap the original dependent observable so that we can remove it from the 'dependentObservables' list we need to evaluate after mapping has
261 | 			// completed if the user already evaluated the DO themselves in the meantime.
262 | 			var wrap = function (DO) {
263 | 				// Temporarily revert ko.dependentObservable, since it is used in ko.isWriteableObservable
264 | 				var tmp = ko.dependentObservable;
265 | 				ko.dependentObservable = realKoDependentObservable;
266 | 				var isWriteable = ko.isWriteableObservable(DO);
267 | 				ko.dependentObservable = tmp;
268 | 
269 | 				var wrapped = realKoDependentObservable({
270 | 					read: function () {
271 | 						if (!isRemoved) {
272 | 							ko.utils.arrayRemoveItem(dependentObservables, DO);
273 | 							isRemoved = true;
274 | 						}
275 | 						return DO.apply(DO, arguments);
276 | 					},
277 | 					write: isWriteable && function (val) {
278 | 						return DO(val);
279 | 					},
280 | 					deferEvaluation: true
281 | 				});
282 | 				if (DEBUG) wrapped._wrapper = true;
283 | 				wrapped.__DO = DO;
284 | 				return wrapped;
285 | 			};
286 | 			
287 | 			options.deferEvaluation = true; // will either set for just options, or both read/options.
288 | 			var realDependentObservable = new realKoDependentObservable(read, owner, options);
289 | 
290 | 			if (!realDeferEvaluation) {
291 | 				realDependentObservable = wrap(realDependentObservable);
292 | 				dependentObservables.push(realDependentObservable);
293 | 			}
294 | 
295 | 			return realDependentObservable;
296 | 		}
297 | 		ko.dependentObservable.fn = realKoDependentObservable.fn;
298 | 		ko.computed = ko.dependentObservable;
299 | 		var result = callback();
300 | 		ko.dependentObservable = localDO;
301 | 		ko.computed = ko.dependentObservable;
302 | 		return result;
303 | 	}
304 | 
305 | 	function updateViewModel(mappedRootObject, rootObject, options, parentName, parent, parentPropertyName, mappedParent) {
306 | 		var isArray = exports.getType(ko.utils.unwrapObservable(rootObject)) === "array";
307 | 
308 | 		parentPropertyName = parentPropertyName || "";
309 | 
310 | 		// If this object was already mapped previously, take the options from there and merge them with our existing ones.
311 | 		if (exports.isMapped(mappedRootObject)) {
312 | 			var previousMapping = ko.utils.unwrapObservable(mappedRootObject)[mappingProperty];
313 | 			options = merge(previousMapping, options);
314 | 		}
315 | 
316 | 		var callbackParams = {
317 | 			data: rootObject,
318 | 			parent: mappedParent || parent
319 | 		};
320 | 
321 | 		var hasCreateCallback = function () {
322 | 			return options[parentName] && options[parentName].create instanceof Function;
323 | 		};
324 | 
325 | 		var createCallback = function (data) {
326 | 			return withProxyDependentObservable(dependentObservables, function () {
327 | 				
328 | 				if (ko.utils.unwrapObservable(parent) instanceof Array) {
329 | 					return options[parentName].create({
330 | 						data: data || callbackParams.data,
331 | 						parent: callbackParams.parent,
332 | 						skip: emptyReturn
333 | 					});
334 | 				} else {
335 | 					return options[parentName].create({
336 | 						data: data || callbackParams.data,
337 | 						parent: callbackParams.parent
338 | 					});
339 | 				}				
340 | 			});
341 | 		};
342 | 
343 | 		var hasUpdateCallback = function () {
344 | 			return options[parentName] && options[parentName].update instanceof Function;
345 | 		};
346 | 
347 | 		var updateCallback = function (obj, data) {
348 | 			var params = {
349 | 				data: data || callbackParams.data,
350 | 				parent: callbackParams.parent,
351 | 				target: ko.utils.unwrapObservable(obj)
352 | 			};
353 | 
354 | 			if (ko.isWriteableObservable(obj)) {
355 | 				params.observable = obj;
356 | 			}
357 | 
358 | 			return options[parentName].update(params);
359 | 		}
360 | 
361 | 		var alreadyMapped = visitedObjects.get(rootObject);
362 | 		if (alreadyMapped) {
363 | 			return alreadyMapped;
364 | 		}
365 | 
366 | 		parentName = parentName || "";
367 | 
368 | 		if (!isArray) {
369 | 			// For atomic types, do a direct update on the observable
370 | 			if (!canHaveProperties(rootObject)) {
371 | 				switch (exports.getType(rootObject)) {
372 | 				case "function":
373 | 					if (hasUpdateCallback()) {
374 | 						if (ko.isWriteableObservable(rootObject)) {
375 | 							rootObject(updateCallback(rootObject));
376 | 							mappedRootObject = rootObject;
377 | 						} else {
378 | 							mappedRootObject = updateCallback(rootObject);
379 | 						}
380 | 					} else {
381 | 						mappedRootObject = rootObject;
382 | 					}
383 | 					break;
384 | 				default:
385 | 					if (ko.isWriteableObservable(mappedRootObject)) {
386 | 						if (hasUpdateCallback()) {
387 | 							var valueToWrite = updateCallback(mappedRootObject);
388 | 							mappedRootObject(valueToWrite);
389 | 							return valueToWrite;
390 | 						} else {
391 | 							var valueToWrite = ko.utils.unwrapObservable(rootObject);
392 | 							mappedRootObject(valueToWrite);
393 | 							return valueToWrite;
394 | 						}
395 | 					} else {
396 | 						var hasCreateOrUpdateCallback = hasCreateCallback() || hasUpdateCallback();
397 | 						
398 | 						if (hasCreateCallback()) {
399 | 							mappedRootObject = createCallback();
400 | 						} else {
401 | 							mappedRootObject = ko.observable(ko.utils.unwrapObservable(rootObject));
402 | 						}
403 | 
404 | 						if (hasUpdateCallback()) {
405 | 							mappedRootObject(updateCallback(mappedRootObject));
406 | 						}
407 | 						
408 | 						if (hasCreateOrUpdateCallback) return mappedRootObject;
409 | 					}
410 | 				}
411 | 
412 | 			} else {
413 | 				mappedRootObject = ko.utils.unwrapObservable(mappedRootObject);
414 | 				if (!mappedRootObject) {
415 | 					if (hasCreateCallback()) {
416 | 						var result = createCallback();
417 | 
418 | 						if (hasUpdateCallback()) {
419 | 							result = updateCallback(result);
420 | 						}
421 | 
422 | 						return result;
423 | 					} else {
424 | 						if (hasUpdateCallback()) {
425 | 							return updateCallback(result);
426 | 						}
427 | 
428 | 						mappedRootObject = {};
429 | 					}
430 | 				}
431 | 
432 | 				if (hasUpdateCallback()) {
433 | 					mappedRootObject = updateCallback(mappedRootObject);
434 | 				}
435 | 
436 | 				visitedObjects.save(rootObject, mappedRootObject);
437 | 				if (hasUpdateCallback()) return mappedRootObject;
438 | 
439 | 				// For non-atomic types, visit all properties and update recursively
440 | 				visitPropertiesOrArrayEntries(rootObject, function (indexer) {
441 | 					var fullPropertyName = parentPropertyName.length ? parentPropertyName + "." + indexer : indexer;
442 | 
443 | 					if (ko.utils.arrayIndexOf(options.ignore, fullPropertyName) != -1) {
444 | 						return;
445 | 					}
446 | 
447 | 					if (ko.utils.arrayIndexOf(options.copy, fullPropertyName) != -1) {
448 | 						mappedRootObject[indexer] = rootObject[indexer];
449 | 						return;
450 | 					}
451 | 
452 | 					if(typeof rootObject[indexer] != "object" && typeof rootObject[indexer] != "array" && options.observe.length > 0 && ko.utils.arrayIndexOf(options.observe, fullPropertyName) == -1)
453 | 					{
454 | 						mappedRootObject[indexer] = rootObject[indexer];
455 | 						options.copiedProperties[fullPropertyName] = true;
456 | 						return;
457 | 					}
458 | 					
459 | 					// In case we are adding an already mapped property, fill it with the previously mapped property value to prevent recursion.
460 | 					// If this is a property that was generated by fromJS, we should use the options specified there
461 | 					var prevMappedProperty = visitedObjects.get(rootObject[indexer]);
462 | 					var retval = updateViewModel(mappedRootObject[indexer], rootObject[indexer], options, indexer, mappedRootObject, fullPropertyName, mappedRootObject);
463 | 					var value = prevMappedProperty || retval;
464 | 					
465 | 					if(options.observe.length > 0 && ko.utils.arrayIndexOf(options.observe, fullPropertyName) == -1)
466 | 					{
467 | 						mappedRootObject[indexer] = value();
468 | 						options.copiedProperties[fullPropertyName] = true;
469 | 						return;
470 | 					}
471 | 					
472 | 					if (ko.isWriteableObservable(mappedRootObject[indexer])) {
473 | 						value = ko.utils.unwrapObservable(value);
474 | 						if (mappedRootObject[indexer]() !== value) {
475 | 							mappedRootObject[indexer](value);
476 | 						}
477 | 					} else {
478 | 						value = mappedRootObject[indexer] === undefined ? value : ko.utils.unwrapObservable(value);
479 | 						mappedRootObject[indexer] = value;
480 | 					}
481 | 
482 | 					options.mappedProperties[fullPropertyName] = true;
483 | 				});
484 | 			}
485 | 		} else { //mappedRootObject is an array
486 | 			var changes = [];
487 | 
488 | 			var hasKeyCallback = false;
489 | 			var keyCallback = function (x) {
490 | 				return x;
491 | 			}
492 | 			if (options[parentName] && options[parentName].key) {
493 | 				keyCallback = options[parentName].key;
494 | 				hasKeyCallback = true;
495 | 			}
496 | 
497 | 			if (!ko.isObservable(mappedRootObject)) {
498 | 				// When creating the new observable array, also add a bunch of utility functions that take the 'key' of the array items into account.
499 | 				mappedRootObject = ko.observableArray([]);
500 | 
501 | 				mappedRootObject.mappedRemove = function (valueOrPredicate) {
502 | 					var predicate = typeof valueOrPredicate == "function" ? valueOrPredicate : function (value) {
503 | 							return value === keyCallback(valueOrPredicate);
504 | 						};
505 | 					return mappedRootObject.remove(function (item) {
506 | 						return predicate(keyCallback(item));
507 | 					});
508 | 				}
509 | 
510 | 				mappedRootObject.mappedRemoveAll = function (arrayOfValues) {
511 | 					var arrayOfKeys = filterArrayByKey(arrayOfValues, keyCallback);
512 | 					return mappedRootObject.remove(function (item) {
513 | 						return ko.utils.arrayIndexOf(arrayOfKeys, keyCallback(item)) != -1;
514 | 					});
515 | 				}
516 | 
517 | 				mappedRootObject.mappedDestroy = function (valueOrPredicate) {
518 | 					var predicate = typeof valueOrPredicate == "function" ? valueOrPredicate : function (value) {
519 | 							return value === keyCallback(valueOrPredicate);
520 | 						};
521 | 					return mappedRootObject.destroy(function (item) {
522 | 						return predicate(keyCallback(item));
523 | 					});
524 | 				}
525 | 
526 | 				mappedRootObject.mappedDestroyAll = function (arrayOfValues) {
527 | 					var arrayOfKeys = filterArrayByKey(arrayOfValues, keyCallback);
528 | 					return mappedRootObject.destroy(function (item) {
529 | 						return ko.utils.arrayIndexOf(arrayOfKeys, keyCallback(item)) != -1;
530 | 					});
531 | 				}
532 | 
533 | 				mappedRootObject.mappedIndexOf = function (item) {
534 | 					var keys = filterArrayByKey(mappedRootObject(), keyCallback);
535 | 					var key = keyCallback(item);
536 | 					return ko.utils.arrayIndexOf(keys, key);
537 | 				}
538 | 
539 | 				mappedRootObject.mappedGet = function (item) {
540 | 					return mappedRootObject()[mappedRootObject.mappedIndexOf(item)];
541 | 				}
542 | 
543 | 				mappedRootObject.mappedCreate = function (value) {
544 | 					if (mappedRootObject.mappedIndexOf(value) !== -1) {
545 | 						throw new Error("There already is an object with the key that you specified.");
546 | 					}
547 | 
548 | 					var item = hasCreateCallback() ? createCallback(value) : value;
549 | 					if (hasUpdateCallback()) {
550 | 						var newValue = updateCallback(item, value);
551 | 						if (ko.isWriteableObservable(item)) {
552 | 							item(newValue);
553 | 						} else {
554 | 							item = newValue;
555 | 						}
556 | 					}
557 | 					mappedRootObject.push(item);
558 | 					return item;
559 | 				}
560 | 			}
561 | 
562 | 			var currentArrayKeys = filterArrayByKey(ko.utils.unwrapObservable(mappedRootObject), keyCallback).sort();
563 | 			var newArrayKeys = filterArrayByKey(rootObject, keyCallback);
564 | 			if (hasKeyCallback) newArrayKeys.sort();
565 | 			var editScript = ko.utils.compareArrays(currentArrayKeys, newArrayKeys);
566 | 
567 | 			var ignoreIndexOf = {};
568 | 			
569 | 			var i, j;
570 | 
571 | 			var unwrappedRootObject = ko.utils.unwrapObservable(rootObject);
572 | 			var itemsByKey = {};
573 | 			var optimizedKeys = true;
574 | 			for (i = 0, j = unwrappedRootObject.length; i < j; i++) {
575 | 				var key = keyCallback(unwrappedRootObject[i]);
576 | 				if (key === undefined || key instanceof Object) {
577 | 					optimizedKeys = false;
578 | 					break;
579 | 				}
580 | 				itemsByKey[key] = unwrappedRootObject[i];
581 | 			}
582 | 
583 | 			var newContents = [];
584 | 			var passedOver = 0;
585 | 			for (i = 0, j = editScript.length; i < j; i++) {
586 | 				var key = editScript[i];
587 | 				var mappedItem;
588 | 				var fullPropertyName = parentPropertyName + "[" + i + "]";
589 | 				switch (key.status) {
590 | 				case "added":
591 | 					var item = optimizedKeys ? itemsByKey[key.value] : getItemByKey(ko.utils.unwrapObservable(rootObject), key.value, keyCallback);
592 | 					mappedItem = updateViewModel(undefined, item, options, parentName, mappedRootObject, fullPropertyName, parent);
593 | 					if(!hasCreateCallback()) {
594 | 						mappedItem = ko.utils.unwrapObservable(mappedItem);
595 | 					}
596 | 
597 | 					var index = ignorableIndexOf(ko.utils.unwrapObservable(rootObject), item, ignoreIndexOf);
598 | 					
599 | 					if (mappedItem === emptyReturn) {
600 | 						passedOver++;
601 | 					} else {
602 | 						newContents[index - passedOver] = mappedItem;
603 | 					}
604 | 						
605 | 					ignoreIndexOf[index] = true;
606 | 					break;
607 | 				case "retained":
608 | 					var item = optimizedKeys ? itemsByKey[key.value] : getItemByKey(ko.utils.unwrapObservable(rootObject), key.value, keyCallback);
609 | 					mappedItem = getItemByKey(mappedRootObject, key.value, keyCallback);
610 | 					updateViewModel(mappedItem, item, options, parentName, mappedRootObject, fullPropertyName, parent);
611 | 
612 | 					var index = ignorableIndexOf(ko.utils.unwrapObservable(rootObject), item, ignoreIndexOf);
613 | 					newContents[index] = mappedItem;
614 | 					ignoreIndexOf[index] = true;
615 | 					break;
616 | 				case "deleted":
617 | 					mappedItem = getItemByKey(mappedRootObject, key.value, keyCallback);
618 | 					break;
619 | 				}
620 | 
621 | 				changes.push({
622 | 					event: key.status,
623 | 					item: mappedItem
624 | 				});
625 | 			}
626 | 
627 | 			mappedRootObject(newContents);
628 | 
629 | 			if (options[parentName] && options[parentName].arrayChanged) {
630 | 				ko.utils.arrayForEach(changes, function (change) {
631 | 					options[parentName].arrayChanged(change.event, change.item);
632 | 				});
633 | 			}
634 | 		}
635 | 
636 | 		return mappedRootObject;
637 | 	}
638 | 
639 | 	function ignorableIndexOf(array, item, ignoreIndices) {
640 | 		for (var i = 0, j = array.length; i < j; i++) {
641 | 			if (ignoreIndices[i] === true) continue;
642 | 			if (array[i] === item) return i;
643 | 		}
644 | 		return null;
645 | 	}
646 | 
647 | 	function mapKey(item, callback) {
648 | 		var mappedItem;
649 | 		if (callback) mappedItem = callback(item);
650 | 		if (exports.getType(mappedItem) === "undefined") mappedItem = item;
651 | 
652 | 		return ko.utils.unwrapObservable(mappedItem);
653 | 	}
654 | 
655 | 	function getItemByKey(array, key, callback) {
656 | 		array = ko.utils.unwrapObservable(array);
657 | 		for (var i = 0, j = array.length; i < j; i++) {
658 | 			var item = array[i];
659 | 			if (mapKey(item, callback) === key) return item;
660 | 		}
661 | 
662 | 		throw new Error("When calling ko.update*, the key '" + key + "' was not found!");
663 | 	}
664 | 
665 | 	function filterArrayByKey(array, callback) {
666 | 		return ko.utils.arrayMap(ko.utils.unwrapObservable(array), function (item) {
667 | 			if (callback) {
668 | 				return mapKey(item, callback);
669 | 			} else {
670 | 				return item;
671 | 			}
672 | 		});
673 | 	}
674 | 
675 | 	function visitPropertiesOrArrayEntries(rootObject, visitorCallback) {
676 | 		if (exports.getType(rootObject) === "array") {
677 | 			for (var i = 0; i < rootObject.length; i++)
678 | 			visitorCallback(i);
679 | 		} else {
680 | 			for (var propertyName in rootObject)
681 | 			visitorCallback(propertyName);
682 | 		}
683 | 	};
684 | 
685 | 	function canHaveProperties(object) {
686 | 		var type = exports.getType(object);
687 | 		return ((type === "object") || (type === "array")) && (object !== null);
688 | 	}
689 | 
690 | 	// Based on the parentName, this creates a fully classified name of a property
691 | 
692 | 	function getPropertyName(parentName, parent, indexer) {
693 | 		var propertyName = parentName || "";
694 | 		if (exports.getType(parent) === "array") {
695 | 			if (parentName) {
696 | 				propertyName += "[" + indexer + "]";
697 | 			}
698 | 		} else {
699 | 			if (parentName) {
700 | 				propertyName += ".";
701 | 			}
702 | 			propertyName += indexer;
703 | 		}
704 | 		return propertyName;
705 | 	}
706 | 
707 | 	exports.visitModel = function (rootObject, callback, options) {
708 | 		options = options || {};
709 | 		options.visitedObjects = options.visitedObjects || new objectLookup();
710 | 
711 | 		var mappedRootObject;
712 | 		var unwrappedRootObject = ko.utils.unwrapObservable(rootObject);
713 | 
714 | 		if (!canHaveProperties(unwrappedRootObject)) {
715 | 			return callback(rootObject, options.parentName);
716 | 		} else {
717 | 			options = fillOptions(options, unwrappedRootObject[mappingProperty]);
718 | 
719 | 			// Only do a callback, but ignore the results
720 | 			callback(rootObject, options.parentName);
721 | 			mappedRootObject = exports.getType(unwrappedRootObject) === "array" ? [] : {};
722 | 		}
723 | 
724 | 		options.visitedObjects.save(rootObject, mappedRootObject);
725 | 
726 | 		var parentName = options.parentName;
727 | 		visitPropertiesOrArrayEntries(unwrappedRootObject, function (indexer) {
728 | 			if (options.ignore && ko.utils.arrayIndexOf(options.ignore, indexer) != -1) return;
729 | 
730 | 			var propertyValue = unwrappedRootObject[indexer];
731 | 			options.parentName = getPropertyName(parentName, unwrappedRootObject, indexer);
732 | 
733 | 			// If we don't want to explicitly copy the unmapped property...
734 | 			if (ko.utils.arrayIndexOf(options.copy, indexer) === -1) {
735 | 				// ...find out if it's a property we want to explicitly include
736 | 				if (ko.utils.arrayIndexOf(options.include, indexer) === -1) {
737 | 					// The mapped properties object contains all the properties that were part of the original object.
738 | 					// 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.
739 | 				    if (unwrappedRootObject[mappingProperty]
740 | 				        && unwrappedRootObject[mappingProperty].mappedProperties && !unwrappedRootObject[mappingProperty].mappedProperties[indexer]
741 | 				        && unwrappedRootObject[mappingProperty].copiedProperties && !unwrappedRootObject[mappingProperty].copiedProperties[indexer]
742 | 				        && !(exports.getType(unwrappedRootObject) === "array")) {
743 | 						return;
744 | 					}
745 | 				}
746 | 			}
747 | 
748 | 			var outputProperty;
749 | 			switch (exports.getType(ko.utils.unwrapObservable(propertyValue))) {
750 | 			case "object":
751 | 			case "array":
752 | 			case "undefined":
753 | 				var previouslyMappedValue = options.visitedObjects.get(propertyValue);
754 | 				mappedRootObject[indexer] = (exports.getType(previouslyMappedValue) !== "undefined") ? previouslyMappedValue : exports.visitModel(propertyValue, callback, options);
755 | 				break;
756 | 			default:
757 | 				mappedRootObject[indexer] = callback(propertyValue, options.parentName);
758 | 			}
759 | 		});
760 | 
761 | 		return mappedRootObject;
762 | 	}
763 | 
764 | 	function simpleObjectLookup() {
765 | 		var keys = [];
766 | 		var values = [];
767 | 		this.save = function (key, value) {
768 | 			var existingIndex = ko.utils.arrayIndexOf(keys, key);
769 | 			if (existingIndex >= 0) values[existingIndex] = value;
770 | 			else {
771 | 				keys.push(key);
772 | 				values.push(value);
773 | 			}
774 | 		};
775 | 		this.get = function (key) {
776 | 			var existingIndex = ko.utils.arrayIndexOf(keys, key);
777 | 			var value = (existingIndex >= 0) ? values[existingIndex] : undefined;
778 | 			return value;
779 | 		};
780 | 	};
781 | 	
782 | 	function objectLookup() {
783 | 		var buckets = {};
784 | 		
785 | 		var findBucket = function(key) {
786 | 			var bucketKey;
787 | 			try {
788 | 				bucketKey = key;//JSON.stringify(key);
789 | 			}
790 | 			catch (e) {
791 | 				bucketKey = "$$$";
792 | 			}
793 | 
794 | 			var bucket = buckets[bucketKey];
795 | 			if (bucket === undefined) {
796 | 				bucket = new simpleObjectLookup();
797 | 				buckets[bucketKey] = bucket;
798 | 			}
799 | 			return bucket;
800 | 		};
801 | 		
802 | 		this.save = function (key, value) {
803 | 			findBucket(key).save(key, value);
804 | 		};
805 | 		this.get = function (key) {
806 | 			return findBucket(key).get(key);
807 | 		};
808 | 	};
809 | }));
810 | 


--------------------------------------------------------------------------------
/build/output/knockout.mapping-latest.js:
--------------------------------------------------------------------------------
 1 | /// Knockout Mapping plugin v2.4.1
 2 | /// (c) 2013 Steven Sanderson, Roy Jacobs - http://knockoutjs.com/
 3 | /// License: MIT (http://www.opensource.org/licenses/mit-license.php)
 4 | (function(e){"function"===typeof require&&"object"===typeof exports&&"object"===typeof module?e(require("knockout"),exports):"function"===typeof define&&define.amd?define(["knockout","exports"],e):e(ko,ko.mapping={})})(function(e,f){function y(b,c){var a,d;for(d in c)if(c.hasOwnProperty(d)&&c[d])if(a=f.getType(b[d]),d&&b[d]&&"array"!==a&&"string"!==a)y(b[d],c[d]);else if("array"===f.getType(b[d])&&"array"===f.getType(c[d])){a=b;for(var e=d,l=b[d],n=c[d],t={},g=l.length-1;0<=g;--g)t[l[g]]=l[g];for(g=
 5 | n.length-1;0<=g;--g)t[n[g]]=n[g];l=[];n=void 0;for(n in t)l.push(t[n]);a[e]=l}else b[d]=c[d]}function E(b,c){var a={};y(a,b);y(a,c);return a}function z(b,c){for(var a=E({},b),e=L.length-1;0<=e;e--){var f=L[e];a[f]&&(a[""]instanceof Object||(a[""]={}),a[""][f]=a[f],delete a[f])}c&&(a.ignore=h(c.ignore,a.ignore),a.include=h(c.include,a.include),a.copy=h(c.copy,a.copy),a.observe=h(c.observe,a.observe));a.ignore=h(a.ignore,j.ignore);a.include=h(a.include,j.include);a.copy=h(a.copy,j.copy);a.observe=h(a.observe,
 6 | j.observe);a.mappedProperties=a.mappedProperties||{};a.copiedProperties=a.copiedProperties||{};return a}function h(b,c){"array"!==f.getType(b)&&(b="undefined"===f.getType(b)?[]:[b]);"array"!==f.getType(c)&&(c="undefined"===f.getType(c)?[]:[c]);return e.utils.arrayGetDistinctValues(b.concat(c))}function F(b,c,a,d,k,l,n){var t="array"===f.getType(e.utils.unwrapObservable(c));l=l||"";if(f.isMapped(b)){var g=e.utils.unwrapObservable(b)[p];a=E(g,a)}var j=n||k,h=function(){return a[d]&&a[d].create instanceof
 7 | Function},x=function(b){var f=G,g=e.dependentObservable;e.dependentObservable=function(a,b,c){c=c||{};a&&"object"==typeof a&&(c=a);var d=c.deferEvaluation,M=!1;c.deferEvaluation=!0;a=new H(a,b,c);if(!d){var g=a,d=e.dependentObservable;e.dependentObservable=H;a=e.isWriteableObservable(g);e.dependentObservable=d;d=H({read:function(){M||(e.utils.arrayRemoveItem(f,g),M=!0);return g.apply(g,arguments)},write:a&&function(a){return g(a)},deferEvaluation:!0});d.__DO=g;a=d;f.push(a)}return a};e.dependentObservable.fn=
 8 | H.fn;e.computed=e.dependentObservable;b=e.utils.unwrapObservable(k)instanceof Array?a[d].create({data:b||c,parent:j,skip:N}):a[d].create({data:b||c,parent:j});e.dependentObservable=g;e.computed=e.dependentObservable;return b},u=function(){return a[d]&&a[d].update instanceof Function},v=function(b,f){var g={data:f||c,parent:j,target:e.utils.unwrapObservable(b)};e.isWriteableObservable(b)&&(g.observable=b);return a[d].update(g)};if(n=I.get(c))return n;d=d||"";if(t){var t=[],s=!1,m=function(a){return a};
 9 | a[d]&&a[d].key&&(m=a[d].key,s=!0);e.isObservable(b)||(b=e.observableArray([]),b.mappedRemove=function(a){var c="function"==typeof a?a:function(b){return b===m(a)};return b.remove(function(a){return c(m(a))})},b.mappedRemoveAll=function(a){var c=C(a,m);return b.remove(function(a){return-1!=e.utils.arrayIndexOf(c,m(a))})},b.mappedDestroy=function(a){var c="function"==typeof a?a:function(b){return b===m(a)};return b.destroy(function(a){return c(m(a))})},b.mappedDestroyAll=function(a){var c=C(a,m);return b.destroy(function(a){return-1!=
10 | e.utils.arrayIndexOf(c,m(a))})},b.mappedIndexOf=function(a){var c=C(b(),m);a=m(a);return e.utils.arrayIndexOf(c,a)},b.mappedGet=function(a){return b()[b.mappedIndexOf(a)]},b.mappedCreate=function(a){if(-1!==b.mappedIndexOf(a))throw Error("There already is an object with the key that you specified.");var c=h()?x(a):a;u()&&(a=v(c,a),e.isWriteableObservable(c)?c(a):c=a);b.push(c);return c});n=C(e.utils.unwrapObservable(b),m).sort();g=C(c,m);s&&g.sort();s=e.utils.compareArrays(n,g);n={};var J,A=e.utils.unwrapObservable(c),
11 | y={},z=!0,g=0;for(J=A.length;g<J;g++){var r=m(A[g]);if(void 0===r||r instanceof Object){z=!1;break}y[r]=A[g]}var A=[],B=0,g=0;for(J=s.length;g<J;g++){var r=s[g],q,w=l+"["+g+"]";switch(r.status){case "added":var D=z?y[r.value]:K(e.utils.unwrapObservable(c),r.value,m);q=F(void 0,D,a,d,b,w,k);h()||(q=e.utils.unwrapObservable(q));w=O(e.utils.unwrapObservable(c),D,n);q===N?B++:A[w-B]=q;n[w]=!0;break;case "retained":D=z?y[r.value]:K(e.utils.unwrapObservable(c),r.value,m);q=K(b,r.value,m);F(q,D,a,d,b,w,
12 | k);w=O(e.utils.unwrapObservable(c),D,n);A[w]=q;n[w]=!0;break;case "deleted":q=K(b,r.value,m)}t.push({event:r.status,item:q})}b(A);a[d]&&a[d].arrayChanged&&e.utils.arrayForEach(t,function(b){a[d].arrayChanged(b.event,b.item)})}else if(P(c)){b=e.utils.unwrapObservable(b);if(!b){if(h())return s=x(),u()&&(s=v(s)),s;if(u())return v(s);b={}}u()&&(b=v(b));I.save(c,b);if(u())return b;Q(c,function(d){var f=l.length?l+"."+d:d;if(-1==e.utils.arrayIndexOf(a.ignore,f))if(-1!=e.utils.arrayIndexOf(a.copy,f))b[d]=
13 | c[d];else if("object"!=typeof c[d]&&"array"!=typeof c[d]&&0<a.observe.length&&-1==e.utils.arrayIndexOf(a.observe,f))b[d]=c[d],a.copiedProperties[f]=!0;else{var g=I.get(c[d]),k=F(b[d],c[d],a,d,b,f,b),g=g||k;if(0<a.observe.length&&-1==e.utils.arrayIndexOf(a.observe,f))b[d]=g(),a.copiedProperties[f]=!0;else{if(e.isWriteableObservable(b[d])){if(g=e.utils.unwrapObservable(g),b[d]()!==g)b[d](g)}else g=void 0===b[d]?g:e.utils.unwrapObservable(g),b[d]=g;a.mappedProperties[f]=!0}}})}else switch(f.getType(c)){case "function":u()?
14 | e.isWriteableObservable(c)?(c(v(c)),b=c):b=v(c):b=c;break;default:if(e.isWriteableObservable(b))return q=u()?v(b):e.utils.unwrapObservable(c),b(q),q;h()||u();b=h()?x():e.observable(e.utils.unwrapObservable(c));u()&&b(v(b))}return b}function O(b,c,a){for(var d=0,e=b.length;d<e;d++)if(!0!==a[d]&&b[d]===c)return d;return null}function R(b,c){var a;c&&(a=c(b));"undefined"===f.getType(a)&&(a=b);return e.utils.unwrapObservable(a)}function K(b,c,a){b=e.utils.unwrapObservable(b);for(var d=0,f=b.length;d<
15 | f;d++){var l=b[d];if(R(l,a)===c)return l}throw Error("When calling ko.update*, the key '"+c+"' was not found!");}function C(b,c){return e.utils.arrayMap(e.utils.unwrapObservable(b),function(a){return c?R(a,c):a})}function Q(b,c){if("array"===f.getType(b))for(var a=0;a<b.length;a++)c(a);else for(a in b)c(a)}function P(b){var c=f.getType(b);return("object"===c||"array"===c)&&null!==b}function T(){var b=[],c=[];this.save=function(a,d){var f=e.utils.arrayIndexOf(b,a);0<=f?c[f]=d:(b.push(a),c.push(d))};
16 | this.get=function(a){a=e.utils.arrayIndexOf(b,a);return 0<=a?c[a]:void 0}}function S(){var b={},c=function(a){var c;try{c=a}catch(e){c="$$$"}a=b[c];void 0===a&&(a=new T,b[c]=a);return a};this.save=function(a,b){c(a).save(a,b)};this.get=function(a){return c(a).get(a)}}var p="__ko_mapping__",H=e.dependentObservable,B=0,G,I,L=["create","update","key","arrayChanged"],N={},x={include:["_destroy"],ignore:[],copy:[],observe:[]},j=x;f.isMapped=function(b){return(b=e.utils.unwrapObservable(b))&&b[p]};f.fromJS=
17 | function(b){if(0==arguments.length)throw Error("When calling ko.fromJS, pass the object you want to convert.");try{B++||(G=[],I=new S);var c,a;2==arguments.length&&(arguments[1][p]?a=arguments[1]:c=arguments[1]);3==arguments.length&&(c=arguments[1],a=arguments[2]);a&&(c=E(c,a[p]));c=z(c);var d=F(a,b,c);a&&(d=a);if(!--B)for(;G.length;){var e=G.pop();e&&(e(),e.__DO.throttleEvaluation=e.throttleEvaluation)}d[p]=E(d[p],c);return d}catch(f){throw B=0,f;}};f.fromJSON=function(b){var c=e.utils.parseJson(b);
18 | arguments[0]=c;return f.fromJS.apply(this,arguments)};f.updateFromJS=function(){throw Error("ko.mapping.updateFromJS, use ko.mapping.fromJS instead. Please note that the order of parameters is different!");};f.updateFromJSON=function(){throw Error("ko.mapping.updateFromJSON, use ko.mapping.fromJSON instead. Please note that the order of parameters is different!");};f.toJS=function(b,c){j||f.resetDefaultOptions();if(0==arguments.length)throw Error("When calling ko.mapping.toJS, pass the object you want to convert.");
19 | if("array"!==f.getType(j.ignore))throw Error("ko.mapping.defaultOptions().ignore should be an array.");if("array"!==f.getType(j.include))throw Error("ko.mapping.defaultOptions().include should be an array.");if("array"!==f.getType(j.copy))throw Error("ko.mapping.defaultOptions().copy should be an array.");c=z(c,b[p]);return f.visitModel(b,function(a){return e.utils.unwrapObservable(a)},c)};f.toJSON=function(b,c){var a=f.toJS(b,c);return e.utils.stringifyJson(a)};f.defaultOptions=function(){if(0<arguments.length)j=
20 | arguments[0];else return j};f.resetDefaultOptions=function(){j={include:x.include.slice(0),ignore:x.ignore.slice(0),copy:x.copy.slice(0)}};f.getType=function(b){if(b&&"object"===typeof b){if(b.constructor===Date)return"date";if(b.constructor===Array)return"array"}return typeof b};f.visitModel=function(b,c,a){a=a||{};a.visitedObjects=a.visitedObjects||new S;var d,k=e.utils.unwrapObservable(b);if(P(k))a=z(a,k[p]),c(b,a.parentName),d="array"===f.getType(k)?[]:{};else return c(b,a.parentName);a.visitedObjects.save(b,
21 | d);var l=a.parentName;Q(k,function(b){if(!(a.ignore&&-1!=e.utils.arrayIndexOf(a.ignore,b))){var j=k[b],g=a,h=l||"";"array"===f.getType(k)?l&&(h+="["+b+"]"):(l&&(h+="."),h+=b);g.parentName=h;if(!(-1===e.utils.arrayIndexOf(a.copy,b)&&-1===e.utils.arrayIndexOf(a.include,b)&&k[p]&&k[p].mappedProperties&&!k[p].mappedProperties[b]&&k[p].copiedProperties&&!k[p].copiedProperties[b]&&"array"!==f.getType(k)))switch(f.getType(e.utils.unwrapObservable(j))){case "object":case "array":case "undefined":g=a.visitedObjects.get(j);
22 | d[b]="undefined"!==f.getType(g)?g:f.visitModel(j,c,a);break;default:d[b]=c(j,a.parentName)}}});return d}});
23 | 


--------------------------------------------------------------------------------
/build/tools/curl.exe:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/SteveSanderson/knockout.mapping/92f2649c61bdad2da3406811518f80387a1f6b57/build/tools/curl.exe


--------------------------------------------------------------------------------
/build/tools/searchReplace.js:
--------------------------------------------------------------------------------
 1 | // Syntax:  cscript searchReplace.js searchRegex replaceText file1 file2 file3 ...
 2 | // Example: cscript searchReplace.js Thursday Friday weatherReport.txt
 3 | 
 4 | function readText(filename) {
 5 |     var fso = WSH.CreateObject("Scripting.FileSystemObject");
 6 |     var file = fso.OpenTextFile(filename, 1 /* readonly */);
 7 |     var txt = file.ReadAll();
 8 |     file.Close();
 9 |     return txt;
10 | }
11 | 
12 | function writeText(filename, text) {
13 |     var fso = WSH.CreateObject("Scripting.FileSystemObject");
14 |     var file = fso.OpenTextFile(filename, 2 /* readwrite */, true);
15 |     file.Write(text);
16 |     file.Close();
17 | }
18 | 
19 | var find = WScript.Arguments.Item(0),
20 |     replace = WScript.Arguments.Item(1);
21 | 
22 | // Special handling for newline chars, as I haven't found a reasonable way to pass them from DOS
23 | if (replace === "\\n")
24 |     replace = "\n";
25 | 
26 | for (var i = 2; i < WScript.Arguments.Length; i++) {
27 |     var filename = WScript.Arguments.Item(i);
28 |     WSH.Echo("Replacing content in " + filename + "...");
29 |     var original = readText(filename);
30 |     var updated = original.replace(new RegExp(find, "g"), replace);
31 |     writeText(filename, updated);
32 | }
33 | 


--------------------------------------------------------------------------------
/build/version-header.js:
--------------------------------------------------------------------------------
1 | /// Knockout Mapping plugin v2.4.1
2 | /// (c) 2013 Steven Sanderson, Roy Jacobs - http://knockoutjs.com/
3 | /// License: MIT (http://www.opensource.org/licenses/mit-license.php)
4 | 


--------------------------------------------------------------------------------
/knockout.mapping.js:
--------------------------------------------------------------------------------
  1 | (function (factory) {
  2 | 	// Module systems magic dance.
  3 | 
  4 | 	if (typeof require === "function" && typeof exports === "object" && typeof module === "object") {
  5 | 		// CommonJS or Node: hard-coded dependency on "knockout"
  6 | 		factory(require("knockout"), exports);
  7 | 	} else if (typeof define === "function" && define["amd"]) {
  8 | 		// AMD anonymous module with hard-coded dependency on "knockout"
  9 | 		define(["knockout", "exports"], factory);
 10 | 	} else {
 11 | 		// <script> tag: use the global `ko` object, attaching a `mapping` property
 12 | 		factory(ko, ko.mapping = {});
 13 | 	}
 14 | }(function (ko, exports) {
 15 | 	var DEBUG=true;
 16 | 	var mappingProperty = "__ko_mapping__";
 17 | 	var realKoDependentObservable = ko.dependentObservable;
 18 | 	var mappingNesting = 0;
 19 | 	var dependentObservables;
 20 | 	var visitedObjects;
 21 | 	var recognizedRootProperties = ["create", "update", "key", "arrayChanged"];
 22 | 	var emptyReturn = {};
 23 | 
 24 | 	var _defaultOptions = {
 25 | 		include: ["_destroy"],
 26 | 		ignore: [],
 27 | 		copy: [],
 28 | 		observe: []
 29 | 	};
 30 | 	var defaultOptions = _defaultOptions;
 31 | 	
 32 | 	function unionArrays() {
 33 | 		var args = arguments,
 34 | 		l = args.length,
 35 | 		obj = {},
 36 | 		res = [],
 37 | 		i, j, k;
 38 | 		
 39 | 		while (l--) {
 40 | 			k = args[l];
 41 | 			i = k.length;
 42 | 			
 43 | 			while (i--) {
 44 | 				j = k[i];
 45 | 				if (!obj[j]) {
 46 | 					obj[j] = 1;
 47 | 					res.push(j);
 48 | 				}
 49 | 			}	
 50 | 		}
 51 | 		
 52 | 		return res;
 53 | 	}
 54 | 
 55 | 	function extendObject(destination, source) {
 56 | 		var destType;
 57 | 
 58 | 		for (var key in source) {
 59 | 			if (source.hasOwnProperty(key) && source[key]) {
 60 | 				destType = exports.getType(destination[key]);
 61 | 				if (key && destination[key] && destType !== "array" && destType !== "string") {
 62 | 					extendObject(destination[key], source[key]);
 63 | 				} else {
 64 | 					var bothArrays = exports.getType(destination[key]) === "array" && exports.getType(source[key]) === "array";
 65 | 					if (bothArrays) {
 66 | 						destination[key] = unionArrays(destination[key], source[key]);
 67 | 					} else {
 68 | 						destination[key] = source[key];
 69 | 					}
 70 | 				}
 71 | 			}
 72 | 		}
 73 | 	}
 74 | 
 75 | 	function merge(obj1, obj2) {
 76 | 		var merged = {};
 77 | 		extendObject(merged, obj1);
 78 | 		extendObject(merged, obj2);
 79 | 
 80 | 		return merged;
 81 | 	}
 82 | 
 83 | 	exports.isMapped = function (viewModel) {
 84 | 		var unwrapped = ko.utils.unwrapObservable(viewModel);
 85 | 		return unwrapped && unwrapped[mappingProperty];
 86 | 	}
 87 | 
 88 | 	exports.fromJS = function (jsObject /*, inputOptions, target*/ ) {
 89 | 		if (arguments.length == 0) throw new Error("When calling ko.fromJS, pass the object you want to convert.");
 90 | 
 91 | 		try {
 92 | 			if (!mappingNesting++) {
 93 | 				dependentObservables = [];
 94 | 				visitedObjects = new objectLookup();
 95 | 			}
 96 | 
 97 | 			var options;
 98 | 			var target;
 99 | 
100 | 			if (arguments.length == 2) {
101 | 				if (arguments[1][mappingProperty]) {
102 | 					target = arguments[1];
103 | 				} else {
104 | 					options = arguments[1];
105 | 				}
106 | 			}
107 | 			if (arguments.length == 3) {
108 | 				options = arguments[1];
109 | 				target = arguments[2];
110 | 			}
111 | 
112 | 			if (target) {
113 | 				options = merge(options, target[mappingProperty]);
114 | 			}
115 | 			options = fillOptions(options);
116 | 
117 | 			var result = updateViewModel(target, jsObject, options);
118 | 			if (target) {
119 | 				result = target;
120 | 			}
121 | 
122 | 			// Evaluate any dependent observables that were proxied.
123 | 			// Do this after the model's observables have been created
124 | 			if (!--mappingNesting) {
125 | 				while (dependentObservables.length) {
126 | 					var DO = dependentObservables.pop();
127 | 					if (DO) {
128 | 						DO();
129 | 						
130 | 						// Move this magic property to the underlying dependent observable
131 | 						DO.__DO["throttleEvaluation"] = DO["throttleEvaluation"];
132 | 					}
133 | 				}
134 | 			}
135 | 
136 | 			// Save any new mapping options in the view model, so that updateFromJS can use them later.
137 | 			result[mappingProperty] = merge(result[mappingProperty], options);
138 | 
139 | 			return result;
140 | 		} catch(e) {
141 | 			mappingNesting = 0;
142 | 			throw e;
143 | 		}
144 | 	};
145 | 
146 | 	exports.fromJSON = function (jsonString /*, options, target*/ ) {
147 | 		var parsed = ko.utils.parseJson(jsonString);
148 | 		arguments[0] = parsed;
149 | 		return exports.fromJS.apply(this, arguments);
150 | 	};
151 | 
152 | 	exports.updateFromJS = function (viewModel) {
153 | 		throw new Error("ko.mapping.updateFromJS, use ko.mapping.fromJS instead. Please note that the order of parameters is different!");
154 | 	};
155 | 
156 | 	exports.updateFromJSON = function (viewModel) {
157 | 		throw new Error("ko.mapping.updateFromJSON, use ko.mapping.fromJSON instead. Please note that the order of parameters is different!");
158 | 	};
159 | 
160 | 	exports.toJS = function (rootObject, options) {
161 | 		if (!defaultOptions) exports.resetDefaultOptions();
162 | 
163 | 		if (arguments.length == 0) throw new Error("When calling ko.mapping.toJS, pass the object you want to convert.");
164 | 		if (exports.getType(defaultOptions.ignore) !== "array") throw new Error("ko.mapping.defaultOptions().ignore should be an array.");
165 | 		if (exports.getType(defaultOptions.include) !== "array") throw new Error("ko.mapping.defaultOptions().include should be an array.");
166 | 		if (exports.getType(defaultOptions.copy) !== "array") throw new Error("ko.mapping.defaultOptions().copy should be an array.");
167 | 
168 | 		// Merge in the options used in fromJS
169 | 		options = fillOptions(options, rootObject[mappingProperty]);
170 | 
171 | 		// We just unwrap everything at every level in the object graph
172 | 		return exports.visitModel(rootObject, function (x) {
173 | 			return ko.utils.unwrapObservable(x)
174 | 		}, options);
175 | 	};
176 | 
177 | 	exports.toJSON = function (rootObject, options) {
178 | 		var plainJavaScriptObject = exports.toJS(rootObject, options);
179 | 		return ko.utils.stringifyJson(plainJavaScriptObject);
180 | 	};
181 | 
182 | 	exports.defaultOptions = function () {
183 | 		if (arguments.length > 0) {
184 | 			defaultOptions = arguments[0];
185 | 		} else {
186 | 			return defaultOptions;
187 | 		}
188 | 	};
189 | 
190 | 	exports.resetDefaultOptions = function () {
191 | 		defaultOptions = {
192 | 			include: _defaultOptions.include.slice(0),
193 | 			ignore: _defaultOptions.ignore.slice(0),
194 | 			copy: _defaultOptions.copy.slice(0),
195 | 			observe: _defaultOptions.observe.slice(0)
196 | 		};
197 | 	};
198 | 
199 | 	exports.getType = function(x) {
200 | 		if ((x) && (typeof (x) === "object")) {
201 | 			if (x.constructor === Date) return "date";
202 | 			if (x.constructor === Array) return "array";
203 | 		}
204 | 		return typeof x;
205 | 	}
206 | 
207 | 	function fillOptions(rawOptions, otherOptions) {
208 | 		var options = merge({}, rawOptions);
209 | 
210 | 		// Move recognized root-level properties into a root namespace
211 | 		for (var i = recognizedRootProperties.length - 1; i >= 0; i--) {
212 | 			var property = recognizedRootProperties[i];
213 | 			
214 | 			// Carry on, unless this property is present
215 | 			if (!options[property]) continue;
216 | 			
217 | 			// Move the property into the root namespace
218 | 			if (!(options[""] instanceof Object)) options[""] = {};
219 | 			options[""][property] = options[property];
220 | 			delete options[property];
221 | 		}
222 | 
223 | 		if (otherOptions) {
224 | 			options.ignore = mergeArrays(otherOptions.ignore, options.ignore);
225 | 			options.include = mergeArrays(otherOptions.include, options.include);
226 | 			options.copy = mergeArrays(otherOptions.copy, options.copy);
227 | 			options.observe = mergeArrays(otherOptions.observe, options.observe);
228 | 		}
229 | 		options.ignore = mergeArrays(options.ignore, defaultOptions.ignore);
230 | 		options.include = mergeArrays(options.include, defaultOptions.include);
231 | 		options.copy = mergeArrays(options.copy, defaultOptions.copy);
232 | 		options.observe = mergeArrays(options.observe, defaultOptions.observe);
233 | 
234 | 		options.mappedProperties = options.mappedProperties || {};
235 | 		options.copiedProperties = options.copiedProperties || {};
236 | 		return options;
237 | 	}
238 | 
239 | 	function mergeArrays(a, b) {
240 | 		if (exports.getType(a) !== "array") {
241 | 			if (exports.getType(a) === "undefined") a = [];
242 | 			else a = [a];
243 | 		}
244 | 		if (exports.getType(b) !== "array") {
245 | 			if (exports.getType(b) === "undefined") b = [];
246 | 			else b = [b];
247 | 		}
248 | 
249 | 		return ko.utils.arrayGetDistinctValues(a.concat(b));
250 | 	}
251 | 
252 | 	// When using a 'create' callback, we proxy the dependent observable so that it doesn't immediately evaluate on creation.
253 | 	// The reason is that the dependent observables in the user-specified callback may contain references to properties that have not been mapped yet.
254 | 	function withProxyDependentObservable(dependentObservables, callback) {
255 | 		var localDO = ko.dependentObservable;
256 | 		ko.dependentObservable = function (read, owner, options) {
257 | 			options = options || {};
258 | 
259 | 			if (read && typeof read == "object") { // mirrors condition in knockout implementation of DO's
260 | 				options = read;
261 | 			}
262 | 
263 | 			var realDeferEvaluation = options.deferEvaluation;
264 | 
265 | 			var isRemoved = false;
266 | 
267 | 			// We wrap the original dependent observable so that we can remove it from the 'dependentObservables' list we need to evaluate after mapping has
268 | 			// completed if the user already evaluated the DO themselves in the meantime.
269 | 			var wrap = function (DO) {
270 | 				// Temporarily revert ko.dependentObservable, since it is used in ko.isWriteableObservable
271 | 				var tmp = ko.dependentObservable;
272 | 				ko.dependentObservable = realKoDependentObservable;
273 | 				var isWriteable = ko.isWriteableObservable(DO);
274 | 				ko.dependentObservable = tmp;
275 | 
276 | 				var wrapped = realKoDependentObservable({
277 | 					read: function () {
278 | 						if (!isRemoved) {
279 | 							ko.utils.arrayRemoveItem(dependentObservables, DO);
280 | 							isRemoved = true;
281 | 						}
282 | 						return DO.apply(DO, arguments);
283 | 					},
284 | 					write: isWriteable && function (val) {
285 | 						return DO(val);
286 | 					},
287 | 					deferEvaluation: true
288 | 				});
289 | 				if (DEBUG) wrapped._wrapper = true;
290 | 				wrapped.__DO = DO;
291 | 				return wrapped;
292 | 			};
293 | 			
294 | 			options.deferEvaluation = true; // will either set for just options, or both read/options.
295 | 			var realDependentObservable = new realKoDependentObservable(read, owner, options);
296 | 
297 | 			if (!realDeferEvaluation) {
298 | 				realDependentObservable = wrap(realDependentObservable);
299 | 				dependentObservables.push(realDependentObservable);
300 | 			}
301 | 
302 | 			return realDependentObservable;
303 | 		}
304 | 		ko.dependentObservable.fn = realKoDependentObservable.fn;
305 | 		ko.computed = ko.dependentObservable;
306 | 		var result = callback();
307 | 		ko.dependentObservable = localDO;
308 | 		ko.computed = ko.dependentObservable;
309 | 		return result;
310 | 	}
311 | 
312 | 	function updateViewModel(mappedRootObject, rootObject, options, parentName, parent, parentPropertyName, mappedParent) {
313 | 		var isArray = exports.getType(ko.utils.unwrapObservable(rootObject)) === "array";
314 | 
315 | 		parentPropertyName = parentPropertyName || "";
316 | 
317 | 		// If this object was already mapped previously, take the options from there and merge them with our existing ones.
318 | 		if (exports.isMapped(mappedRootObject)) {
319 | 			var previousMapping = ko.utils.unwrapObservable(mappedRootObject)[mappingProperty];
320 | 			options = merge(previousMapping, options);
321 | 		}
322 | 
323 | 		var callbackParams = {
324 | 			data: rootObject,
325 | 			parent: mappedParent || parent
326 | 		};
327 | 
328 | 		var hasCreateCallback = function () {
329 | 			return options[parentName] && options[parentName].create instanceof Function;
330 | 		};
331 | 
332 | 		var createCallback = function (data) {
333 | 			return withProxyDependentObservable(dependentObservables, function () {
334 | 				
335 | 				if (ko.utils.unwrapObservable(parent) instanceof Array) {
336 | 					return options[parentName].create({
337 | 						data: data || callbackParams.data,
338 | 						parent: callbackParams.parent,
339 | 						skip: emptyReturn
340 | 					});
341 | 				} else {
342 | 					return options[parentName].create({
343 | 						data: data || callbackParams.data,
344 | 						parent: callbackParams.parent
345 | 					});
346 | 				}				
347 | 			});
348 | 		};
349 | 
350 | 		var hasUpdateCallback = function () {
351 | 			return options[parentName] && options[parentName].update instanceof Function;
352 | 		};
353 | 
354 | 		var updateCallback = function (obj, data) {
355 | 			var params = {
356 | 				data: data || callbackParams.data,
357 | 				parent: callbackParams.parent,
358 | 				target: ko.utils.unwrapObservable(obj)
359 | 			};
360 | 
361 | 			if (ko.isWriteableObservable(obj)) {
362 | 				params.observable = obj;
363 | 			}
364 | 
365 | 			return options[parentName].update(params);
366 | 		}
367 | 
368 | 		var alreadyMapped = visitedObjects.get(rootObject);
369 | 		if (alreadyMapped) {
370 | 			return alreadyMapped;
371 | 		}
372 | 
373 | 		parentName = parentName || "";
374 | 
375 | 		if (!isArray) {
376 | 			// For atomic types, do a direct update on the observable
377 | 			if (!canHaveProperties(rootObject)) {
378 | 				switch (exports.getType(rootObject)) {
379 | 				case "function":
380 | 					if (hasUpdateCallback()) {
381 | 						if (ko.isWriteableObservable(rootObject)) {
382 | 							rootObject(updateCallback(rootObject));
383 | 							mappedRootObject = rootObject;
384 | 						} else {
385 | 							mappedRootObject = updateCallback(rootObject);
386 | 						}
387 | 					} else {
388 | 						mappedRootObject = rootObject;
389 | 					}
390 | 					break;
391 | 				default:
392 | 					if (ko.isWriteableObservable(mappedRootObject)) {
393 | 						if (hasUpdateCallback()) {
394 | 							var valueToWrite = updateCallback(mappedRootObject);
395 | 							mappedRootObject(valueToWrite);
396 | 							return valueToWrite;
397 | 						} else {
398 | 							var valueToWrite = ko.utils.unwrapObservable(rootObject);
399 | 							mappedRootObject(valueToWrite);
400 | 							return valueToWrite;
401 | 						}
402 | 					} else {
403 | 						var hasCreateOrUpdateCallback = hasCreateCallback() || hasUpdateCallback();
404 | 						
405 | 						if (hasCreateCallback()) {
406 | 							mappedRootObject = createCallback();
407 | 						} else {
408 | 							mappedRootObject = ko.observable(ko.utils.unwrapObservable(rootObject));
409 | 						}
410 | 
411 | 						if (hasUpdateCallback()) {
412 | 							mappedRootObject(updateCallback(mappedRootObject));
413 | 						}
414 | 						
415 | 						if (hasCreateOrUpdateCallback) return mappedRootObject;
416 | 					}
417 | 				}
418 | 
419 | 			} else {
420 | 				mappedRootObject = ko.utils.unwrapObservable(mappedRootObject);
421 | 				if (!mappedRootObject) {
422 | 					if (hasCreateCallback()) {
423 | 						var result = createCallback();
424 | 
425 | 						if (hasUpdateCallback()) {
426 | 							result = updateCallback(result);
427 | 						}
428 | 
429 | 						return result;
430 | 					} else {
431 | 						if (hasUpdateCallback()) {
432 | 							return updateCallback(result);
433 | 						}
434 | 
435 | 						mappedRootObject = {};
436 | 					}
437 | 				}
438 | 
439 | 				if (hasUpdateCallback()) {
440 | 					mappedRootObject = updateCallback(mappedRootObject);
441 | 				}
442 | 
443 | 				visitedObjects.save(rootObject, mappedRootObject);
444 | 				if (hasUpdateCallback()) return mappedRootObject;
445 | 
446 | 				// For non-atomic types, visit all properties and update recursively
447 | 				visitPropertiesOrArrayEntries(rootObject, function (indexer) {
448 | 					var fullPropertyName = parentPropertyName.length ? parentPropertyName + "." + indexer : indexer;
449 | 
450 | 					if (ko.utils.arrayIndexOf(options.ignore, fullPropertyName) != -1) {
451 | 						return;
452 | 					}
453 | 
454 | 					if (ko.utils.arrayIndexOf(options.copy, fullPropertyName) != -1) {
455 | 						mappedRootObject[indexer] = rootObject[indexer];
456 | 						return;
457 | 					}
458 | 
459 | 					if(typeof rootObject[indexer] != "object" && typeof rootObject[indexer] != "array" && options.observe.length > 0 && ko.utils.arrayIndexOf(options.observe, fullPropertyName) == -1)
460 | 					{
461 | 						mappedRootObject[indexer] = rootObject[indexer];
462 | 						options.copiedProperties[fullPropertyName] = true;
463 | 						return;
464 | 					}
465 | 					
466 | 					// In case we are adding an already mapped property, fill it with the previously mapped property value to prevent recursion.
467 | 					// If this is a property that was generated by fromJS, we should use the options specified there
468 | 					var prevMappedProperty = visitedObjects.get(rootObject[indexer]);
469 | 					var retval = updateViewModel(mappedRootObject[indexer], rootObject[indexer], options, indexer, mappedRootObject, fullPropertyName, mappedRootObject);
470 | 					var value = prevMappedProperty || retval;
471 | 					
472 | 					if(options.observe.length > 0 && ko.utils.arrayIndexOf(options.observe, fullPropertyName) == -1)
473 | 					{
474 | 						mappedRootObject[indexer] = ko.utils.unwrapObservable(value);
475 | 						options.copiedProperties[fullPropertyName] = true;
476 | 						return;
477 | 					}
478 | 					
479 | 					if (ko.isWriteableObservable(mappedRootObject[indexer])) {
480 | 						value = ko.utils.unwrapObservable(value);
481 | 						if (mappedRootObject[indexer]() !== value) {
482 | 							mappedRootObject[indexer](value);
483 | 						}
484 | 					} else {
485 | 						value = mappedRootObject[indexer] === undefined ? value : ko.utils.unwrapObservable(value);
486 | 						mappedRootObject[indexer] = value;
487 | 					}
488 | 
489 | 					options.mappedProperties[fullPropertyName] = true;
490 | 				});
491 | 			}
492 | 		} else { //mappedRootObject is an array
493 | 			var changes = [];
494 | 
495 | 			var hasKeyCallback = false;
496 | 			var keyCallback = function (x) {
497 | 				return x;
498 | 			}
499 | 			if (options[parentName] && options[parentName].key) {
500 | 				keyCallback = options[parentName].key;
501 | 				hasKeyCallback = true;
502 | 			}
503 | 
504 | 			if (!ko.isObservable(mappedRootObject)) {
505 | 				// When creating the new observable array, also add a bunch of utility functions that take the 'key' of the array items into account.
506 | 				mappedRootObject = ko.observableArray([]);
507 | 
508 | 				mappedRootObject.mappedRemove = function (valueOrPredicate) {
509 | 					var predicate = typeof valueOrPredicate == "function" ? valueOrPredicate : function (value) {
510 | 							return value === keyCallback(valueOrPredicate);
511 | 						};
512 | 					return mappedRootObject.remove(function (item) {
513 | 						return predicate(keyCallback(item));
514 | 					});
515 | 				}
516 | 
517 | 				mappedRootObject.mappedRemoveAll = function (arrayOfValues) {
518 | 					var arrayOfKeys = filterArrayByKey(arrayOfValues, keyCallback);
519 | 					return mappedRootObject.remove(function (item) {
520 | 						return ko.utils.arrayIndexOf(arrayOfKeys, keyCallback(item)) != -1;
521 | 					});
522 | 				}
523 | 
524 | 				mappedRootObject.mappedDestroy = function (valueOrPredicate) {
525 | 					var predicate = typeof valueOrPredicate == "function" ? valueOrPredicate : function (value) {
526 | 							return value === keyCallback(valueOrPredicate);
527 | 						};
528 | 					return mappedRootObject.destroy(function (item) {
529 | 						return predicate(keyCallback(item));
530 | 					});
531 | 				}
532 | 
533 | 				mappedRootObject.mappedDestroyAll = function (arrayOfValues) {
534 | 					var arrayOfKeys = filterArrayByKey(arrayOfValues, keyCallback);
535 | 					return mappedRootObject.destroy(function (item) {
536 | 						return ko.utils.arrayIndexOf(arrayOfKeys, keyCallback(item)) != -1;
537 | 					});
538 | 				}
539 | 
540 | 				mappedRootObject.mappedIndexOf = function (item) {
541 | 					var keys = filterArrayByKey(mappedRootObject(), keyCallback);
542 | 					var key = keyCallback(item);
543 | 					return ko.utils.arrayIndexOf(keys, key);
544 | 				}
545 | 
546 | 				mappedRootObject.mappedGet = function (item) {
547 | 					return mappedRootObject()[mappedRootObject.mappedIndexOf(item)];
548 | 				}
549 | 
550 | 				mappedRootObject.mappedCreate = function (value) {
551 | 					if (mappedRootObject.mappedIndexOf(value) !== -1) {
552 | 						throw new Error("There already is an object with the key that you specified.");
553 | 					}
554 | 
555 | 					var item = hasCreateCallback() ? createCallback(value) : value;
556 | 					if (hasUpdateCallback()) {
557 | 						var newValue = updateCallback(item, value);
558 | 						if (ko.isWriteableObservable(item)) {
559 | 							item(newValue);
560 | 						} else {
561 | 							item = newValue;
562 | 						}
563 | 					}
564 | 					mappedRootObject.push(item);
565 | 					return item;
566 | 				}
567 | 			}
568 | 
569 | 			var currentArrayKeys = filterArrayByKey(ko.utils.unwrapObservable(mappedRootObject), keyCallback).sort();
570 | 			var newArrayKeys = filterArrayByKey(rootObject, keyCallback);
571 | 			if (hasKeyCallback) newArrayKeys.sort();
572 | 			var editScript = ko.utils.compareArrays(currentArrayKeys, newArrayKeys);
573 | 
574 | 			var ignoreIndexOf = {};
575 | 			
576 | 			var i, j;
577 | 
578 | 			var unwrappedRootObject = ko.utils.unwrapObservable(rootObject);
579 | 			var itemsByKey = {};
580 | 			var optimizedKeys = true;
581 | 			for (i = 0, j = unwrappedRootObject.length; i < j; i++) {
582 | 				var key = keyCallback(unwrappedRootObject[i]);
583 | 				if (key === undefined || key instanceof Object) {
584 | 					optimizedKeys = false;
585 | 					break;
586 | 				}
587 | 				itemsByKey[key] = unwrappedRootObject[i];
588 | 			}
589 | 
590 | 			var newContents = [];
591 | 			var passedOver = 0;
592 | 			for (i = 0, j = editScript.length; i < j; i++) {
593 | 				var key = editScript[i];
594 | 				var mappedItem;
595 | 				var fullPropertyName = parentPropertyName + "[" + i + "]";
596 | 				switch (key.status) {
597 | 				case "added":
598 | 					var item = optimizedKeys ? itemsByKey[key.value] : getItemByKey(ko.utils.unwrapObservable(rootObject), key.value, keyCallback);
599 | 					mappedItem = updateViewModel(undefined, item, options, parentName, mappedRootObject, fullPropertyName, parent);
600 | 					if(!hasCreateCallback()) {
601 | 						mappedItem = ko.utils.unwrapObservable(mappedItem);
602 | 					}
603 | 
604 | 					var index = ignorableIndexOf(ko.utils.unwrapObservable(rootObject), item, ignoreIndexOf);
605 | 					
606 | 					if (mappedItem === emptyReturn) {
607 | 						passedOver++;
608 | 					} else {
609 | 						newContents[index - passedOver] = mappedItem;
610 | 					}
611 | 						
612 | 					ignoreIndexOf[index] = true;
613 | 					break;
614 | 				case "retained":
615 | 					var item = optimizedKeys ? itemsByKey[key.value] : getItemByKey(ko.utils.unwrapObservable(rootObject), key.value, keyCallback);
616 | 					mappedItem = getItemByKey(mappedRootObject, key.value, keyCallback);
617 | 					updateViewModel(mappedItem, item, options, parentName, mappedRootObject, fullPropertyName, parent);
618 | 
619 | 					var index = ignorableIndexOf(ko.utils.unwrapObservable(rootObject), item, ignoreIndexOf);
620 | 					newContents[index] = mappedItem;
621 | 					ignoreIndexOf[index] = true;
622 | 					break;
623 | 				case "deleted":
624 | 					mappedItem = getItemByKey(mappedRootObject, key.value, keyCallback);
625 | 					break;
626 | 				}
627 | 
628 | 				changes.push({
629 | 					event: key.status,
630 | 					item: mappedItem
631 | 				});
632 | 			}
633 | 
634 | 			mappedRootObject(newContents);
635 | 
636 | 			if (options[parentName] && options[parentName].arrayChanged) {
637 | 				ko.utils.arrayForEach(changes, function (change) {
638 | 					options[parentName].arrayChanged(change.event, change.item);
639 | 				});
640 | 			}
641 | 		}
642 | 
643 | 		return mappedRootObject;
644 | 	}
645 | 
646 | 	function ignorableIndexOf(array, item, ignoreIndices) {
647 | 		for (var i = 0, j = array.length; i < j; i++) {
648 | 			if (ignoreIndices[i] === true) continue;
649 | 			if (array[i] === item) return i;
650 | 		}
651 | 		return null;
652 | 	}
653 | 
654 | 	function mapKey(item, callback) {
655 | 		var mappedItem;
656 | 		if (callback) mappedItem = callback(item);
657 | 		if (exports.getType(mappedItem) === "undefined") mappedItem = item;
658 | 
659 | 		return ko.utils.unwrapObservable(mappedItem);
660 | 	}
661 | 
662 | 	function getItemByKey(array, key, callback) {
663 | 		array = ko.utils.unwrapObservable(array);
664 | 		for (var i = 0, j = array.length; i < j; i++) {
665 | 			var item = array[i];
666 | 			if (mapKey(item, callback) === key) return item;
667 | 		}
668 | 
669 | 		throw new Error("When calling ko.update*, the key '" + key + "' was not found!");
670 | 	}
671 | 
672 | 	function filterArrayByKey(array, callback) {
673 | 		return ko.utils.arrayMap(ko.utils.unwrapObservable(array), function (item) {
674 | 			if (callback) {
675 | 				return mapKey(item, callback);
676 | 			} else {
677 | 				return item;
678 | 			}
679 | 		});
680 | 	}
681 | 
682 | 	function visitPropertiesOrArrayEntries(rootObject, visitorCallback) {
683 | 		if (exports.getType(rootObject) === "array") {
684 | 			for (var i = 0; i < rootObject.length; i++)
685 | 			visitorCallback(i);
686 | 		} else {
687 | 			for (var propertyName in rootObject)
688 | 			visitorCallback(propertyName);
689 | 		}
690 | 	};
691 | 
692 | 	function canHaveProperties(object) {
693 | 		var type = exports.getType(object);
694 | 		return ((type === "object") || (type === "array")) && (object !== null);
695 | 	}
696 | 
697 | 	// Based on the parentName, this creates a fully classified name of a property
698 | 
699 | 	function getPropertyName(parentName, parent, indexer) {
700 | 		var propertyName = parentName || "";
701 | 		if (exports.getType(parent) === "array") {
702 | 			if (parentName) {
703 | 				propertyName += "[" + indexer + "]";
704 | 			}
705 | 		} else {
706 | 			if (parentName) {
707 | 				propertyName += ".";
708 | 			}
709 | 			propertyName += indexer;
710 | 		}
711 | 		return propertyName;
712 | 	}
713 | 
714 | 	exports.visitModel = function (rootObject, callback, options) {
715 | 		options = options || {};
716 | 		options.visitedObjects = options.visitedObjects || new objectLookup();
717 | 
718 | 		var mappedRootObject;
719 | 		var unwrappedRootObject = ko.utils.unwrapObservable(rootObject);
720 | 
721 | 		if (!canHaveProperties(unwrappedRootObject)) {
722 | 			return callback(rootObject, options.parentName);
723 | 		} else {
724 | 			options = fillOptions(options, unwrappedRootObject[mappingProperty]);
725 | 
726 | 			// Only do a callback, but ignore the results
727 | 			callback(rootObject, options.parentName);
728 | 			mappedRootObject = exports.getType(unwrappedRootObject) === "array" ? [] : {};
729 | 		}
730 | 
731 | 		options.visitedObjects.save(rootObject, mappedRootObject);
732 | 
733 | 		var parentName = options.parentName;
734 | 		visitPropertiesOrArrayEntries(unwrappedRootObject, function (indexer) {
735 | 			if (options.ignore && ko.utils.arrayIndexOf(options.ignore, indexer) != -1) return;
736 | 
737 | 			var propertyValue = unwrappedRootObject[indexer];
738 | 			options.parentName = getPropertyName(parentName, unwrappedRootObject, indexer);
739 | 
740 | 			// If we don't want to explicitly copy the unmapped property...
741 | 			if (ko.utils.arrayIndexOf(options.copy, indexer) === -1) {
742 | 				// ...find out if it's a property we want to explicitly include
743 | 				if (ko.utils.arrayIndexOf(options.include, indexer) === -1) {
744 | 					// The mapped properties object contains all the properties that were part of the original object.
745 | 					// 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.
746 | 				    if (unwrappedRootObject[mappingProperty]
747 | 				        && unwrappedRootObject[mappingProperty].mappedProperties && !unwrappedRootObject[mappingProperty].mappedProperties[indexer]
748 | 				        && unwrappedRootObject[mappingProperty].copiedProperties && !unwrappedRootObject[mappingProperty].copiedProperties[indexer]
749 | 				        && !(exports.getType(unwrappedRootObject) === "array")) {
750 | 						return;
751 | 					}
752 | 				}
753 | 			}
754 | 
755 | 			var outputProperty;
756 | 			switch (exports.getType(ko.utils.unwrapObservable(propertyValue))) {
757 | 			case "object":
758 | 			case "array":
759 | 			case "undefined":
760 | 				var previouslyMappedValue = options.visitedObjects.get(propertyValue);
761 | 				mappedRootObject[indexer] = (exports.getType(previouslyMappedValue) !== "undefined") ? previouslyMappedValue : exports.visitModel(propertyValue, callback, options);
762 | 				break;
763 | 			default:
764 | 				mappedRootObject[indexer] = callback(propertyValue, options.parentName);
765 | 			}
766 | 		});
767 | 
768 | 		return mappedRootObject;
769 | 	}
770 | 
771 | 	function simpleObjectLookup() {
772 | 		var keys = [];
773 | 		var values = [];
774 | 		this.save = function (key, value) {
775 | 			var existingIndex = ko.utils.arrayIndexOf(keys, key);
776 | 			if (existingIndex >= 0) values[existingIndex] = value;
777 | 			else {
778 | 				keys.push(key);
779 | 				values.push(value);
780 | 			}
781 | 		};
782 | 		this.get = function (key) {
783 | 			var existingIndex = ko.utils.arrayIndexOf(keys, key);
784 | 			var value = (existingIndex >= 0) ? values[existingIndex] : undefined;
785 | 			return value;
786 | 		};
787 | 	};
788 | 	
789 | 	function objectLookup() {
790 | 		var buckets = {};
791 | 		
792 | 		var findBucket = function(key) {
793 | 			var bucketKey;
794 | 			try {
795 | 				bucketKey = key;//JSON.stringify(key);
796 | 			}
797 | 			catch (e) {
798 | 				bucketKey = "$$$";
799 | 			}
800 | 
801 | 			var bucket = buckets[bucketKey];
802 | 			if (bucket === undefined) {
803 | 				bucket = new simpleObjectLookup();
804 | 				buckets[bucketKey] = bucket;
805 | 			}
806 | 			return bucket;
807 | 		};
808 | 		
809 | 		this.save = function (key, value) {
810 | 			findBucket(key).save(key, value);
811 | 		};
812 | 		this.get = function (key) {
813 | 			return findBucket(key).get(key);
814 | 		};
815 | 	};
816 | }));
817 | 


--------------------------------------------------------------------------------
/spec/issues.js:
--------------------------------------------------------------------------------
  1 | module('Integration tests');
  2 | 
  3 | test('Store', function() {
  4 | 	function Product(data) {
  5 | 		
  6 | 		var viewModel = {
  7 | 			guid: ko.observable(),
  8 | 			name : ko.observable()
  9 | 		};
 10 | 		
 11 | 		ko.mapping.fromJS(data, {}, viewModel);
 12 | 		
 13 | 		return viewModel;
 14 | 	}
 15 | 
 16 | 	Store = function(data) {
 17 | 		data = data || {};
 18 | 		var mapping = {
 19 | 				Products: {
 20 | 					key: function(data) {
 21 | 						return ko.utils.unwrapObservable(data.guid);
 22 | 					},
 23 | 					create: function(options) {
 24 | 						return new Product(options.data);
 25 | 					}
 26 | 				},
 27 | 			
 28 | 				Selected: {
 29 | 					update: function(options) {
 30 | 						return ko.utils.arrayFirst(viewModel.Products(), function(p) {
 31 | 							return p.guid() == options.data.guid;
 32 | 						});
 33 | 					}
 34 | 				}
 35 | 			};
 36 | 
 37 | 		var viewModel = {
 38 | 			Products: ko.observableArray(),
 39 | 			Selected : ko.observable()
 40 | 		};
 41 | 
 42 | 		ko.mapping.fromJS(data, mapping, viewModel);
 43 | 		
 44 | 		return viewModel;
 45 | 	};
 46 | 
 47 | 	var jsData = {
 48 | 		"Products": [
 49 | 			{ "guid": "01", "name": "Product1" },
 50 | 			{ "guid": "02", "name": "Product2" },
 51 | 			{ "guid": "03", "name": "Product3" }
 52 | 		],
 53 | 		"Selected": { "guid": "02" }
 54 | 	};
 55 | 	var viewModel = new Store(jsData);
 56 | 	equal(viewModel.Selected().name(), "Product2");
 57 | });
 58 | 
 59 | //https://github.com/SteveSanderson/knockout.mapping/issues/34
 60 | test('Issue #34', function() {
 61 | 	var importData = function(dataArray, target) {
 62 | 		var mapping = {
 63 | 			"create": function( options ) {
 64 | 				return options.data;
 65 | 			}
 66 | 		};
 67 | 
 68 | 		return ko.mapping.fromJS(dataArray, mapping, target);
 69 | 	};
 70 | 
 71 | 	var viewModel = {
 72 | 		things: ko.observableArray( [] ),
 73 | 		load: function() {
 74 | 			var rows = [
 75 | 				{ id: 1 }
 76 | 			];
 77 | 	
 78 | 			importData(rows, viewModel.things);
 79 | 		}
 80 | 	};
 81 | 	
 82 | 	viewModel.load();
 83 | 	viewModel.load();
 84 | 	viewModel.load();
 85 | 
 86 | 	deepEqual(viewModel.things(), [{"id":1}]);
 87 | });
 88 | 
 89 | test('Adding large amounts of items to array is slow', function() {
 90 | 	expect(0);
 91 | 
 92 | 	var numItems = 5000;
 93 | 	var data = [];
 94 | 	for (var t=0;t<numItems;t++) {
 95 | 		data.push({ id: t });
 96 | 	}
 97 | 	
 98 | 	var mapped = ko.mapping.fromJS(data, {
 99 | 		key: function(data) {
100 | 			return ko.utils.unwrapObservable(data).id;
101 | 		}
102 | 	});
103 | });
104 | 
105 | test('Issue #87', function() {
106 | 	var Item = function(data) {
107 | 		var _this = this;
108 | 
109 | 		var mapping = {
110 | 			include: ["name"]
111 | 		};
112 | 
113 | 		data = data || {};
114 | 		_this.name = ko.observable(data.name || "c");
115 | 
116 | 		ko.mapping.fromJS(data, mapping, _this);
117 | 	};
118 | 
119 | 	var Container = function(data) {
120 | 		var _this = this;
121 | 
122 | 		var mapping = {
123 | 			items: {
124 | 				create: function(options) {
125 | 					return new Item(options.data);
126 | 				}
127 | 			}
128 | 		};
129 | 
130 | 		_this.addItem = function() {
131 | 			_this.items.push(new Item());
132 | 		};
133 | 
134 | 		ko.mapping.fromJS(data, mapping, _this);
135 | 	};
136 | 
137 | 	var data = {
138 | 		items: [
139 | 			{ name: "a" },
140 | 			{ name: "b" }
141 | 		]
142 | 	};
143 | 
144 | 	var mapped = new Container(data);
145 | 
146 | 	mapped.addItem();
147 | 	equal(mapped.items().length, 3);
148 | 	equal(mapped.items()[0].name(), "a");
149 | 	equal(mapped.items()[1].name(), "b");
150 | 	equal(mapped.items()[2].name(), "c");
151 | 
152 | 	var unmapped = ko.mapping.toJS(mapped);
153 | 	equal(unmapped.items.length, 3);
154 | 	equal(unmapped.items[0].name, "a");
155 | 	equal(unmapped.items[1].name, "b");
156 | 	equal(unmapped.items[2].name, "c");
157 | });
158 | 
159 | test('Issue #88', function() {
160 | 	var ViewModel = function(data) {
161 | 	    ko.mapping.fromJS(data, {
162 | 	        copy: ["id"]
163 | 	    }, this);
164 | 
165 | 	    this.reference = ko.observable(this);
166 | 	};
167 | 
168 | 	var viewModel = new ViewModel({"id":123, "name":"Alice"});
169 | 	var unmapped;
170 | 
171 | 	unmapped = ko.mapping.toJS(viewModel);
172 | 	equal(unmapped.id, 123);
173 | 	equal(unmapped.name, "Alice");
174 | 
175 | 	unmapped = ko.mapping.toJS(viewModel.reference);
176 | 	equal(unmapped.id, 123);
177 | 	equal(unmapped.name, "Alice");
178 | 
179 | 	unmapped = ko.mapping.toJS(viewModel.reference());
180 | 	equal(unmapped.id, 123);
181 | 	equal(unmapped.name, "Alice");
182 | });
183 | 
184 | test('Issue #94', function() {
185 | 	var model = { 
186 | 	    prop: "original",
187 | 	    obj: { 
188 | 	        prop: "original", 
189 | 	        obj: { 
190 | 	            prop: "original" 
191 | 	        } 
192 | 	    }
193 | 	};
194 | 	var viewModel = ko.mapping.fromJS(model);
195 | 
196 | 	var modelUpdate = { 
197 | 	    prop: "edit",
198 | 	    obj: { 
199 | 	        prop: "edit",
200 | 	        obj: { 
201 | 	            prop: "edit" 
202 | 	        }
203 | 	    }            
204 | 	};
205 | 	ko.mapping.fromJS(modelUpdate, { ignore: ["obj.prop", "obj.obj"] }, viewModel);
206 | 
207 | 	equal(viewModel.prop(), "edit");
208 | 	equal(viewModel.obj.prop(), "original");
209 | 	equal(viewModel.obj.obj.prop(), "original");
210 | });
211 | 
212 | asyncTest('Issue #99', function() {
213 | 	var a = {
214 | 		x : ko.observable().extend({ throttle: 1 })
215 | 	};
216 | 
217 | 	var receivedValue;
218 | 	a.x.subscribe(function(value) {
219 | 		receivedValue = value;
220 | 	});
221 | 
222 | 	ko.mapping.fromJS({ x: 3 }, {}, a);
223 | 	window.setTimeout(function() {
224 | 		equal(receivedValue, 3);
225 | 		start();
226 | 	}, 2);
227 | });
228 | 
229 | test('Issue #33', function() {
230 | 	var mapping = {
231 | 	    'items': {
232 | 	        key: function(data) {
233 | 	            return ko.utils.unwrapObservable(data.id);
234 | 	        },
235 | 	        create: function(options) {
236 | 	            var o = (new(function() {
237 | 	                this._remove = function() {
238 | 	                    options.parent.items.mappedRemove(options.data);
239 | 	                };
240 | 	                ko.mapping.fromJS(options.data, {}, this);
241 | 	            })());
242 | 	            return o;
243 | 	        }
244 | 	    }
245 | 	};
246 | 
247 | 	var i = 0;
248 | 	var vm = ko.mapping.fromJS({
249 | 	    'items': [{
250 | 	        id: ++i}]
251 | 	}, mapping);
252 | 
253 |     vm.items.mappedCreate({
254 |         id: ++i
255 |     });
256 | 
257 |     equal(vm.items().length, 2);
258 | 	vm.items()[1]._remove();
259 | 
260 | 	equal(vm.items().length, 1);
261 | 	vm.items()[0]._remove();
262 | 
263 | 	equal(vm.items().length, 0);
264 | });
265 | 
266 | test('Issue #86', function() {
267 | 	var ViewModel = function() {
268 | 		var _this = this;
269 | 		this.filters = new FilterModel();
270 | 		this.update = function(data) {
271 | 			var mapping = {
272 | 				filters: {
273 | 					update: function(options) {
274 | 						return options.target.update(options.data);
275 | 					}
276 | 				}
277 | 			};
278 | 
279 | 			ko.mapping.fromJS(data, mapping, _this);
280 | 			return _this;
281 | 		};
282 | 	};
283 | 
284 | 	var FilterModel = function() {
285 | 		var _this = this;
286 | 		this.a = ko.observable();
287 | 		this.update = function(data) {
288 | 			debugger;
289 | 			var mapping = {
290 | 				a: {
291 | 					update: function(options) {
292 | 						debugger;
293 | 						return options.data + " modified";
294 | 					}
295 | 				}
296 | 			};
297 | 			ko.mapping.fromJS(data, mapping, _this);
298 | 			return _this;
299 | 		};
300 | 	};
301 | 
302 | 	var model = new ViewModel();
303 | 	model.update({ filters: { a: "a1" }});
304 | 	equal(model.filters.a(), "a1 modified");
305 | });
306 | 
307 | //https://github.com/SteveSanderson/knockout.mapping/issues/107
308 | test('Issue #107', function () {
309 | 	var model = ko.mapping.fromJS({ foo: 'bar' }, {
310 | 		fiz: 'applesauce'
311 | 	});
312 | 
313 | 	ko.mapping.fromJS({ foo: 'baz' }, model);
314 | 
315 | 	equal(model.foo(), "baz");
316 | });
317 | 


--------------------------------------------------------------------------------
/spec/lib/json2.js:
--------------------------------------------------------------------------------
  1 | /*
  2 |     http://www.JSON.org/json2.js
  3 |     2010-03-20
  4 | 
  5 |     Public Domain.
  6 | 
  7 |     NO WARRANTY EXPRESSED OR IMPLIED. USE AT YOUR OWN RISK.
  8 | 
  9 |     See http://www.JSON.org/js.html
 10 | 
 11 | 
 12 |     This code should be minified before deployment.
 13 |     See http://javascript.crockford.com/jsmin.html
 14 | 
 15 |     USE YOUR OWN COPY. IT IS EXTREMELY UNWISE TO LOAD CODE FROM SERVERS YOU DO
 16 |     NOT CONTROL.
 17 | 
 18 | 
 19 |     This file creates a global JSON object containing two methods: stringify
 20 |     and parse.
 21 | 
 22 |         JSON.stringify(value, replacer, space)
 23 |             value       any JavaScript value, usually an object or array.
 24 | 
 25 |             replacer    an optional parameter that determines how object
 26 |                         values are stringified for objects. It can be a
 27 |                         function or an array of strings.
 28 | 
 29 |             space       an optional parameter that specifies the indentation
 30 |                         of nested structures. If it is omitted, the text will
 31 |                         be packed without extra whitespace. If it is a number,
 32 |                         it will specify the number of spaces to indent at each
 33 |                         level. If it is a string (such as '\t' or '&nbsp;'),
 34 |                         it contains the characters used to indent at each level.
 35 | 
 36 |             This method produces a JSON text from a JavaScript value.
 37 | 
 38 |             When an object value is found, if the object contains a toJSON
 39 |             method, its toJSON method will be called and the result will be
 40 |             stringified. A toJSON method does not serialize: it returns the
 41 |             value represented by the name/value pair that should be serialized,
 42 |             or undefined if nothing should be serialized. The toJSON method
 43 |             will be passed the key associated with the value, and this will be
 44 |             bound to the value
 45 | 
 46 |             For example, this would serialize Dates as ISO strings.
 47 | 
 48 |                 Date.prototype.toJSON = function (key) {
 49 |                     function f(n) {
 50 |                         // Format integers to have at least two digits.
 51 |                         return n < 10 ? '0' + n : n;
 52 |                     }
 53 | 
 54 |                     return this.getUTCFullYear()   + '-' +
 55 |                          f(this.getUTCMonth() + 1) + '-' +
 56 |                          f(this.getUTCDate())      + 'T' +
 57 |                          f(this.getUTCHours())     + ':' +
 58 |                          f(this.getUTCMinutes())   + ':' +
 59 |                          f(this.getUTCSeconds())   + 'Z';
 60 |                 };
 61 | 
 62 |             You can provide an optional replacer method. It will be passed the
 63 |             key and value of each member, with this bound to the containing
 64 |             object. The value that is returned from your method will be
 65 |             serialized. If your method returns undefined, then the member will
 66 |             be excluded from the serialization.
 67 | 
 68 |             If the replacer parameter is an array of strings, then it will be
 69 |             used to select the members to be serialized. It filters the results
 70 |             such that only members with keys listed in the replacer array are
 71 |             stringified.
 72 | 
 73 |             Values that do not have JSON representations, such as undefined or
 74 |             functions, will not be serialized. Such values in objects will be
 75 |             dropped; in arrays they will be replaced with null. You can use
 76 |             a replacer function to replace those with JSON values.
 77 |             JSON.stringify(undefined) returns undefined.
 78 | 
 79 |             The optional space parameter produces a stringification of the
 80 |             value that is filled with line breaks and indentation to make it
 81 |             easier to read.
 82 | 
 83 |             If the space parameter is a non-empty string, then that string will
 84 |             be used for indentation. If the space parameter is a number, then
 85 |             the indentation will be that many spaces.
 86 | 
 87 |             Example:
 88 | 
 89 |             text = JSON.stringify(['e', {pluribus: 'unum'}]);
 90 |             // text is '["e",{"pluribus":"unum"}]'
 91 | 
 92 | 
 93 |             text = JSON.stringify(['e', {pluribus: 'unum'}], null, '\t');
 94 |             // text is '[\n\t"e",\n\t{\n\t\t"pluribus": "unum"\n\t}\n]'
 95 | 
 96 |             text = JSON.stringify([new Date()], function (key, value) {
 97 |                 return this[key] instanceof Date ?
 98 |                     'Date(' + this[key] + ')' : value;
 99 |             });
100 |             // text is '["Date(---current time---)"]'
101 | 
102 | 
103 |         JSON.parse(text, reviver)
104 |             This method parses a JSON text to produce an object or array.
105 |             It can throw a SyntaxError exception.
106 | 
107 |             The optional reviver parameter is a function that can filter and
108 |             transform the results. It receives each of the keys and values,
109 |             and its return value is used instead of the original value.
110 |             If it returns what it received, then the structure is not modified.
111 |             If it returns undefined then the member is deleted.
112 | 
113 |             Example:
114 | 
115 |             // Parse the text. Values that look like ISO date strings will
116 |             // be converted to Date objects.
117 | 
118 |             myData = JSON.parse(text, function (key, value) {
119 |                 var a;
120 |                 if (typeof value === 'string') {
121 |                     a =
122 | /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2}(?:\.\d*)?)Z$/.exec(value);
123 |                     if (a) {
124 |                         return new Date(Date.UTC(+a[1], +a[2] - 1, +a[3], +a[4],
125 |                             +a[5], +a[6]));
126 |                     }
127 |                 }
128 |                 return value;
129 |             });
130 | 
131 |             myData = JSON.parse('["Date(09/09/2001)"]', function (key, value) {
132 |                 var d;
133 |                 if (typeof value === 'string' &&
134 |                         value.slice(0, 5) === 'Date(' &&
135 |                         value.slice(-1) === ')') {
136 |                     d = new Date(value.slice(5, -1));
137 |                     if (d) {
138 |                         return d;
139 |                     }
140 |                 }
141 |                 return value;
142 |             });
143 | 
144 | 
145 |     This is a reference implementation. You are free to copy, modify, or
146 |     redistribute.
147 | */
148 | 
149 | /*jslint evil: true, strict: false */
150 | 
151 | /*members "", "\b", "\t", "\n", "\f", "\r", "\"", JSON, "\\", apply,
152 |     call, charCodeAt, getUTCDate, getUTCFullYear, getUTCHours,
153 |     getUTCMinutes, getUTCMonth, getUTCSeconds, hasOwnProperty, join,
154 |     lastIndex, length, parse, prototype, push, replace, slice, stringify,
155 |     test, toJSON, toString, valueOf
156 | */
157 | 
158 | 
159 | // Create a JSON object only if one does not already exist. We create the
160 | // methods in a closure to avoid creating global variables.
161 | 
162 | if (!this.JSON) {
163 |     this.JSON = {};
164 | }
165 | 
166 | (function () {
167 | 
168 |     function f(n) {
169 |         // Format integers to have at least two digits.
170 |         return n < 10 ? '0' + n : n;
171 |     }
172 | 
173 |     if (typeof Date.prototype.toJSON !== 'function') {
174 | 
175 |         Date.prototype.toJSON = function (key) {
176 | 
177 |             return isFinite(this.valueOf()) ?
178 |                    this.getUTCFullYear()   + '-' +
179 |                  f(this.getUTCMonth() + 1) + '-' +
180 |                  f(this.getUTCDate())      + 'T' +
181 |                  f(this.getUTCHours())     + ':' +
182 |                  f(this.getUTCMinutes())   + ':' +
183 |                  f(this.getUTCSeconds())   + 'Z' : null;
184 |         };
185 | 
186 |         String.prototype.toJSON =
187 |         Number.prototype.toJSON =
188 |         Boolean.prototype.toJSON = function (key) {
189 |             return this.valueOf();
190 |         };
191 |     }
192 | 
193 |     var cx = /[\u0000\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g,
194 |         escapable = /[\\\"\x00-\x1f\x7f-\x9f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g,
195 |         gap,
196 |         indent,
197 |         meta = {    // table of character substitutions
198 |             '\b': '\\b',
199 |             '\t': '\\t',
200 |             '\n': '\\n',
201 |             '\f': '\\f',
202 |             '\r': '\\r',
203 |             '"' : '\\"',
204 |             '\\': '\\\\'
205 |         },
206 |         rep;
207 | 
208 | 
209 |     function quote(string) {
210 | 
211 | // If the string contains no control characters, no quote characters, and no
212 | // backslash characters, then we can safely slap some quotes around it.
213 | // Otherwise we must also replace the offending characters with safe escape
214 | // sequences.
215 | 
216 |         escapable.lastIndex = 0;
217 |         return escapable.test(string) ?
218 |             '"' + string.replace(escapable, function (a) {
219 |                 var c = meta[a];
220 |                 return typeof c === 'string' ? c :
221 |                     '\\u' + ('0000' + a.charCodeAt(0).toString(16)).slice(-4);
222 |             }) + '"' :
223 |             '"' + string + '"';
224 |     }
225 | 
226 | 
227 |     function str(key, holder) {
228 | 
229 | // Produce a string from holder[key].
230 | 
231 |         var i,          // The loop counter.
232 |             k,          // The member key.
233 |             v,          // The member value.
234 |             length,
235 |             mind = gap,
236 |             partial,
237 |             value = holder[key];
238 | 
239 | // If the value has a toJSON method, call it to obtain a replacement value.
240 | 
241 |         if (value && typeof value === 'object' &&
242 |                 typeof value.toJSON === 'function') {
243 |             value = value.toJSON(key);
244 |         }
245 | 
246 | // If we were called with a replacer function, then call the replacer to
247 | // obtain a replacement value.
248 | 
249 |         if (typeof rep === 'function') {
250 |             value = rep.call(holder, key, value);
251 |         }
252 | 
253 | // What happens next depends on the value's type.
254 | 
255 |         switch (typeof value) {
256 |         case 'string':
257 |             return quote(value);
258 | 
259 |         case 'number':
260 | 
261 | // JSON numbers must be finite. Encode non-finite numbers as null.
262 | 
263 |             return isFinite(value) ? String(value) : 'null';
264 | 
265 |         case 'boolean':
266 |         case 'null':
267 | 
268 | // If the value is a boolean or null, convert it to a string. Note:
269 | // typeof null does not produce 'null'. The case is included here in
270 | // the remote chance that this gets fixed someday.
271 | 
272 |             return String(value);
273 | 
274 | // If the type is 'object', we might be dealing with an object or an array or
275 | // null.
276 | 
277 |         case 'object':
278 | 
279 | // Due to a specification blunder in ECMAScript, typeof null is 'object',
280 | // so watch out for that case.
281 | 
282 |             if (!value) {
283 |                 return 'null';
284 |             }
285 | 
286 | // Make an array to hold the partial results of stringifying this object value.
287 | 
288 |             gap += indent;
289 |             partial = [];
290 | 
291 | // Is the value an array?
292 | 
293 |             if (Object.prototype.toString.apply(value) === '[object Array]') {
294 | 
295 | // The value is an array. Stringify every element. Use null as a placeholder
296 | // for non-JSON values.
297 | 
298 |                 length = value.length;
299 |                 for (i = 0; i < length; i += 1) {
300 |                     partial[i] = str(i, value) || 'null';
301 |                 }
302 | 
303 | // Join all of the elements together, separated with commas, and wrap them in
304 | // brackets.
305 | 
306 |                 v = partial.length === 0 ? '[]' :
307 |                     gap ? '[\n' + gap +
308 |                             partial.join(',\n' + gap) + '\n' +
309 |                                 mind + ']' :
310 |                           '[' + partial.join(',') + ']';
311 |                 gap = mind;
312 |                 return v;
313 |             }
314 | 
315 | // If the replacer is an array, use it to select the members to be stringified.
316 | 
317 |             if (rep && typeof rep === 'object') {
318 |                 length = rep.length;
319 |                 for (i = 0; i < length; i += 1) {
320 |                     k = rep[i];
321 |                     if (typeof k === 'string') {
322 |                         v = str(k, value);
323 |                         if (v) {
324 |                             partial.push(quote(k) + (gap ? ': ' : ':') + v);
325 |                         }
326 |                     }
327 |                 }
328 |             } else {
329 | 
330 | // Otherwise, iterate through all of the keys in the object.
331 | 
332 |                 for (k in value) {
333 |                     if (Object.hasOwnProperty.call(value, k)) {
334 |                         v = str(k, value);
335 |                         if (v) {
336 |                             partial.push(quote(k) + (gap ? ': ' : ':') + v);
337 |                         }
338 |                     }
339 |                 }
340 |             }
341 | 
342 | // Join all of the member texts together, separated with commas,
343 | // and wrap them in braces.
344 | 
345 |             v = partial.length === 0 ? '{}' :
346 |                 gap ? '{\n' + gap + partial.join(',\n' + gap) + '\n' +
347 |                         mind + '}' : '{' + partial.join(',') + '}';
348 |             gap = mind;
349 |             return v;
350 |         }
351 |     }
352 | 
353 | // If the JSON object does not yet have a stringify method, give it one.
354 | 
355 |     if (typeof JSON.stringify !== 'function') {
356 |         JSON.stringify = function (value, replacer, space) {
357 | 
358 | // The stringify method takes a value and an optional replacer, and an optional
359 | // space parameter, and returns a JSON text. The replacer can be a function
360 | // that can replace values, or an array of strings that will select the keys.
361 | // A default replacer method can be provided. Use of the space parameter can
362 | // produce text that is more easily readable.
363 | 
364 |             var i;
365 |             gap = '';
366 |             indent = '';
367 | 
368 | // If the space parameter is a number, make an indent string containing that
369 | // many spaces.
370 | 
371 |             if (typeof space === 'number') {
372 |                 for (i = 0; i < space; i += 1) {
373 |                     indent += ' ';
374 |                 }
375 | 
376 | // If the space parameter is a string, it will be used as the indent string.
377 | 
378 |             } else if (typeof space === 'string') {
379 |                 indent = space;
380 |             }
381 | 
382 | // If there is a replacer, it must be a function or an array.
383 | // Otherwise, throw an error.
384 | 
385 |             rep = replacer;
386 |             if (replacer && typeof replacer !== 'function' &&
387 |                     (typeof replacer !== 'object' ||
388 |                      typeof replacer.length !== 'number')) {
389 |                 throw new Error('JSON.stringify');
390 |             }
391 | 
392 | // Make a fake root object containing our value under the key of ''.
393 | // Return the result of stringifying the value.
394 | 
395 |             return str('', {'': value});
396 |         };
397 |     }
398 | 
399 | 
400 | // If the JSON object does not yet have a parse method, give it one.
401 | 
402 |     if (typeof JSON.parse !== 'function') {
403 |         JSON.parse = function (text, reviver) {
404 | 
405 | // The parse method takes a text and an optional reviver function, and returns
406 | // a JavaScript value if the text is a valid JSON text.
407 | 
408 |             var j;
409 | 
410 |             function walk(holder, key) {
411 | 
412 | // The walk method is used to recursively walk the resulting structure so
413 | // that modifications can be made.
414 | 
415 |                 var k, v, value = holder[key];
416 |                 if (value && typeof value === 'object') {
417 |                     for (k in value) {
418 |                         if (Object.hasOwnProperty.call(value, k)) {
419 |                             v = walk(value, k);
420 |                             if (v !== undefined) {
421 |                                 value[k] = v;
422 |                             } else {
423 |                                 delete value[k];
424 |                             }
425 |                         }
426 |                     }
427 |                 }
428 |                 return reviver.call(holder, key, value);
429 |             }
430 | 
431 | 
432 | // Parsing happens in four stages. In the first stage, we replace certain
433 | // Unicode characters with escape sequences. JavaScript handles many characters
434 | // incorrectly, either silently deleting them, or treating them as line endings.
435 | 
436 |             text = String(text);
437 |             cx.lastIndex = 0;
438 |             if (cx.test(text)) {
439 |                 text = text.replace(cx, function (a) {
440 |                     return '\\u' +
441 |                         ('0000' + a.charCodeAt(0).toString(16)).slice(-4);
442 |                 });
443 |             }
444 | 
445 | // In the second stage, we run the text against regular expressions that look
446 | // for non-JSON patterns. We are especially concerned with '()' and 'new'
447 | // because they can cause invocation, and '=' because it can cause mutation.
448 | // But just to be safe, we want to reject all unexpected forms.
449 | 
450 | // We split the second stage into 4 regexp operations in order to work around
451 | // crippling inefficiencies in IE's and Safari's regexp engines. First we
452 | // replace the JSON backslash pairs with '@' (a non-JSON character). Second, we
453 | // replace all simple value tokens with ']' characters. Third, we delete all
454 | // open brackets that follow a colon or comma or that begin the text. Finally,
455 | // we look to see that the remaining characters are only whitespace or ']' or
456 | // ',' or ':' or '{' or '}'. If that is so, then the text is safe for eval.
457 | 
458 |             if (/^[\],:{}\s]*$/.
459 | test(text.replace(/\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g, '@').
460 | replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, ']').
461 | replace(/(?:^|:|,)(?:\s*\[)+/g, ''))) {
462 | 
463 | // In the third stage we use the eval function to compile the text into a
464 | // JavaScript structure. The '{' operator is subject to a syntactic ambiguity
465 | // in JavaScript: it can begin a block or an object literal. We wrap the text
466 | // in parens to eliminate the ambiguity.
467 | 
468 |                 j = eval('(' + text + ')');
469 | 
470 | // In the optional fourth stage, we recursively walk the new structure, passing
471 | // each name/value pair to a reviver function for possible transformation.
472 | 
473 |                 return typeof reviver === 'function' ?
474 |                     walk({'': j}, '') : j;
475 |             }
476 | 
477 | // If the text is not JSON parseable, then a SyntaxError is thrown.
478 | 
479 |             throw new SyntaxError('JSON.parse');
480 |         };
481 |     }
482 | }());
483 | 


--------------------------------------------------------------------------------
/spec/lib/qunit-1.10.0.css:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * QUnit v1.10.0 - A JavaScript Unit Testing Framework
  3 |  *
  4 |  * http://qunitjs.com
  5 |  *
  6 |  * Copyright 2012 jQuery Foundation and other contributors
  7 |  * Released under the MIT license.
  8 |  * http://jquery.org/license
  9 |  */
 10 | 
 11 | /** Font Family and Sizes */
 12 | 
 13 | #qunit-tests, #qunit-header, #qunit-banner, #qunit-testrunner-toolbar, #qunit-userAgent, #qunit-testresult {
 14 | 	font-family: "Helvetica Neue Light", "HelveticaNeue-Light", "Helvetica Neue", Calibri, Helvetica, Arial, sans-serif;
 15 | }
 16 | 
 17 | #qunit-testrunner-toolbar, #qunit-userAgent, #qunit-testresult, #qunit-tests li { font-size: small; }
 18 | #qunit-tests { font-size: smaller; }
 19 | 
 20 | 
 21 | /** Resets */
 22 | 
 23 | #qunit-tests, #qunit-tests ol, #qunit-header, #qunit-banner, #qunit-userAgent, #qunit-testresult, #qunit-modulefilter {
 24 | 	margin: 0;
 25 | 	padding: 0;
 26 | }
 27 | 
 28 | 
 29 | /** Header */
 30 | 
 31 | #qunit-header {
 32 | 	padding: 0.5em 0 0.5em 1em;
 33 | 
 34 | 	color: #8699a4;
 35 | 	background-color: #0d3349;
 36 | 
 37 | 	font-size: 1.5em;
 38 | 	line-height: 1em;
 39 | 	font-weight: normal;
 40 | 
 41 | 	border-radius: 5px 5px 0 0;
 42 | 	-moz-border-radius: 5px 5px 0 0;
 43 | 	-webkit-border-top-right-radius: 5px;
 44 | 	-webkit-border-top-left-radius: 5px;
 45 | }
 46 | 
 47 | #qunit-header a {
 48 | 	text-decoration: none;
 49 | 	color: #c2ccd1;
 50 | }
 51 | 
 52 | #qunit-header a:hover,
 53 | #qunit-header a:focus {
 54 | 	color: #fff;
 55 | }
 56 | 
 57 | #qunit-testrunner-toolbar label {
 58 | 	display: inline-block;
 59 | 	padding: 0 .5em 0 .1em;
 60 | }
 61 | 
 62 | #qunit-banner {
 63 | 	height: 5px;
 64 | }
 65 | 
 66 | #qunit-testrunner-toolbar {
 67 | 	padding: 0.5em 0 0.5em 2em;
 68 | 	color: #5E740B;
 69 | 	background-color: #eee;
 70 | 	overflow: hidden;
 71 | }
 72 | 
 73 | #qunit-userAgent {
 74 | 	padding: 0.5em 0 0.5em 2.5em;
 75 | 	background-color: #2b81af;
 76 | 	color: #fff;
 77 | 	text-shadow: rgba(0, 0, 0, 0.5) 2px 2px 1px;
 78 | }
 79 | 
 80 | #qunit-modulefilter-container {
 81 | 	float: right;
 82 | }
 83 | 
 84 | /** Tests: Pass/Fail */
 85 | 
 86 | #qunit-tests {
 87 | 	list-style-position: inside;
 88 | }
 89 | 
 90 | #qunit-tests li {
 91 | 	padding: 0.4em 0.5em 0.4em 2.5em;
 92 | 	border-bottom: 1px solid #fff;
 93 | 	list-style-position: inside;
 94 | }
 95 | 
 96 | #qunit-tests.hidepass li.pass, #qunit-tests.hidepass li.running  {
 97 | 	display: none;
 98 | }
 99 | 
100 | #qunit-tests li strong {
101 | 	cursor: pointer;
102 | }
103 | 
104 | #qunit-tests li a {
105 | 	padding: 0.5em;
106 | 	color: #c2ccd1;
107 | 	text-decoration: none;
108 | }
109 | #qunit-tests li a:hover,
110 | #qunit-tests li a:focus {
111 | 	color: #000;
112 | }
113 | 
114 | #qunit-tests ol {
115 | 	margin-top: 0.5em;
116 | 	padding: 0.5em;
117 | 
118 | 	background-color: #fff;
119 | 
120 | 	border-radius: 5px;
121 | 	-moz-border-radius: 5px;
122 | 	-webkit-border-radius: 5px;
123 | }
124 | 
125 | #qunit-tests table {
126 | 	border-collapse: collapse;
127 | 	margin-top: .2em;
128 | }
129 | 
130 | #qunit-tests th {
131 | 	text-align: right;
132 | 	vertical-align: top;
133 | 	padding: 0 .5em 0 0;
134 | }
135 | 
136 | #qunit-tests td {
137 | 	vertical-align: top;
138 | }
139 | 
140 | #qunit-tests pre {
141 | 	margin: 0;
142 | 	white-space: pre-wrap;
143 | 	word-wrap: break-word;
144 | }
145 | 
146 | #qunit-tests del {
147 | 	background-color: #e0f2be;
148 | 	color: #374e0c;
149 | 	text-decoration: none;
150 | }
151 | 
152 | #qunit-tests ins {
153 | 	background-color: #ffcaca;
154 | 	color: #500;
155 | 	text-decoration: none;
156 | }
157 | 
158 | /*** Test Counts */
159 | 
160 | #qunit-tests b.counts                       { color: black; }
161 | #qunit-tests b.passed                       { color: #5E740B; }
162 | #qunit-tests b.failed                       { color: #710909; }
163 | 
164 | #qunit-tests li li {
165 | 	padding: 5px;
166 | 	background-color: #fff;
167 | 	border-bottom: none;
168 | 	list-style-position: inside;
169 | }
170 | 
171 | /*** Passing Styles */
172 | 
173 | #qunit-tests li li.pass {
174 | 	color: #3c510c;
175 | 	background-color: #fff;
176 | 	border-left: 10px solid #C6E746;
177 | }
178 | 
179 | #qunit-tests .pass                          { color: #528CE0; background-color: #D2E0E6; }
180 | #qunit-tests .pass .test-name               { color: #366097; }
181 | 
182 | #qunit-tests .pass .test-actual,
183 | #qunit-tests .pass .test-expected           { color: #999999; }
184 | 
185 | #qunit-banner.qunit-pass                    { background-color: #C6E746; }
186 | 
187 | /*** Failing Styles */
188 | 
189 | #qunit-tests li li.fail {
190 | 	color: #710909;
191 | 	background-color: #fff;
192 | 	border-left: 10px solid #EE5757;
193 | 	white-space: pre;
194 | }
195 | 
196 | #qunit-tests > li:last-child {
197 | 	border-radius: 0 0 5px 5px;
198 | 	-moz-border-radius: 0 0 5px 5px;
199 | 	-webkit-border-bottom-right-radius: 5px;
200 | 	-webkit-border-bottom-left-radius: 5px;
201 | }
202 | 
203 | #qunit-tests .fail                          { color: #000000; background-color: #EE5757; }
204 | #qunit-tests .fail .test-name,
205 | #qunit-tests .fail .module-name             { color: #000000; }
206 | 
207 | #qunit-tests .fail .test-actual             { color: #EE5757; }
208 | #qunit-tests .fail .test-expected           { color: green;   }
209 | 
210 | #qunit-banner.qunit-fail                    { background-color: #EE5757; }
211 | 
212 | 
213 | /** Result */
214 | 
215 | #qunit-testresult {
216 | 	padding: 0.5em 0.5em 0.5em 2.5em;
217 | 
218 | 	color: #2b81af;
219 | 	background-color: #D2E0E6;
220 | 
221 | 	border-bottom: 1px solid white;
222 | }
223 | #qunit-testresult .module-name {
224 | 	font-weight: bold;
225 | }
226 | 
227 | /** Fixture */
228 | 
229 | #qunit-fixture {
230 | 	position: absolute;
231 | 	top: -10000px;
232 | 	left: -10000px;
233 | 	width: 1000px;
234 | 	height: 1000px;
235 | }
236 | 


--------------------------------------------------------------------------------
/spec/mappingBehaviors.js:
--------------------------------------------------------------------------------
   1 | module('Mapping');
   2 | 
   3 | test('ko.mapping.toJS should unwrap observable values', function () {
   4 | 	var atomicValues = ["hello", 123, true, null, undefined,
   5 | 	{
   6 | 		a: 1
   7 | 	}];
   8 | 	for (var i = 0; i < atomicValues.length; i++) {
   9 | 		var data = ko.observable(atomicValues[i]);
  10 | 		var result = ko.mapping.toJS(data);
  11 | 		equal(ko.isObservable(result), false);
  12 | 		deepEqual(result, atomicValues[i]);
  13 | 	}
  14 | });
  15 | 
  16 | test('ko.mapping.toJS should unwrap observable properties, including nested ones', function () {
  17 | 	var data = {
  18 | 		a: ko.observable(123),
  19 | 		b: {
  20 | 			b1: ko.observable(456),
  21 | 			b2: 789
  22 | 		}
  23 | 	};
  24 | 	var result = ko.mapping.toJS(data);
  25 | 	equal(result.a, 123);
  26 | 	equal(result.b.b1, 456);
  27 | 	equal(result.b.b2, 789);
  28 | });
  29 | 
  30 | test('ko.mapping.toJS should unwrap observable arrays and things inside them', function () {
  31 | 	var data = ko.observableArray(['a', 1,
  32 | 	{
  33 | 		someProp: ko.observable('Hey')
  34 | 	}]);
  35 | 	var result = ko.mapping.toJS(data);
  36 | 	equal(result.length, 3);
  37 | 	equal(result[0], 'a');
  38 | 	equal(result[1], 1);
  39 | 	equal(result[2].someProp, 'Hey');
  40 | });
  41 | 
  42 | test('ko.mapping.toJS should ignore specified single property', function() {
  43 | 	var data = {
  44 | 		a: "a",
  45 | 		b: "b"
  46 | 	};
  47 | 	
  48 | 	var result = ko.mapping.toJS(data, { ignore: "b" });
  49 | 	equal(result.a, "a");
  50 | 	equal(result.b, undefined);
  51 | });
  52 | 
  53 | test('ko.mapping.toJS should ignore specified single property on update', function() {
  54 | 	var data = {
  55 | 		a: "a",
  56 | 		b: "b",
  57 | 		c: "c"
  58 | 	};
  59 | 	
  60 | 	var result = ko.mapping.fromJS(data);
  61 | 	equal(result.a(), "a");
  62 | 	equal(result.b(), "b");
  63 | 	equal(result.c(), "c");
  64 | 	ko.mapping.fromJS({ a: "a2", b: "b2", c: "c2" }, { ignore: ["b", "c"] }, result);
  65 | 	equal(result.a(), "a2");
  66 | 	equal(result.b(), "b");
  67 | 	equal(result.c(), "c");
  68 | });
  69 | 
  70 | test('ko.mapping.toJS should ignore specified multiple properties', function() {
  71 | 	var data = {
  72 | 		a: { a1: "a1", a2: "a2" },
  73 | 		b: "b"
  74 | 	};
  75 | 	
  76 | 	var result = ko.mapping.fromJS(data, { ignore: ["a.a1", "b"] });
  77 | 	equal(result.a.a1, undefined);
  78 | 	equal(result.a.a2(), "a2");
  79 | 	equal(result.b, undefined);
  80 | 
  81 |     data.a.a1 = "a11";
  82 |     data.a.a2 = "a22";
  83 | 	ko.mapping.fromJS(data, {}, result);
  84 | 	equal(result.a.a1, undefined);
  85 | 	equal(result.a.a2(), "a22");
  86 | 	equal(result.b, undefined);
  87 | });
  88 | 
  89 | test('ko.mapping.fromJS should ignore specified single property', function() {
  90 | 	var data = {
  91 | 		a: "a",
  92 | 		b: "b"
  93 | 	};
  94 | 	
  95 | 	var result = ko.mapping.fromJS(data, { ignore: "b" });
  96 | 	equal(result.a(), "a");
  97 | 	equal(result.b, undefined);
  98 | });
  99 | 
 100 | test('ko.mapping.fromJS should ignore specified array item', function() {
 101 | 	var data = {
 102 | 		a: "a",
 103 | 		b: [{ b1: "v1" }, { b2: "v2" }] 
 104 | 	};
 105 | 	
 106 | 	var result = ko.mapping.fromJS(data, { ignore: "b[1].b2" });
 107 | 	equal(result.a(), "a");
 108 | 	equal(result.b()[0].b1(), "v1");
 109 | 	equal(result.b()[1].b2, undefined);
 110 | });
 111 | 
 112 | test('ko.mapping.fromJS should ignore specified single property, also when going back .toJS', function() {
 113 | 	var data = {
 114 | 		a: "a",
 115 | 		b: "b"
 116 | 	};
 117 | 	
 118 | 	var result = ko.mapping.fromJS(data, { ignore: "b" });
 119 | 	var js = ko.mapping.toJS(result);
 120 | 	equal(js.a, "a");
 121 | 	equal(js.b, undefined);
 122 | });
 123 | 
 124 | test('ko.mapping.fromJS should copy specified single property', function() {
 125 | 	var data = {
 126 | 		a: "a",
 127 | 		b: "b"
 128 | 	};
 129 | 	
 130 | 	var result = ko.mapping.fromJS(data, { copy: "b" });
 131 | 	equal(result.a(), "a");
 132 | 	equal(result.b, "b");
 133 | });
 134 | 
 135 | test('ko.mapping.fromJS should copy specified array', function() {
 136 | 	var data = {
 137 | 		a: "a",
 138 | 		b: ["b1", "b2"]
 139 | 	};
 140 | 	
 141 | 	var result = ko.mapping.fromJS(data, { copy: "b" });
 142 | 	equal(result.a(), "a");
 143 | 	deepEqual(result.b, ["b1", "b2"]);
 144 | });
 145 | 
 146 | test('ko.mapping.fromJS should copy specified array item', function() {
 147 | 	var data = {
 148 | 		a: "a",
 149 | 		b: [{ b1: "v1" }, { b2: "v2" }] 
 150 | 	};
 151 | 	
 152 | 	var result = ko.mapping.fromJS(data, { copy: "b[0].b1" });
 153 | 	equal(result.a(), "a");
 154 | 	equal(result.b()[0].b1, "v1");
 155 | 	equal(result.b()[1].b2(), "v2");
 156 | });
 157 | 
 158 | test('ko.mapping.fromJS should copy specified single property, also when going back .toJS', function() {
 159 | 	var data = {
 160 | 		a: "a",
 161 | 		b: "b"
 162 | 	};
 163 | 	
 164 | 	var result = ko.mapping.fromJS(data, { copy: "b" });
 165 | 	var js = ko.mapping.toJS(result);
 166 | 	equal(js.a, "a");
 167 | 	equal(js.b, "b");
 168 | });
 169 | 
 170 | test('ko.mapping.fromJS should copy specified single property, also when going back .toJS, except when overridden', function() {
 171 | 	var data = {
 172 | 		a: "a",
 173 | 		b: "b"
 174 | 	};
 175 | 	
 176 | 	var result = ko.mapping.fromJS(data, { copy: "b" });
 177 | 	var js = ko.mapping.toJS(result, { ignore: "b" });
 178 | 	equal(js.a, "a");
 179 | 	equal(js.b, undefined);
 180 | });
 181 | 
 182 | test('ko.mapping.toJS should include specified single property', function() {
 183 | 	var data = {
 184 | 		a: "a"
 185 | 	};
 186 | 	
 187 | 	var mapped = ko.mapping.fromJS(data);
 188 | 	mapped.c = 1;
 189 | 	mapped.d = 2;
 190 | 	var result = ko.mapping.toJS(mapped, { include: "c" });
 191 | 	equal(result.a, "a");
 192 | 	equal(result.c, 1);
 193 | 	equal(result.d, undefined);
 194 | });
 195 | 
 196 | test('ko.mapping.toJS should by default ignore the mapping property', function() {
 197 | 	var data = {
 198 | 		a: "a",
 199 | 		b: "b"
 200 | 	};
 201 | 	
 202 | 	var fromJS = ko.mapping.fromJS(data);
 203 | 	var result = ko.mapping.toJS(fromJS);
 204 | 	equal(result.a, "a");
 205 | 	equal(result.b, "b");
 206 | 	equal(result.__ko_mapping__, undefined);
 207 | });
 208 | 
 209 | test('ko.mapping.toJS should by default include the _destroy property', function() {
 210 | 	var data = {
 211 | 		a: "a"
 212 | 	};
 213 | 	
 214 | 	var fromJS = ko.mapping.fromJS(data);
 215 | 	fromJS._destroy = true;
 216 | 	var result = ko.mapping.toJS(fromJS);
 217 | 	equal(result.a, "a");
 218 | 	equal(result._destroy, true);
 219 | });
 220 | 
 221 | test('ko.mapping.toJS should merge the default includes', function() {
 222 | 	var data = {
 223 | 		a: "a"
 224 | 	};
 225 | 	
 226 | 	var fromJS = ko.mapping.fromJS(data);
 227 | 	fromJS.b = "b";
 228 | 	fromJS._destroy = true;
 229 | 	var result = ko.mapping.toJS(fromJS, { include: "b" });
 230 | 	equal(result.a, "a");
 231 | 	equal(result.b, "b");
 232 | 	equal(result._destroy, true);
 233 | });
 234 | 
 235 | test('ko.mapping.toJS should merge the default ignores', function() {
 236 | 	var data = {
 237 | 		a: "a",
 238 | 		b: "b",
 239 | 		c: "c"
 240 | 	};
 241 | 	
 242 | 	ko.mapping.defaultOptions().ignore = ["a"];
 243 | 	var fromJS = ko.mapping.fromJS(data);
 244 | 	var result = ko.mapping.toJS(fromJS, { ignore: "b" });
 245 | 	equal(result.a, undefined);
 246 | 	equal(result.b, undefined);
 247 | 	equal(result.c, "c");
 248 | });
 249 | 
 250 | test('ko.mapping.defaultOptions should by default include the _destroy property', function() {
 251 | 	notEqual(ko.utils.arrayIndexOf(ko.mapping.defaultOptions().include, "_destroy"), -1);
 252 | });
 253 | 
 254 | test('ko.mapping.defaultOptions.include should be an array', function() {
 255 | 	var didThrow = false;
 256 | 	try {
 257 | 		ko.mapping.defaultOptions().include = {};
 258 | 		ko.mapping.toJS({});
 259 | 	}
 260 | 	catch (ex) {
 261 | 		didThrow = true
 262 | 	}
 263 | 	equal(didThrow, true);
 264 | });
 265 | 
 266 | test('ko.mapping.defaultOptions.ignore should be an array', function() {
 267 | 	var didThrow = false;
 268 | 	try {
 269 | 		ko.mapping.defaultOptions().ignore = {};
 270 | 		ko.mapping.toJS({});
 271 | 	}
 272 | 	catch (ex) {
 273 | 		didThrow = true
 274 | 	}
 275 | 	equal(didThrow, true);
 276 | });
 277 | 
 278 | test('ko.mapping.defaultOptions can be set', function() {
 279 | 	var oldOptions = ko.mapping.defaultOptions();
 280 | 	ko.mapping.defaultOptions({ a: "a" });
 281 | 	var newOptions = ko.mapping.defaultOptions();
 282 | 	ko.mapping.defaultOptions(oldOptions);
 283 | 	equal(newOptions.a, "a");
 284 | });
 285 | 
 286 | test('recognized root-level options should be moved into a root namespace, leaving other options in place', function() {
 287 | 	var recognizedRootProperties = ['create', 'update', 'key', 'arrayChanged'];
 288 | 	
 289 | 	// Zero out the default options so they don't interfere with this test
 290 | 	ko.mapping.defaultOptions({});
 291 | 	
 292 | 	// Set up a mapping with root and child mappings
 293 | 	var mapping = {
 294 | 		ignore: ['a'],
 295 | 		copy: ['b'],
 296 | 		include: ['c'],
 297 | 		create: function(opts) { return opts.data; },
 298 | 		update: function(opts) { return opts.data; },
 299 | 		key: function(item) { return ko.utils.unwrapObservable(item.id); },
 300 | 		arrayChanged: function(event, item) { },
 301 | 		children: {
 302 | 			ignore: ['a1'],
 303 | 			copy: ['b1'],
 304 | 			include: ['c1'],
 305 | 			create: function(opts) { return opts.data; },
 306 | 			update: function(opts) { return opts.data; },
 307 | 			key: function(item) { return ko.utils.unwrapObservable(item.id); },
 308 | 			arrayChanged: function(event, item) { }
 309 | 		}
 310 | 	};
 311 | 	
 312 | 	// Run the mapping through ko.mapping.fromJS
 313 | 	var resultantMapping = ko.mapping.fromJS({}, mapping).__ko_mapping__;
 314 | 	
 315 | 	// Test that the recognized root-level mappings were moved into a root-level namespace
 316 | 	for(var i=recognizedRootProperties.length-1; i>=0; i--) {
 317 | 		notDeepEqual(resultantMapping[recognizedRootProperties[i]], mapping[[recognizedRootProperties[i]]]);
 318 | 		deepEqual(resultantMapping[''][recognizedRootProperties[i]], mapping[[recognizedRootProperties[i]]]);
 319 | 	};
 320 | 	
 321 | 	// Test that the non-recognized root-level and descendant mappings were left in place
 322 | 	for(property in mapping) {
 323 | 		window[recognizedRootProperties.indexOf(property) == -1 ? 'deepEqual' : 'notDeepEqual'](resultantMapping[property], mapping[property]);
 324 | 	};
 325 | });
 326 | 
 327 | test('ko.mapping.toJS should ignore properties that were not part of the original model', function () {
 328 | 	var data = {
 329 | 		a: 123,
 330 | 		b: {
 331 | 			b1: 456,
 332 | 			b2: [
 333 | 				"b21", "b22"
 334 | 			],
 335 | 		}
 336 | 	};
 337 | 	
 338 | 	var mapped = ko.mapping.fromJS(data);
 339 | 	mapped.extraProperty = ko.observable(333);
 340 | 	mapped.extraFunction = function() {};
 341 | 	
 342 | 	var unmapped = ko.mapping.toJS(mapped);
 343 | 	equal(unmapped.a, 123);
 344 | 	equal(unmapped.b.b1, 456);
 345 | 	equal(unmapped.b.b2[0], "b21");
 346 | 	equal(unmapped.b.b2[1], "b22");
 347 | 	equal(unmapped.extraProperty, undefined);
 348 | 	equal(unmapped.extraFunction, undefined);
 349 | 	equal(unmapped.__ko_mapping__, undefined);
 350 | });
 351 | 
 352 | test('ko.mapping.toJS should ignore properties that were not part of the original model when there are no nested create callbacks', function () {
 353 | 	var data = [
 354 | 		{
 355 | 			a: [{ id: "a1.1" }, { id: "a1.2" }]
 356 | 		}
 357 | 	];
 358 | 	
 359 | 	var mapped = ko.mapping.fromJS(data, {
 360 | 		create: function(options) {
 361 | 			return ko.mapping.fromJS(options.data);
 362 | 		}
 363 | 	});
 364 | 	mapped.extraProperty = ko.observable(333);
 365 | 	mapped.extraFunction = function() {};
 366 | 	
 367 | 	var unmapped = ko.mapping.toJS(mapped);
 368 | 	equal(unmapped[0].a[0].id, "a1.1");
 369 | 	equal(unmapped[0].a[1].id, "a1.2");
 370 | 	equal(unmapped.extraProperty, undefined);
 371 | 	equal(unmapped.extraFunction, undefined);
 372 | 	equal(unmapped.__ko_mapping__, undefined);
 373 | });
 374 | 
 375 | test('ko.mapping.toJS should ignore properties that were not part of the original model when there are nested create callbacks', function () {
 376 | 	var data = [
 377 | 		{
 378 | 			a: [{ id: "a1.1" }, { id: "a1.2" }]
 379 | 		}
 380 | 	];
 381 | 	
 382 | 	var nestedMappingOptions = {
 383 | 		a: {
 384 | 			create: function(options) {
 385 | 				return ko.mapping.fromJS(options.data);
 386 | 			}
 387 | 		}
 388 | 	};
 389 | 	
 390 | 	var mapped = ko.mapping.fromJS(data, {
 391 | 		create: function(options) {
 392 | 			return ko.mapping.fromJS(options.data, nestedMappingOptions);
 393 | 		}
 394 | 	});
 395 | 	mapped.extraProperty = ko.observable(333);
 396 | 	mapped.extraFunction = function() {};
 397 | 	
 398 | 	var unmapped = ko.mapping.toJS(mapped);
 399 | 	equal(unmapped[0].a[0].id, "a1.1");
 400 | 	equal(unmapped[0].a[1].id, "a1.2");
 401 | 	equal(unmapped.extraProperty, undefined);
 402 | 	equal(unmapped.extraFunction, undefined);
 403 | 	equal(unmapped.__ko_mapping__, undefined);
 404 | });
 405 | 
 406 | test('ko.mapping.toJS should ignore specified properties', function() {
 407 | 	var data = {
 408 | 		a: "a",
 409 | 		b: "b",
 410 | 		c: "c"
 411 | 	};
 412 | 	
 413 | 	var result = ko.mapping.toJS(data, { ignore: ["b", "c"] });
 414 | 	equal(result.a, "a");
 415 | 	equal(result.b, undefined);
 416 | 	equal(result.c, undefined);
 417 | });
 418 | 
 419 | test('ko.mapping.toJSON should ignore specified properties', function() {
 420 | 	var data = {
 421 | 		a: "a",
 422 | 		b: "b",
 423 | 		c: "c"
 424 | 	};
 425 | 	
 426 | 	var result = ko.mapping.toJSON(data, { ignore: ["b", "c"] });
 427 | 	equal(result, "{\"a\":\"a\"}");
 428 | });
 429 | 
 430 | test('ko.mapping.toJSON should unwrap everything and then stringify', function () {
 431 | 	var data = ko.observableArray(['a', 1,
 432 | 	{
 433 | 		someProp: ko.observable('Hey')
 434 | 	}]);
 435 | 	var result = ko.mapping.toJSON(data);
 436 | 
 437 | 	// Check via parsing so the specs are independent of browser-specific JSON string formatting
 438 | 	equal(typeof result, 'string');
 439 | 	var parsedResult = ko.utils.parseJson(result);
 440 | 	equal(parsedResult.length, 3);
 441 | 	equal(parsedResult[0], 'a');
 442 | 	equal(parsedResult[1], 1);
 443 | 	equal(parsedResult[2].someProp, 'Hey');
 444 | });
 445 | 
 446 | test('ko.mapping.fromJS should require a parameter', function () {
 447 | 	var didThrow = false;
 448 | 	try {
 449 | 		ko.mapping.fromJS()
 450 | 	}
 451 | 	catch (ex) {
 452 | 		didThrow = true
 453 | 	}
 454 | 	equal(didThrow, true);
 455 | });
 456 | 
 457 | test('ko.mapping.fromJS should return an observable if you supply an atomic value', function () {
 458 | 	var atomicValues = ["hello", 123, true, null, undefined];
 459 | 	for (var i = 0; i < atomicValues.length; i++) {
 460 | 		var result = ko.mapping.fromJS(atomicValues[i]);
 461 | 		equal(ko.isObservable(result), true);
 462 | 		equal(result(), atomicValues[i]);
 463 | 	}
 464 | });
 465 | 
 466 | test('ko.mapping.fromJS should be able to map into an existing object', function () {
 467 | 	var existingObj = {
 468 | 		a: "a"
 469 | 	};
 470 | 	
 471 | 	var obj = {
 472 | 		b: "b"
 473 | 	};
 474 | 	
 475 | 	ko.mapping.fromJS(obj, {}, existingObj);
 476 | 	
 477 | 	equal(ko.isObservable(existingObj.a), false);
 478 | 	equal(ko.isObservable(existingObj.b), true);
 479 | 	equal(existingObj.a, "a");
 480 | 	equal(existingObj.b(), "b");
 481 | });
 482 | 
 483 | test('ko.mapping.fromJS should return an observableArray if you supply an array, but should not wrap its entries in further observables', function () {
 484 | 	var sampleArray = ["a", "b"];
 485 | 	var result = ko.mapping.fromJS(sampleArray);
 486 | 	equal(typeof result.destroyAll, 'function'); // Just an example of a function on ko.observableArray but not on Array
 487 | 	equal(result().length, 2);
 488 | 	equal(result()[0], "a");
 489 | 	equal(result()[1], "b");
 490 | });
 491 | 
 492 | test('ko.mapping.fromJS should return an observableArray if you supply an array, and leave entries as observables if there is a create mapping that does that', function () {
 493 |         var sampleArray = {array: ["a", "b"]};
 494 |         var result = ko.mapping.fromJS(sampleArray, {
 495 |                 array: {
 496 |                         create: function(options) {
 497 |                                 return new ko.observable(options.data);
 498 |                         }
 499 |                 }
 500 |         });
 501 |         equal(result.array().length, 2);
 502 |         equal(ko.isObservable(result.array()[0]),true);
 503 |         equal(ko.isObservable(result.array()[1]),true);
 504 |         equal(result.array()[0](), "a");
 505 |         equal(result.array()[1](), "b");
 506 | });
 507 | 
 508 | test('ko.mapping.fromJS should not return an observable if you supply an object that could have properties', function () {
 509 | 	equal(ko.isObservable(ko.mapping.fromJS({})), false);
 510 | });
 511 | 
 512 | test('ko.mapping.fromJS should not wrap functions in an observable', function () {
 513 | 	var result = ko.mapping.fromJS({}, {
 514 | 		create: function(model) {
 515 | 			return {
 516 | 				myFunc: function() {
 517 | 					return 123;
 518 | 				}
 519 | 			}
 520 | 		}
 521 | 	});
 522 | 	equal(result.myFunc(), 123);
 523 | });
 524 | 
 525 | test('ko.mapping.fromJS update callbacks should pass in a non-observable', function () {
 526 | 	var result = ko.mapping.fromJS({
 527 | 		obj: { a: "a" }
 528 | 	}, {
 529 | 		obj: {
 530 | 			update: function(options) {
 531 | 				equal(options.observable, undefined);
 532 | 				return { b: "b" };
 533 | 			}
 534 | 		}
 535 | 	});
 536 | 	equal(result.obj.b, "b");
 537 | });
 538 | 
 539 | test('ko.mapping.fromJS update callbacks should pass in an observable, when original is also observable', function () {
 540 | 	var result = ko.mapping.fromJS({
 541 | 		obj: ko.observable("a")
 542 | 	}, {
 543 | 		obj: {
 544 | 			update: function(options) {
 545 | 				return options.observable() + "ab";
 546 | 			}
 547 | 		}
 548 | 	});
 549 | 	equal(result.obj(), "aab");
 550 | });
 551 | 
 552 | test('ko.mapping.fromJS update callbacks should pass in an observable, when original is not observable', function () {
 553 | 	var result = ko.mapping.fromJS({
 554 | 		obj: "a"
 555 | 	}, {
 556 | 		obj: {
 557 | 			update: function(options) {
 558 | 				return options.observable() + "ab";
 559 | 			}
 560 | 		}
 561 | 	});
 562 | 	equal(result.obj(), "aab");
 563 | });
 564 | 
 565 | test('ko.mapping.fromJS should map the top-level atomic properties on the supplied object as observables', function () {
 566 | 	var result = ko.mapping.fromJS({
 567 | 		a: 123,
 568 | 		b: 'Hello',
 569 | 		c: true
 570 | 	});
 571 | 	equal(ko.isObservable(result.a), true);
 572 | 	equal(ko.isObservable(result.b), true);
 573 | 	equal(ko.isObservable(result.c), true);
 574 | 	equal(result.a(), 123);
 575 | 	equal(result.b(), 'Hello');
 576 | 	equal(result.c(), true);
 577 | });
 578 | 
 579 | test('ko.mapping.fromJS should not map the top-level non-atomic properties on the supplied object as observables', function () {
 580 | 	var result = ko.mapping.fromJS({
 581 | 		a: {
 582 | 			a1: "Hello"
 583 | 		}
 584 | 	});
 585 | 	equal(ko.isObservable(result.a), false);
 586 | 	equal(ko.isObservable(result.a.a1), true);
 587 | 	equal(result.a.a1(), 'Hello');
 588 | });
 589 | 
 590 | test('ko.mapping.fromJS should not map the top-level non-atomic properties on the supplied overriden model as observables', function () {
 591 | 	var result = ko.mapping.fromJS({
 592 | 		a: {
 593 | 			a2: "a2"
 594 | 		}
 595 | 	}, {
 596 | 		create: function(model) {
 597 | 			return {
 598 | 				a: {
 599 | 					a1: "a1"
 600 | 				}
 601 | 			};
 602 | 		}
 603 | 	});
 604 | 	equal(ko.isObservable(result.a), false);
 605 | 	equal(ko.isObservable(result.a.a1), false);
 606 | 	equal(result.a.a2, undefined);
 607 | 	equal(result.a.a1, 'a1');
 608 | });
 609 | 
 610 | test('ko.mapping.fromJS should not map top-level objects on the supplied overriden model as observables', function () {
 611 | 	var dummyObject = function (options) {
 612 | 		this.a1 = options.a1;
 613 | 		return this;
 614 | 	}
 615 | 
 616 | 	var result = ko.mapping.fromJS({}, {
 617 | 		create: function(model) {
 618 | 			return {
 619 | 				a: new dummyObject({
 620 | 					a1: "Hello"
 621 | 				})
 622 | 			};
 623 | 		}
 624 | 	});
 625 | 	equal(ko.isObservable(result.a), false);
 626 | 	equal(ko.isObservable(result.a.a1), false);
 627 | 	equal(result.a.a1, 'Hello');
 628 | });
 629 | 
 630 | test('ko.mapping.fromJS should allow non-unique atomic properties', function () {
 631 | 	var vm = ko.mapping.fromJS({
 632 | 		a: [1, 2, 1]
 633 | 	});
 634 | 
 635 | 	deepEqual(vm.a(), [1, 2, 1]);
 636 | });
 637 | /* speed optimizations don't allow this anymore...
 638 | test('ko.mapping.fromJS should not allow non-unique non-atomic properties', function () {
 639 | 	var options = {
 640 | 		key: function(item) { return ko.utils.unwrapObservable(item.id); }
 641 | 	};
 642 | 
 643 | 	var didThrow = false;
 644 | 	try {
 645 | 		ko.mapping.fromJS([
 646 | 			{ id: "a1" },
 647 | 			{ id: "a2" },
 648 | 			{ id: "a1" }
 649 | 		], options);
 650 | 	}
 651 | 	catch (ex) {
 652 | 		didThrow = true
 653 | 	}
 654 | 	equal(didThrow, true);
 655 | });
 656 | */
 657 | test('ko.mapping.fromJS should map descendant properties on the supplied object as observables', function () {
 658 | 	var result = ko.mapping.fromJS({
 659 | 		a: {
 660 | 			a1: 'a1value',
 661 | 			a2: {
 662 | 				a21: 'a21value',
 663 | 				a22: 'a22value'
 664 | 			}
 665 | 		},
 666 | 		b: {
 667 | 			b1: null,
 668 | 			b2: undefined
 669 | 		}
 670 | 	});
 671 | 	equal(result.a.a1(), 'a1value');
 672 | 	equal(result.a.a2.a21(), 'a21value');
 673 | 	equal(result.a.a2.a22(), 'a22value');
 674 | 	equal(result.b.b1(), null);
 675 | 	equal(result.b.b2(), undefined);
 676 | });
 677 | 
 678 | test('ko.mapping.fromJS should map observable properties, but without adding a further observable wrapper', function () {
 679 | 	var result = ko.mapping.fromJS({
 680 | 		a: ko.observable('Hey')
 681 | 	});
 682 | 	equal(result.a(), 'Hey');
 683 | });
 684 | 
 685 | test('ko.mapping.fromJS should escape from reference cycles', function () {
 686 | 	var obj = {};
 687 | 	obj.someProp = {
 688 | 		owner: obj
 689 | 	};
 690 | 	var result = ko.mapping.fromJS(obj);
 691 | 	equal(result.someProp.owner === result, true);
 692 | });
 693 | 
 694 | test('ko.mapping.fromJS should send relevant create callbacks', function () {
 695 | 	var items = [];
 696 | 	var index = 0;
 697 | 	var result = ko.mapping.fromJS({
 698 | 		a: "hello"
 699 | 	}, {
 700 | 		create: function (model) {
 701 | 			index++;
 702 | 			return model;
 703 | 		}
 704 | 	});
 705 | 	equal(index, 1);
 706 | });
 707 | 
 708 | test('ko.mapping.fromJS should send relevant create callbacks when mapping arrays', function () {
 709 | 	var items = [];
 710 | 	var index = 0;
 711 | 	var result = ko.mapping.fromJS([
 712 | 		"hello"
 713 | 	], {
 714 | 		create: function (model) {
 715 | 			index++;
 716 | 			return model;
 717 | 		}
 718 | 	});
 719 | 	equal(index, 1);
 720 | });
 721 | 
 722 | test('ko.mapping.fromJS should send parent along to create callback when creating an object', function() {
 723 | 	var obj = {
 724 | 		a: "a",
 725 | 		b: {
 726 | 			b1: "b1"
 727 | 		}
 728 | 	};
 729 | 	
 730 | 	var result = ko.mapping.fromJS(obj, {
 731 | 		"b": {
 732 | 			create: function(options) {
 733 | 				equal(ko.isObservable(options.parent.a), true);
 734 | 				equal(options.parent.a(), "a");
 735 | 			}
 736 | 		}
 737 | 	});
 738 | });
 739 | 
 740 | test('ko.mapping.fromJS should send parent along to create callback when creating an array item inside an object', function() {
 741 | 	var obj = {
 742 | 		a: "a",
 743 | 		b: [
 744 | 			{ id: 1 },
 745 | 			{ id: 2 }
 746 | 		]
 747 | 	};
 748 | 	
 749 | 	var target = {};
 750 | 	var numCreated = 0;
 751 | 	var result = ko.mapping.fromJS(obj, {
 752 | 		"b": {
 753 | 			create: function(options) {
 754 | 				equal(ko.isObservable(options.parent), false);
 755 | 				equal(options.parent, target);
 756 | 				numCreated++;
 757 | 			}
 758 | 		}
 759 | 	}, target);
 760 | 	
 761 | 	equal(numCreated, 2);
 762 | });
 763 | 
 764 | test('ko.mapping.fromJS should send parent along to create callback when creating an array item inside an array', function() {
 765 | 	// parent is the array
 766 | 	
 767 | 	var obj = [
 768 | 		{ id: 1 },
 769 | 		{ id: 2 }
 770 | 	];
 771 | 	
 772 | 	var target = [];
 773 | 	var numCreated = 0;
 774 | 	var result = ko.mapping.fromJS(obj, {
 775 | 		create: function(options) {
 776 | 			equal(ko.isObservable(options.parent), true);
 777 | 			numCreated++;
 778 | 		}
 779 | 	}, target);
 780 | 	
 781 | 	equal(numCreated, 2);
 782 | });
 783 | 
 784 | test('ko.mapping.fromJS should update objects in arrays that were specified in the overriden model in the create callback', function () {
 785 | 	var options = {
 786 | 		create: function(options) {
 787 | 			return ko.mapping.fromJS(options.data);
 788 | 		}
 789 | 	}
 790 | 	
 791 | 	var result = ko.mapping.fromJS([], options);
 792 | 	ko.mapping.fromJS([{
 793 | 		a: "a",
 794 | 		b: "b"
 795 | 	}], {}, result);
 796 | 
 797 | 	equal(ko.isObservable(result), true);
 798 | 	equal(ko.isObservable(result()[0].a), true);
 799 | 	equal(result()[0].a(), "a");
 800 | 	equal(ko.isObservable(result()[0].b), true);
 801 | 	equal(result()[0].b(), "b");
 802 | });
 803 | 
 804 | test('ko.mapping.fromJS should use the create callback to update objects in arrays', function () {
 805 | 	var created = [];
 806 | 	var arrayEvents = 0;
 807 | 	
 808 | 	var options = {
 809 | 		key: function(item) { return ko.utils.unwrapObservable(item.id); },
 810 | 		create: function(options) {
 811 | 			created.push(options.data.id);
 812 | 			return ko.mapping.fromJS(options.data);
 813 | 		},
 814 | 		arrayChanged: function(event, item) {
 815 | 			arrayEvents++;
 816 | 		}
 817 | 	}
 818 | 	
 819 | 	var result = ko.mapping.fromJS([
 820 | 		{ id: "a" }
 821 | 	], options);
 822 | 	
 823 | 	ko.mapping.fromJS([
 824 | 		{ id: "a" },
 825 | 		{ id: "b" }
 826 | 	], {}, result);
 827 | 
 828 | 	equal(created[0], "a");
 829 | 	equal(created[1], "b");
 830 | 	equal(result()[0].id(), "a");
 831 | 	equal(result()[1].id(), "b");
 832 | 	equal(arrayEvents, 3); // added, retained, added
 833 | });
 834 | 
 835 | test('ko.mapping.fromJS should not call the create callback for existing objects', function () {
 836 | 	var numCreate = 0;
 837 | 	var options = {
 838 | 		create: function (model) {
 839 | 			numCreate++;
 840 | 			var overridenModel = {};
 841 | 			return overridenModel;
 842 | 		}
 843 | 	};
 844 | 	
 845 | 	var items = [];
 846 | 	var index = 0;
 847 | 	var result = ko.mapping.fromJS({
 848 | 		a: "hello"
 849 | 	}, options);
 850 | 
 851 | 	ko.mapping.fromJS({
 852 | 		a: "bye"
 853 | 	}, {}, result);
 854 | 
 855 | 	equal(numCreate, 1);
 856 | });
 857 | 
 858 | test('ko.mapping.fromJS should not overwrite the existing observable array', function () {
 859 | 	var result = ko.mapping.fromJS({
 860 | 		a: [1]
 861 | 	});
 862 | 	
 863 | 	var resultA = result.a;
 864 | 
 865 | 	ko.mapping.fromJS({
 866 | 		a: [1]
 867 | 	}, result);
 868 | 	
 869 | 	equal(resultA, result.a);
 870 | });
 871 | 
 872 | test('ko.mapping.fromJS should send an added callback for every array item that is added to a previously non-existent array', function () {
 873 | 	var added = [];
 874 | 
 875 | 	var options = {
 876 | 		"a" : {
 877 | 			arrayChanged: function (event, newValue) {
 878 | 				if (event === "added") added.push(newValue);
 879 | 			}
 880 | 		}
 881 | 	};
 882 | 	var result = ko.mapping.fromJS({}, options);
 883 | 	ko.mapping.fromJS({
 884 | 		a: [1, 2]
 885 | 	}, {}, result);
 886 | 	equal(added.length, 2);
 887 | 	equal(added[0], 1);
 888 | 	equal(added[1], 2);
 889 | });
 890 | 
 891 | test('ko.mapping.fromJS should send an added callback for every array item that is added to a previously empty array', function () {
 892 | 	var added = [];
 893 | 
 894 | 	var options = {
 895 | 		"a": {
 896 | 			arrayChanged: function (event, newValue) {
 897 | 				if (event === "added") added.push(newValue);
 898 | 			}
 899 | 		}
 900 | 	};
 901 | 	var result = ko.mapping.fromJS({ a: [] }, options);
 902 | 	ko.mapping.fromJS({
 903 | 		a: [1, 2]
 904 | 	}, {}, result);
 905 | 	equal(added.length, 2);
 906 | 	equal(added[0], 1);
 907 | 	equal(added[1], 2);
 908 | });
 909 | 
 910 | test('ko.mapping.fromJS should not make observable anything that is not in the js object', function () {
 911 | 	var result = ko.mapping.fromJS({});
 912 | 	result.a = "a";
 913 | 	equal(ko.isObservable(result.a), false);
 914 | 	
 915 | 	ko.mapping.fromJS({
 916 | 		b: "b"
 917 | 	}, {}, result);
 918 | 	
 919 | 	equal(ko.isObservable(result.a), false);
 920 | 	equal(ko.isObservable(result.b), true);
 921 | 	equal(result.a, "a");
 922 | 	equal(result.b(), "b");
 923 | });
 924 | 
 925 | test('ko.mapping.fromJS should not make observable anything that is not in the js object when overriding the model', function () {
 926 | 	var options = {
 927 | 		create: function(model) {
 928 | 			return {
 929 | 				a: "a"
 930 | 			}
 931 | 		}
 932 | 	};
 933 | 
 934 | 	var result = ko.mapping.fromJS({}, options);
 935 | 	ko.mapping.fromJS({
 936 | 		b: "b"
 937 | 	}, {}, result);
 938 | 	
 939 | 	equal(ko.isObservable(result.a), false);
 940 | 	equal(ko.isObservable(result.b), true);
 941 | 	equal(result.a, "a");
 942 | 	equal(result.b(), "b");
 943 | });
 944 | 
 945 | test('ko.mapping.fromJS should send an added callback for every array item that is added', function () {
 946 | 	var added = [];
 947 | 
 948 | 	var options = {
 949 | 		"a": {
 950 | 			arrayChanged: function (event, newValue) {
 951 | 				if (event === "added") added.push(newValue);
 952 | 			}
 953 | 		}
 954 | 	};
 955 | 	var result = ko.mapping.fromJS({
 956 | 		a: []
 957 | 	}, options);
 958 | 	ko.mapping.fromJS({
 959 | 		a: [1, 2]
 960 | 	}, {}, result);
 961 | 	equal(added.length, 2);
 962 | 	equal(added[0], 1);
 963 | 	equal(added[1], 2);
 964 | });
 965 | 
 966 | test('ko.mapping.fromJS should send an added callback for every array item that is added', function () {
 967 | 	var added = [];
 968 | 
 969 | 	var result = ko.mapping.fromJS({
 970 | 		a: [1, 2]
 971 | 	}, {
 972 | 		"a": {
 973 | 			arrayChanged: function (event, newValue) {
 974 | 				if (event === "added") added.push(newValue);
 975 | 			}
 976 | 		}
 977 | 	});
 978 | 	equal(added.length, 2);
 979 | 	equal(added[0], 1);
 980 | 	equal(added[1], 2);
 981 | });
 982 | 
 983 | test('ko.mapping.fromJSON should parse and then map in the same way', function () {
 984 | 	var jsonString = ko.utils.stringifyJson({ // Note that "undefined" property values are omitted by the stringifier, so not testing those
 985 | 		a: {
 986 | 			a1: 'a1value',
 987 | 			a2: {
 988 | 				a21: 'a21value',
 989 | 				a22: 'a22value'
 990 | 			}
 991 | 		},
 992 | 		b: {
 993 | 			b1: null
 994 | 		}
 995 | 	});
 996 | 	var result = ko.mapping.fromJSON(jsonString);
 997 | 	equal(result.a.a1(), 'a1value');
 998 | 	equal(result.a.a2.a21(), 'a21value');
 999 | 	equal(result.a.a2.a22(), 'a22value');
1000 | 	equal(result.b.b1(), null);
1001 | });
1002 | 
1003 | test('ko.mapping.fromJS should be able to map empty object structures', function () {
1004 | 	var obj = {
1005 | 		someProp: undefined,
1006 | 		a: []
1007 | 	};
1008 | 	var result = ko.mapping.fromJS(obj);
1009 | 	equal(ko.isObservable(result.someProp), true);
1010 | 	equal(ko.isObservable(result.a), true);
1011 | 	equal(ko.isObservable(result.unknownProperty), false);
1012 | });
1013 | 
1014 | test('ko.mapping.fromJS should send create callbacks when atomic items are constructed', function () {
1015 | 	var atomicValues = ["hello", 123, true, null, undefined];
1016 | 	var callbacksReceived = 0;
1017 | 	for (var i = 0; i < atomicValues.length; i++) {
1018 | 		var result = ko.mapping.fromJS(atomicValues[i], {
1019 | 			create: function (item) {
1020 | 				callbacksReceived++;
1021 | 				return item;
1022 | 			}
1023 | 		});
1024 | 	}
1025 | 	equal(callbacksReceived, 5);
1026 | });
1027 | 
1028 | test('ko.mapping.fromJS should send callbacks when atomic array elements are constructed', function () {
1029 | 	var oldItems = {
1030 | 		array: []
1031 | 	};
1032 | 	var newItems = {
1033 | 		array: [{
1034 | 			id: 1
1035 | 		},
1036 | 		{
1037 | 			id: 2
1038 | 		}]
1039 | 	};
1040 | 
1041 | 	var items = [];
1042 | 	var result = ko.mapping.fromJS(oldItems, {
1043 | 		"array": {
1044 | 			arrayChanged: function (event, item) {
1045 | 				if (event == "added")
1046 | 					items.push(item);
1047 | 			}
1048 | 		}
1049 | 	});
1050 | 	ko.mapping.fromJS(newItems, {}, result);
1051 | 	equal(items.length, 2);
1052 | });
1053 | 
1054 | test('ko.mapping.fromJS should not send callbacks containing parent names when descendant objects are constructed', function () {
1055 | 	var obj = {
1056 | 		a: {
1057 | 			a1: "hello",
1058 | 			a2: 234,
1059 | 			a3: {
1060 | 				a31: null
1061 | 			}
1062 | 		}
1063 | 	};
1064 | 	var parents = [];
1065 | 	var pushParent = function (item, parent) {
1066 | 		parents.push(parent);
1067 | 		return item;
1068 | 	};
1069 | 	var result = ko.mapping.fromJS(obj, {
1070 | 		create: pushParent
1071 | 	});
1072 | 	equal(parents.length, 1);
1073 | 	equal(parents[0], undefined);
1074 | });
1075 | 
1076 | test('ko.mapping.fromJS should create instead of update, on empty objects', function () {
1077 | 	var obj = {
1078 | 		a: ["a1", "a2"]
1079 | 	};
1080 | 
1081 | 	var result;
1082 | 	result = ko.mapping.fromJS({});
1083 | 	ko.mapping.fromJS(obj, {}, result);
1084 | 	equal(result.a().length, 2);
1085 | 	equal(result.a()[0], "a1");
1086 | 	equal(result.a()[1], "a2");
1087 | });
1088 | 
1089 | test('ko.mapping.fromJS should update atomic observables', function () {
1090 | 	var atomicValues = ["hello", 123, true, null, undefined];
1091 | 	var atomicValues2 = ["hello2", 124, false, "not null", "defined"];
1092 | 
1093 | 	for (var i = 0; i < atomicValues.length; i++) {
1094 | 		var result = ko.mapping.fromJS(atomicValues[i]);
1095 | 		ko.mapping.fromJS(atomicValues2[i], {}, result);
1096 | 		equal(ko.isObservable(result), true);
1097 | 		equal(result(), atomicValues2[i]);
1098 | 	}
1099 | });
1100 | 
1101 | test('ko.mapping.fromJS should update objects', function () {
1102 | 	var obj = {
1103 | 		a: "prop",
1104 | 		b: {
1105 | 			b1: null,
1106 | 			b2: "b2"
1107 | 		}
1108 | 	}
1109 | 
1110 | 	var obj2 = {
1111 | 		a: "prop2",
1112 | 		b: {
1113 | 			b1: 124,
1114 | 			b2: "b22"
1115 | 		}
1116 | 	}
1117 | 
1118 | 	var result = ko.mapping.fromJS(obj);
1119 | 	ko.mapping.fromJS(obj2, {}, result);
1120 | 	equal(result.a(), "prop2");
1121 | 	equal(result.b.b1(), 124);
1122 | 	equal(result.b.b2(), "b22");
1123 | });
1124 | 
1125 | test('ko.mapping.fromJS should update initially empty objects', function () {
1126 | 	var obj = {
1127 | 		a: undefined,
1128 | 		b: []
1129 | 	}
1130 | 
1131 | 	var obj2 = {
1132 | 		a: "prop2",
1133 | 		b: ["b1", "b2"]
1134 | 	}
1135 | 
1136 | 	var result = ko.mapping.fromJS(obj);
1137 | 	ko.mapping.fromJS(obj2, {}, result);
1138 | 	equal(result.a(), "prop2");
1139 | 	equal(result.b()[0], "b1");
1140 | 	equal(result.b()[1], "b2");
1141 | });
1142 | 
1143 | test('ko.mapping.fromJS should update arrays containing atomic types', function () {
1144 | 	var obj = ["a1", "a2", 6];
1145 | 	var obj2 = ["a3", "a4", 7];
1146 | 
1147 | 	var result = ko.mapping.fromJS(obj);
1148 | 
1149 | 	ko.mapping.fromJS(obj2, {}, result);
1150 | 	equal(result().length, 3);
1151 | 	equal(result()[0], "a3");
1152 | 	equal(result()[1], "a4");
1153 | 	equal(result()[2], 7);
1154 | });
1155 | 
1156 | test('ko.mapping.fromJS should update arrays containing objects', function () {
1157 | 	var obj = {
1158 | 		a: [{
1159 | 			id: 1,
1160 | 			value: "a1"
1161 | 		},
1162 | 		{
1163 | 			id: 2,
1164 | 			value: "a2"
1165 | 		}]
1166 | 	}
1167 | 
1168 | 	var obj2 = {
1169 | 		a: [{
1170 | 			id: 1,
1171 | 			value: "a1"
1172 | 		},
1173 | 		{
1174 | 			id: 3,
1175 | 			value: "a3"
1176 | 		}]
1177 | 	}
1178 | 
1179 | 	var options = {
1180 | 		"a": {
1181 | 			key: function (item) {
1182 | 				return item.id;
1183 | 			}
1184 | 		}
1185 | 	};
1186 | 	var result = ko.mapping.fromJS(obj, options);
1187 | 
1188 | 	ko.mapping.fromJS(obj2, {}, result);
1189 | 	equal(result.a().length, 2);
1190 | 	equal(result.a()[0].value(), "a1");
1191 | 	equal(result.a()[1].value(), "a3");
1192 | });
1193 | 
1194 | test('ko.mapping.fromJS should send a callback when adding new objects to an array', function () {
1195 | 	var obj = [{
1196 | 		id: 1
1197 | 	}];
1198 | 	var obj2 = [{
1199 | 		id: 1
1200 | 	},
1201 | 	{
1202 | 		id: 2
1203 | 	}];
1204 | 
1205 | 	var mappedItems = [];
1206 | 
1207 | 	var options = {
1208 | 		key: function(item) {
1209 | 			return item.id;
1210 | 		},
1211 | 		arrayChanged: function (event, item) {
1212 | 			if (event == "added") mappedItems.push(item);
1213 | 		}
1214 | 	};
1215 | 	var result = ko.mapping.fromJS(obj, options);
1216 | 	ko.mapping.fromJS(obj2, {}, result);
1217 | 	equal(mappedItems.length, 2);
1218 | 	equal(mappedItems[0].id(), 1);
1219 | 	equal(mappedItems[1].id(), 2);
1220 | });
1221 | 
1222 | test('ko.mapping.fromJS should be able to update from an observable source', function () {
1223 | 	var obj = [{
1224 | 		id: 1
1225 | 	}];
1226 | 	var obj2 = ko.mapping.fromJS([{
1227 | 		id: 1
1228 | 	},
1229 | 	{
1230 | 		id: 2
1231 | 	}]);
1232 | 
1233 | 	var result = ko.mapping.fromJS(obj);
1234 | 	ko.mapping.fromJS(obj2, {}, result);
1235 | 	equal(result().length, 2);
1236 | 	equal(result()[0].id(), 1);
1237 | 	equal(result()[1].id(), 2);
1238 | });
1239 | 
1240 | test('ko.mapping.fromJS should send a deleted callback when an item was deleted from an array', function () {
1241 | 	var obj = [1, 2];
1242 | 	var obj2 = [1];
1243 | 
1244 | 	var items = [];
1245 | 
1246 | 	var options = {
1247 | 		arrayChanged: function (event, item) {
1248 | 			if (event == "deleted") items.push(item);
1249 | 		}
1250 | 	};
1251 | 	var result = ko.mapping.fromJS(obj, options);
1252 | 	ko.mapping.fromJS(obj2, {}, result);
1253 | 	equal(items.length, 1);
1254 | 	equal(items[0], 2);
1255 | });
1256 | 
1257 | test('ko.mapping.fromJS should reuse options that were added in ko.mapping.fromJS', function() {
1258 | 	var viewModelMapping = {
1259 | 		key: function(data) {
1260 | 			return ko.utils.unwrapObservable(data.id);
1261 | 		},
1262 | 		create: function(options) {
1263 | 			return new viewModel(options);
1264 | 		}
1265 | 	};
1266 | 	
1267 | 	var viewModel = function(options) {
1268 | 		var mapping = {
1269 | 			entries: viewModelMapping
1270 | 		};
1271 | 
1272 | 		ko.mapping.fromJS(options.data, mapping, this);
1273 | 
1274 | 		this.func = function() { return true; };
1275 | 	};
1276 | 	
1277 | 	var model = ko.mapping.fromJS([], viewModelMapping);
1278 | 	
1279 | 	var data = [{
1280 | 		"id": 1,
1281 | 		"entries": [{
1282 | 			"id": 2,
1283 | 			"entries": [{
1284 | 				"id": 3,
1285 | 				"entries": []
1286 | 			}]
1287 | 		}]
1288 | 	}];
1289 | 	
1290 | 	ko.mapping.fromJS(data, {}, model);
1291 | 	ko.mapping.fromJS(data, {}, model);
1292 | 	
1293 | 	equal(model()[0].func(), true);
1294 | 	equal(model()[0].entries()[0].func(), true);
1295 | 	equal(model()[0].entries()[0].entries()[0].func(), true);
1296 | });
1297 | 
1298 | test('ko.mapping.toJS should not change the mapped object', function() {
1299 | 	var obj = {
1300 | 		a: "a"
1301 | 	}
1302 | 	
1303 | 	var result = ko.mapping.fromJS(obj);
1304 | 	result.b = ko.observable(123);
1305 | 	var toJS = ko.mapping.toJS(result);
1306 | 	
1307 | 	equal(ko.isObservable(result.b), true);
1308 | 	equal(result.b(), 123);
1309 | 	equal(toJS.b, undefined);
1310 | });
1311 | 
1312 | test('ko.mapping.toJS should not change the mapped array', function() {
1313 | 	var obj = [{
1314 | 		a: 50
1315 | 	}]
1316 | 	
1317 | 	var result = ko.mapping.fromJS(obj);
1318 | 	result()[0].b = ko.observable(123);
1319 | 	var toJS = ko.mapping.toJS(result);
1320 | 	
1321 | 	equal(ko.isObservable(result()[0].b), true);
1322 | 	equal(result()[0].b(), 123);
1323 | });
1324 | 
1325 | test('observableArray.mappedRemove should use key callback if available', function() {
1326 | 	var obj = [
1327 | 		{ id : 1 },
1328 | 		{ id : 2 }
1329 | 	]
1330 | 	
1331 | 	var result = ko.mapping.fromJS(obj, {
1332 | 		key: function(item) {
1333 | 			return ko.utils.unwrapObservable(item.id);
1334 | 		}
1335 | 	});
1336 | 	result.mappedRemove({ id : 2 });
1337 | 	equal(result().length, 1);
1338 | });
1339 | 
1340 | test('observableArray.mappedRemove with predicate should use key callback if available', function() {
1341 | 	var obj = [
1342 | 		{ id : 1 },
1343 | 		{ id : 2 }
1344 | 	]
1345 | 	
1346 | 	var result = ko.mapping.fromJS(obj, {
1347 | 		key: function(item) {
1348 | 			return ko.utils.unwrapObservable(item.id);
1349 | 		}
1350 | 	});
1351 | 	result.mappedRemove(function(key) {
1352 | 		return key == 2;
1353 | 	});
1354 | 	equal(result().length, 1);
1355 | });
1356 | 
1357 | test('observableArray.mappedRemoveAll should use key callback if available', function() {
1358 | 	var obj = [
1359 | 		{ id : 1 },
1360 | 		{ id : 2 }
1361 | 	]
1362 | 	
1363 | 	var result = ko.mapping.fromJS(obj, {
1364 | 		key: function(item) {
1365 | 			return ko.utils.unwrapObservable(item.id);
1366 | 		}
1367 | 	});
1368 | 	result.mappedRemoveAll([{ id : 2 }]);
1369 | 	equal(result().length, 1);
1370 | });
1371 | 
1372 | test('observableArray.mappedDestroy should use key callback if available', function() {
1373 | 	var obj = [
1374 | 		{ id : 1 },
1375 | 		{ id : 2 }
1376 | 	]
1377 | 	
1378 | 	var result = ko.mapping.fromJS(obj, {
1379 | 		key: function(item) {
1380 | 			return ko.utils.unwrapObservable(item.id);
1381 | 		}
1382 | 	});
1383 | 	result.mappedDestroy({ id : 2 });
1384 | 	equal(result()[0]._destroy, undefined);
1385 | 	equal(result()[1]._destroy, true);
1386 | });
1387 | 
1388 | test('observableArray.mappedDestroy with predicate should use key callback if available', function() {
1389 | 	var obj = [
1390 | 		{ id : 1 },
1391 | 		{ id : 2 }
1392 | 	]
1393 | 	
1394 | 	var result = ko.mapping.fromJS(obj, {
1395 | 		key: function(item) {
1396 | 			return ko.utils.unwrapObservable(item.id);
1397 | 		}
1398 | 	});
1399 | 	result.mappedDestroy(function(key) {
1400 | 		return key == 2;
1401 | 	});
1402 | 	equal(result()[0]._destroy, undefined);
1403 | 	equal(result()[1]._destroy, true);
1404 | });
1405 | 	
1406 | test('observableArray.mappedDestroyAll should use key callback if available', function() {
1407 | 	var obj = [
1408 | 		{ id : 1 },
1409 | 		{ id : 2 }
1410 | 	]
1411 | 	
1412 | 	var result = ko.mapping.fromJS(obj, {
1413 | 		key: function(item) {
1414 | 			return ko.utils.unwrapObservable(item.id);
1415 | 		}
1416 | 	});
1417 | 	result.mappedDestroyAll([{ id : 2 }]);
1418 | 	equal(result()[0]._destroy, undefined);
1419 | 	equal(result()[1]._destroy, true);
1420 | });
1421 | 
1422 | test('observableArray.mappedIndexOf should use key callback if available', function() {
1423 | 	var obj = [
1424 | 		{ id : 1 },
1425 | 		{ id : 2 }
1426 | 	]
1427 | 	
1428 | 	var result = ko.mapping.fromJS(obj, {
1429 | 		key: function(item) {
1430 | 			return ko.utils.unwrapObservable(item.id);
1431 | 		}
1432 | 	});
1433 | 	equal(result.mappedIndexOf({ id : 1 }), 0);
1434 | 	equal(result.mappedIndexOf({ id : 2 }), 1);
1435 | 	equal(result.mappedIndexOf({ id : 3 }), -1);
1436 | });
1437 | 
1438 | test('observableArray.mappedCreate should use key callback if available and not allow duplicates', function() {
1439 | 	var obj = [
1440 | 		{ id : 1 },
1441 | 		{ id : 2 }
1442 | 	]
1443 | 	
1444 | 	var result = ko.mapping.fromJS(obj, {
1445 | 		key: function(item) {
1446 | 			return ko.utils.unwrapObservable(item.id);
1447 | 		}
1448 | 	});		
1449 | 	
1450 | 	var caught = false;
1451 | 	try {
1452 | 		result.mappedCreate({ id : 1 });
1453 | 	}		
1454 | 	catch(e) {
1455 | 		caught = true;
1456 | 	}
1457 | 	
1458 | 	equal(caught, true);
1459 | 	equal(result().length, 2);	
1460 | });
1461 | 
1462 | test('observableArray.mappedCreate should use create callback if available', function() {
1463 | 	var obj = [ 
1464 | 		{ id : 1 },
1465 | 		{ id : 2 }
1466 | 	]
1467 | 	
1468 | 	var childModel = function(data){			
1469 | 		ko.mapping.fromJS(data, {}, this);
1470 | 		this.Hello = ko.observable("hello");
1471 | 	}
1472 | 	
1473 | 	var result = ko.mapping.fromJS(obj, {
1474 | 		key: function(item) {
1475 | 			return ko.utils.unwrapObservable(item.id);
1476 | 		},
1477 | 		create: function(options){
1478 | 			return new childModel(options.data);
1479 | 		}
1480 | 	});
1481 | 			
1482 | 	result.mappedCreate({ id: 3 });
1483 | 	var index = result.mappedIndexOf({ id : 3 });
1484 | 	equal(index, 2);				
1485 | 	equal(result()[index].Hello(), "hello");
1486 | });
1487 | 
1488 | test('observableArray.mappedCreate should use update callback if available', function() {
1489 | 	var obj = [
1490 | 		{ id : 1 },
1491 | 		{ id : 2 }
1492 | 	]
1493 | 
1494 | 	var childModel = function(data){
1495 | 		ko.mapping.fromJS(data, {}, this);
1496 | 	}
1497 | 
1498 | 	var result = ko.mapping.fromJS(obj, {
1499 | 		key: function(item) {
1500 | 			return ko.utils.unwrapObservable(item.id);
1501 | 		},
1502 | 		create: function(options){
1503 | 			return new childModel(options.data);
1504 | 		},
1505 | 		update: function(options){
1506 | 			return {
1507 | 				bla: options.data.id * 10
1508 | 			};
1509 | 		}
1510 | 	});
1511 | 
1512 | 	result.mappedCreate({ id: 3 });
1513 | 	equal(result()[0].bla, 10);
1514 | 	equal(result()[2].bla, 30);
1515 | });
1516 | 
1517 | test('ko.mapping.fromJS should merge options from subsequent calls', function() {
1518 | 	var obj = ['a'];
1519 | 	
1520 | 	var result = ko.mapping.fromJS(obj, { dummyOption1: 1 });
1521 | 	ko.mapping.fromJS({}, { dummyOption2: 2 }, result);
1522 | 	
1523 | 	equal(result.__ko_mapping__.dummyOption1, 1);
1524 | 	equal(result.__ko_mapping__.dummyOption2, 2);
1525 | });
1526 | 
1527 | test('ko.mapping.fromJS should correctly handle falsey values', function () {
1528 | 	var obj = [false, ""];
1529 | 
1530 | 	var result = ko.mapping.fromJS(obj);
1531 | 	
1532 | 	equal(result()[0] === false, true);
1533 | 	equal(result()[1] === "", true);
1534 | });
1535 | 
1536 | test('ko.mapping.fromJS should correctly handle falsey values in keys', function () {
1537 | 	var created = [];
1538 | 	var gotDeletedEvent = false;
1539 | 	
1540 | 	var options = {
1541 | 		key: function(item) { return ko.utils.unwrapObservable(item.id); },
1542 | 		arrayChanged: function(event, item) {
1543 | 			if (event === "deleted") gotDeletedEvent = true;
1544 | 		}
1545 | 	}
1546 | 	
1547 | 	var result = ko.mapping.fromJS([
1548 | 		{ id: 0 }
1549 | 	], options);
1550 | 	
1551 | 	ko.mapping.fromJS([
1552 | 		{ id: 0 },
1553 | 		{ id: 1 }
1554 | 	], {}, result);
1555 | 	
1556 | 	equal(gotDeletedEvent, false);
1557 | });
1558 | 
1559 | test('ko.mapping.fromJS should allow duplicate atomic items in arrays', function () {
1560 | 	var result = ko.mapping.fromJS([
1561 | 		"1", "1", "2"
1562 | 	]);
1563 | 	
1564 | 	equal(result().length, 3);
1565 | 	equal(result()[0], "1");
1566 | 	equal(result()[1], "1");
1567 | 	equal(result()[2], "2");
1568 | 	
1569 | 	ko.mapping.fromJS([
1570 | 		"1", "1", "1", "2"
1571 | 	], {}, result);
1572 | 	
1573 | 	equal(result().length, 4);
1574 | 	equal(result()[0], "1");
1575 | 	equal(result()[1], "1");
1576 | 	equal(result()[2], "1");
1577 | 	equal(result()[3], "2");
1578 | });
1579 | 
1580 | test('when doing ko.mapping.fromJS on an already mapped object, the new options should combine with the old', function() {
1581 | 	var dataA = {
1582 | 		a: "a"
1583 | 	};
1584 | 	var dataB = {
1585 | 		b: "b"
1586 | 	};
1587 | 	
1588 | 	var mapped = {};
1589 | 	ko.mapping.fromJS(dataA, {}, mapped);
1590 | 	ko.mapping.fromJS(dataB, {}, mapped);
1591 | 	equal(mapped.__ko_mapping__.mappedProperties.a, true);
1592 | 	equal(mapped.__ko_mapping__.mappedProperties.b, true);
1593 | });
1594 | 
1595 | test('ko.mapping.fromJS should merge options from subsequent calls', function() {
1596 | 	var obj = ['a'];
1597 | 	
1598 | 	var result = ko.mapping.fromJS(obj, { dummyOption1: 1 });
1599 | 	ko.mapping.fromJS(['b'], { dummyOption2: 2 }, result);
1600 | 	
1601 | 	equal(result.__ko_mapping__.dummyOption1, 1);
1602 | 	equal(result.__ko_mapping__.dummyOption2, 2);
1603 | });
1604 | 
1605 | test('ko.mapping.fromJS should work on unmapped objects', function() {
1606 | 	var obj = ko.observableArray(['a']);
1607 | 	
1608 | 	ko.mapping.fromJS(['b'], {}, obj);
1609 | 	
1610 | 	equal(obj()[0], 'b');
1611 | });
1612 | 
1613 | test('ko.mapping.fromJS should update an array only once', function() {
1614 | 	var obj = {
1615 | 		a: ko.observableArray()
1616 | 	};
1617 | 	
1618 | 	var updateCount = 0;
1619 | 	obj.a.subscribe(function() {
1620 | 		updateCount++;
1621 | 	});
1622 | 	
1623 | 	ko.mapping.fromJS({ a: [1, 2, 3] }, {}, obj);
1624 | 	
1625 | 	equal(updateCount, 1);
1626 | });
1627 | 
1628 | test('ko.mapping.fromJSON should merge options from subsequent calls', function() {
1629 | 	var obj = ['a'];
1630 | 	
1631 | 	var result = ko.mapping.fromJS(obj, { dummyOption1: 1 });
1632 | 	ko.mapping.fromJSON('["b"]', { dummyOption2: 2 }, result);
1633 | 	
1634 | 	equal(result.__ko_mapping__.dummyOption1, 1);
1635 | 	equal(result.__ko_mapping__.dummyOption2, 2);
1636 | });
1637 | 
1638 | test('ko.mapping.fromJS should be able to update observables not created by fromJS', function() {
1639 | 	var existing = {
1640 | 		a: ko.observable(),
1641 | 		d: ko.observableArray()
1642 | 	};
1643 | 	
1644 | 	ko.mapping.fromJS({
1645 | 		a: {
1646 | 			b: "b!"
1647 | 		},
1648 | 		d: [2]
1649 | 	}, {}, existing);
1650 | 	
1651 | 	equal(existing.a().b(), "b!");
1652 | 	equal(existing.d().length, 1);
1653 | 	equal(existing.d()[0], 2);
1654 | });
1655 | 
1656 | test('ko.mapping.fromJS should accept an already mapped object as the second parameter', function() {
1657 | 	var mapped = ko.mapping.fromJS({ a: "a" });
1658 | 	ko.mapping.fromJS({ a: "b" }, mapped);
1659 | 	equal(mapped.a(), "b");
1660 | });
1661 | 
1662 | test('ko.mapping.fromJS should properly map objects that appear in multiple places', function() {
1663 | 	var obj = { title: "Lorem ipsum" }, obj2 = { title: "Lorem ipsum 2" };
1664 | 	var x = [obj,obj2];
1665 | 	var y = { o: obj, x: x };
1666 | 
1667 | 	var z = ko.mapping.fromJS(y);
1668 | 
1669 | 	equal(y.x[0].title, "Lorem ipsum");
1670 | 	equal(z.x()[0].title(), "Lorem ipsum");
1671 | });
1672 | 
1673 | test('ko.mapping.fromJS should properly update arrays containing a NULL key', function() {
1674 | 	var data = [1,2,3,null];
1675 | 	var model=ko.mapping.fromJS(data);
1676 | 	
1677 | 	deepEqual(model(), [1,2,3,null]);
1678 | 
1679 | 	data = [null,1,2,3];
1680 | 	ko.mapping.fromJS(data, {}, model);
1681 | 
1682 | 	deepEqual(model(), [null,1,2,3]);
1683 | });
1684 | 
1685 | test('ko.mapping.visitModel will pass in correct parent names', function() {
1686 | 	var data = { a: { a2: "a2value" } };
1687 | 	var parents = [];
1688 | 	ko.mapping.visitModel(data, function(obj, parent) {
1689 | 		parents.push(parent);
1690 | 	});
1691 | 	equal(parents.length, 3);
1692 | 	equal(parents[0], undefined);
1693 | 	equal(parents[1], "a");
1694 | 	equal(parents[2], "a.a2");
1695 | });
1696 | 
1697 | test('ko.mapping.toJS should merge the default observe', function() {
1698 | 	var data = {
1699 | 		a: "a",
1700 | 		b: "b",
1701 | 		c: "c"
1702 | 	};
1703 | 	
1704 | 	ko.mapping.defaultOptions().observe = ["a"];
1705 | 	var result  = ko.mapping.fromJS(data, { observe: "b" });
1706 | 	equal(ko.isObservable(result.a), true);
1707 | 	equal(ko.isObservable(result.b), true);
1708 | 	equal(ko.isObservable(result.c), false);	
1709 | });
1710 | 
1711 | test('ko.mapping.fromJS should observe specified single property', function() {
1712 | 	var data = {
1713 | 		a: "a",
1714 | 		b: "b"
1715 | 	};
1716 | 	
1717 | 	var result = ko.mapping.fromJS(data, { observe: "a" });
1718 | 	equal(result.a(), "a");
1719 | 	equal(result.b, "b");
1720 | });
1721 | 
1722 | test('ko.mapping.fromJS should observe specified array', function() {
1723 | 	var data = {
1724 | 		a: "a",
1725 | 		b: ["b1", "b2"]
1726 | 	};
1727 | 	
1728 | 	var result = ko.mapping.fromJS(data, { observe: "b" });
1729 | 	equal(result.a, "a");
1730 | 	equal(ko.isObservable(result.b), true);	
1731 | });
1732 | 
1733 | test('ko.mapping.fromJS should observe specified array item', function() {
1734 | 	var data = {
1735 | 		a: "a",
1736 | 		b: [{ b1: "v1" }, { b2: "v2" }] 
1737 | 	};
1738 | 	
1739 | 	var result = ko.mapping.fromJS(data, { observe: "b[0].b1" });
1740 | 	equal(result.a, "a");
1741 | 	equal(result.b[0].b1(), "v1");
1742 | 	equal(result.b[1].b2, "v2");
1743 | });
1744 | 
1745 | test('ko.mapping.fromJS should observe specified array but not the children', function() {
1746 | 	var data = {
1747 | 		a: "a",
1748 | 		b: [{ b1: "v1" }, { b2: "v2" }] 
1749 | 	};
1750 | 	
1751 | 	var result = ko.mapping.fromJS(data, { observe: "b" });
1752 | 	equal(result.a, "a");
1753 | 	equal(result.b()[0].b1, "v1");
1754 | 	equal(result.b()[1].b2, "v2");
1755 | });
1756 | 
1757 | test('ko.mapping.fromJS should observe specified single property, also when going back .toJS', function() {
1758 | 	var data = {
1759 | 		a: "a",
1760 | 		b: "b"
1761 | 	};
1762 | 	
1763 | 	var result = ko.mapping.fromJS(data, { observe: "b" });
1764 | 	var js = ko.mapping.toJS(result);
1765 | 	equal(js.a, "a");
1766 | 	equal(js.b, "b");
1767 | });
1768 | 
1769 | test('ko.mapping.fromJS should copy specified single property, also when going back .toJS, except when overridden', function() {
1770 | 	var data = {
1771 | 		a: "a",
1772 | 		b: "b"
1773 | 	};
1774 | 	
1775 | 	var result = ko.mapping.fromJS(data, { observe: "b" });
1776 | 	var js = ko.mapping.toJS(result, { ignore: "b" });
1777 | 	equal(js.a, "a");
1778 | 	equal(js.b, undefined);
1779 | });
1780 | 
1781 | test('ko.mapping.fromJS with observe option should not fail when map data with sub-object', function() {
1782 | 	var data = {
1783 | 		a: "a",
1784 | 		b: {
1785 | 			c: "c"
1786 | 		}
1787 | 	};
1788 | 	
1789 | 	var result = ko.mapping.fromJS(data, { observe: "a" });
1790 | 	equal(ko.isObservable(result.a), true);	
1791 | 	equal(ko.isObservable(result.b), false);	
1792 | 	equal(ko.isObservable(result.b.c), false);	
1793 | });
1794 | 
1795 | test('ko.mapping.fromJS should observe property in sub-object', function() {
1796 | 	var data = {
1797 | 		a: "a",
1798 | 		b: {
1799 | 			c: "c"
1800 | 		}
1801 | 	};
1802 | 	
1803 | 	var result = ko.mapping.fromJS(data, { observe: "b.c" });
1804 | 	equal(ko.isObservable(result.a), false);	
1805 | 	equal(ko.isObservable(result.b), false);	
1806 | 	equal(ko.isObservable(result.b.c), true);	
1807 | });
1808 | 
1809 | test('ko.mapping.fromJS explicit declared none observable members should not be mapped to an observable', function() {
1810 | 	var data = {
1811 | 		a: "a",
1812 | 		b: "b",
1813 |         c: "c"
1814 | 	};
1815 | 	
1816 |     var ViewModel = function() {
1817 |         this.a = ko.observable();
1818 |         this.b = null;
1819 |     };
1820 | 
1821 | 	var result = ko.mapping.fromJS(data, {}, new ViewModel());
1822 |     equal(ko.isObservable(result.a), true);
1823 |     equal(ko.isObservable(result.b), false);
1824 |     equal(ko.isObservable(result.c), true);
1825 |     equal(result.b, data.b);
1826 | });
1827 | 
1828 | test('ko.mapping.toJS explicit declared none observable members should be mapped toJS correctly', function() {
1829 | 	var data = {
1830 | 		a: "a",
1831 | 	};
1832 | 	
1833 |     var ViewModel = function() {
1834 |         this.a = null;
1835 |     };
1836 | 
1837 | 	var result = ko.mapping.fromJS(data, {}, new ViewModel());
1838 |     var js = ko.mapping.toJS(result);
1839 | 
1840 |     equal(js.b, data.b);
1841 | });
1842 | 
1843 | 


--------------------------------------------------------------------------------
/spec/proxyDependentObservableBehaviors.js:
--------------------------------------------------------------------------------
  1 | (function() {
  2 | var generateProxyTests = function(useComputed) {
  3 | 	var moduleName = useComputed ? 'ProxyComputed' : 'ProxyDependentObservable';
  4 | 	module(moduleName);
  5 | 
  6 | 	var func = function() {
  7 | 		var result;
  8 | 		result = useComputed ? ko.computed.apply(null, arguments) : ko.dependentObservable.apply(null, arguments);
  9 | 		return result;
 10 | 	};
 11 | 
 12 | 	testStart[moduleName] = function() {
 13 | 		test = {
 14 | 			evaluationCount: 0,
 15 | 			writeEvaluationCount: 0
 16 | 		};
 17 | 		test.create = function(createOptions) {
 18 | 			var obj = {
 19 | 				a: "b"
 20 | 			};
 21 | 
 22 | 			var mapping = {
 23 | 				a: {
 24 | 					create: function(options) {
 25 | 						createOptions = createOptions || {};
 26 | 						var mapped = ko.mapping.fromJS(options.data, mapping);
 27 | 						
 28 | 						var DOdata = function() {
 29 | 							test.evaluationCount++;
 30 | 							return "test";
 31 | 						};
 32 | 						if (createOptions.useReadCallback) {
 33 | 							mapped.DO = func({
 34 | 								read: DOdata,
 35 | 								deferEvaluation: !!createOptions.deferEvaluation
 36 | 							}, mapped);
 37 | 						}
 38 | 						else if (createOptions.useWriteCallback) {
 39 | 							mapped.DO = func({
 40 | 								read: DOdata,
 41 | 								write: function(value) { test.written = value; test.writeEvaluationCount++; },
 42 | 								deferEvaluation: !!createOptions.deferEvaluation
 43 | 							}, mapped);
 44 | 						}
 45 | 						else {
 46 | 							mapped.DO = func(DOdata, mapped, {
 47 | 								deferEvaluation: !!createOptions.deferEvaluation
 48 | 							});
 49 | 						}
 50 | 						
 51 | 						return mapped;
 52 | 					}
 53 | 				}
 54 | 			};
 55 | 			
 56 | 			return ko.mapping.fromJS(obj, mapping);
 57 | 		};
 58 | 	};
 59 | 
 60 | 	test('ko.mapping.fromJS should handle interdependent dependent observables in objects', function() {
 61 | 		var obj = {
 62 | 			a: { a1: "a1" },
 63 | 			b: { b1: "b1" }
 64 | 		}
 65 | 		
 66 | 		var dependencyInvocations = [];
 67 | 		
 68 | 		var result = ko.mapping.fromJS(obj, {
 69 | 			a: {
 70 | 				create: function(options) {
 71 | 					return {
 72 | 						a1: ko.observable(options.data.a1),
 73 | 						observeB: func(function() {
 74 | 							dependencyInvocations.push("a");
 75 | 							return options.parent.b.b1();
 76 | 						})
 77 | 					}
 78 | 				}
 79 | 			},
 80 | 			b: {
 81 | 				create: function(options) {
 82 | 					return {
 83 | 						b1: ko.observable(options.data.b1),
 84 | 						observeA: func(function() {
 85 | 							dependencyInvocations.push("b");
 86 | 							return options.parent.a.a1();
 87 | 						})
 88 | 					}
 89 | 				},
 90 | 			}
 91 | 		});
 92 | 		
 93 | 		equal("b1", result.a.observeB());
 94 | 		equal("a1", result.b.observeA());
 95 | 	});
 96 | 
 97 | 	test('ko.mapping.fromJS should handle interdependent dependent observables with read/write callbacks in objects', function() {
 98 | 		var obj = {
 99 | 			a: { a1: "a1" },
100 | 			b: { b1: "b1" }
101 | 		}
102 | 		
103 | 		var dependencyInvocations = [];
104 | 		
105 | 		var result = ko.mapping.fromJS(obj, {
106 | 			a: {
107 | 				create: function(options) {
108 | 					return {
109 | 						a1: ko.observable(options.data.a1),
110 | 						observeB: func({
111 | 							read: function() {
112 | 								dependencyInvocations.push("a");
113 | 								return options.parent.b.b1();
114 | 							},
115 | 							write: function(value) {
116 | 								options.parent.b.b1(value);
117 | 							}
118 | 						})
119 | 					}
120 | 				}
121 | 			},
122 | 			b: {
123 | 				create: function(options) {
124 | 					return {
125 | 						b1: ko.observable(options.data.b1),
126 | 						observeA: func({
127 | 							read: function() {
128 | 								dependencyInvocations.push("b");
129 | 								return options.parent.a.a1();
130 | 							},
131 | 							write: function(value) {
132 | 								options.parent.a.a1(value);
133 | 							}
134 | 						})
135 | 					}
136 | 				},
137 | 			}
138 | 		});
139 | 		
140 | 		equal(result.a.observeB(), "b1");
141 | 		equal(result.b.observeA(), "a1");
142 | 		
143 | 		result.a.observeB("b2");
144 | 		result.b.observeA("a2");
145 | 		equal(result.a.observeB(), "b2");
146 | 		equal(result.b.observeA(), "a2");
147 | 	});
148 | 
149 | 	test('ko.mapping.fromJS should handle dependent observables in arrays', function() {
150 | 		var obj = {
151 | 			items: [
152 | 				{ id: "a" },
153 | 				{ id: "b" }
154 | 			]
155 | 		}
156 | 		
157 | 		var dependencyInvocations = 0;
158 | 		
159 | 		var result = ko.mapping.fromJS(obj, {
160 | 			"items": {
161 | 				create: function(options) {
162 | 					return {
163 | 						id: ko.observable(options.data.id),
164 | 						observeParent: func(function() {
165 | 							dependencyInvocations++;
166 | 							return options.parent.items().length;
167 | 						})
168 | 					}
169 | 				}
170 | 			}
171 | 		});
172 | 		
173 | 		equal(result.items()[0].observeParent(), 2);
174 | 		equal(result.items()[1].observeParent(), 2);
175 | 	});
176 | 
177 | 	test('dependentObservables with a write callback are passed through', function() {
178 | 		var mapped = test.create({ useWriteCallback: true });
179 | 		
180 | 		mapped.a.DO("hello");
181 | 		equal(test.written, "hello");
182 | 		equal(test.writeEvaluationCount, 1);
183 | 	});
184 | 	
185 | 	asyncTest('throttleEvaluation is correctly applied', function() {
186 | 		var obj = {
187 | 			a: "hello"
188 | 		};
189 | 	
190 | 		var dependency = ko.observable(0);
191 | 		var mapped = ko.mapping.fromJS(obj, {
192 | 			a: {
193 | 				create: function() {
194 | 					var f = func(function() {
195 | 						dependency(dependency() + 1);
196 | 						return dependency();
197 | 					});
198 | 					var ex = f.extend({ throttle: 1 });
199 | 					return ex;
200 | 				}
201 | 			}
202 | 		});
203 | 		
204 | 		// Even though the dependency updates many times, it should be throttled to only one update
205 | 		dependency.valueHasMutated();
206 | 		dependency.valueHasMutated();
207 | 		dependency.valueHasMutated();
208 | 		dependency.valueHasMutated();
209 | 		
210 | 		window.setTimeout(function() {
211 | 			start();
212 | 			equal(mapped.a(), 1);
213 | 		}, 1);
214 | 	});
215 | 	
216 | 	test('dependentObservables without a write callback do not get a write callback', function() {
217 | 		var mapped = test.create({ useWriteCallback: false });
218 | 		
219 | 		var caught = false;
220 | 		try {
221 | 			mapped.a.DO("hello");
222 | 		} catch(e) {
223 | 			caught = true;
224 | 		}
225 | 		equal(caught, true);
226 | 	});
227 | 	
228 | 	asyncTest('undeferred dependentObservables that are NOT used immediately SHOULD be auto-evaluated after mapping', function() {
229 | 		var mapped = test.create();
230 | 		window.setTimeout(function() {
231 | 			start();
232 | 			equal(test.evaluationCount, 1);
233 | 		}, 0);
234 | 	});
235 | 
236 | 	asyncTest('undeferred dependentObservables that ARE used immediately should NOT be auto-evaluated after mapping', function() {
237 | 		var mapped = test.create();
238 | 		equal(ko.utils.unwrapObservable(mapped.a.DO), "test");
239 | 		window.setTimeout(function() {
240 | 			start();
241 | 			equal(test.evaluationCount, 1);
242 | 		}, 0);
243 | 	});
244 | 
245 | 	asyncTest('deferred dependentObservables should NOT be auto-evaluated after mapping', function() {
246 | 		var mapped = test.create({ deferEvaluation: true });
247 | 		window.setTimeout(function() {
248 | 			start();
249 | 			equal(test.evaluationCount, 0);
250 | 		}, 0);
251 | 	});
252 | 
253 | 	asyncTest('undeferred dependentObservables with read callback that are NOT used immediately SHOULD be auto-evaluated after mapping', function() {
254 | 		var mapped = test.create({ useReadCallback: true });
255 | 		window.setTimeout(function() {
256 | 			start();
257 | 			equal(test.evaluationCount, 1);
258 | 		}, 0);
259 | 	});
260 | 
261 | 	asyncTest('undeferred dependentObservables with read callback that ARE used immediately should NOT be auto-evaluated after mapping', function() {
262 | 		var mapped = test.create({ useReadCallback: true });
263 | 		equal(ko.utils.unwrapObservable(mapped.a.DO), "test");
264 | 		window.setTimeout(function() {
265 | 			start();
266 | 			equal(test.evaluationCount, 1);
267 | 		}, 0);
268 | 	});
269 | 
270 | 	asyncTest('deferred dependentObservables with read callback should NOT be auto-evaluated after mapping', function() {
271 | 		var mapped = test.create({ deferEvaluation: true, useReadCallback: true });
272 | 		window.setTimeout(function() {
273 | 			start();
274 | 			equal(test.evaluationCount, 0);
275 | 		}, 0);
276 | 	});
277 | 
278 | 	test('can subscribe to proxy dependentObservable', function() {
279 | 		expect(0);
280 | 		var mapped = test.create({ deferEvaluation: true, useReadCallback: true });
281 | 		var subscriptionTriggered = false;
282 | 		mapped.a.DO.subscribe(function() {
283 | 		});
284 | 	});
285 | 
286 | 	test('can subscribe to nested proxy dependentObservable', function() {
287 | 		var obj = {
288 | 			a: { b: null }
289 | 		};
290 | 
291 | 		var DOsubscribedVal ;
292 | 		var mapping = {
293 | 			a: {
294 | 				create: function(options) {
295 | 					var mappedB = ko.mapping.fromJS(options.data, {
296 | 						create: function(options) {
297 | 							//In KO writable computed observables have to be backed by an observable
298 | 							//otherwise they won't be notified they need updating. see: http://jsfiddle.net/drdamour/9Pz4m/ 
299 | 							var DOval = ko.observable(undefined);
300 | 							
301 | 							var m = {};
302 | 							m.myValue = ko.observable("myValue");
303 | 							m.DO = func({
304 | 								read: function() {
305 | 									return DOval();
306 | 								},
307 | 								write: function(val) {
308 | 									DOval(val);
309 | 								}
310 | 							});
311 | 							m.readOnlyDO = func(function() {
312 | 								return m.myValue();
313 | 							});
314 | 							return m;
315 | 						}
316 | 					});
317 | 					mappedB.DO.subscribe(function(val) {
318 | 						DOsubscribedVal = val;
319 | 					});
320 | 					return mappedB;
321 | 				}
322 | 			}
323 | 		};
324 | 		
325 | 		var mapped = ko.mapping.fromJS(obj, mapping);
326 | 		mapped.a.DO("bob");
327 | 		equal(ko.utils.unwrapObservable(mapped.a.readOnlyDO), "myValue");
328 | 		equal(ko.utils.unwrapObservable(mapped.a.DO), "bob");
329 | 		equal(DOsubscribedVal, "bob");
330 | 	});
331 | 	
332 | 
333 | 	test('dependentObservable dependencies trigger subscribers', function() {
334 | 		var obj = {
335 | 			inner: {
336 | 				dependency: 1
337 | 			}
338 | 		};
339 | 		
340 | 		var inner = function(data) {
341 | 			var _this = this;
342 | 			ko.mapping.fromJS(data, {}, _this);
343 | 			
344 | 			_this.DO = func(function() {
345 | 				_this.dependency();
346 | 			});
347 | 
348 | 			_this.evaluationCount = 0;
349 | 			_this.DO.subscribe(function() {
350 | 				_this.evaluationCount++;
351 | 			});
352 | 		};
353 | 		
354 | 		var mapping = {
355 | 			inner: {
356 | 				create: function(options) {
357 | 					return new inner(options.data);
358 | 				}
359 | 			}
360 | 		};
361 | 		
362 | 		var mapped = ko.mapping.fromJS(obj, mapping);
363 | 		var i = mapped.inner;
364 | 		equal(i.evaluationCount, 1); //it's evaluated once prior to fromJS returning
365 | 
366 | 		// change the dependency
367 | 		i.dependency(2);
368 | 			
369 | 		// should also have re-evaluated
370 | 		equal(i.evaluationCount, 2);
371 | 	});
372 | 
373 | 
374 | 	//taken from outline defined at https://github.com/SteveSanderson/knockout.mapping/issues/95#issuecomment-12275070
375 | 	test('dependentObservable evaluation is defferred until mapping takes place', function() {
376 | 		var model = {
377 | 			a: { name: "a" },
378 |   			b: { name: "b" }
379 | 		};
380 | 		
381 | 		var MyClassA = function(data, parent) {
382 | 			var _this = this;
383 | 
384 | 			ko.mapping.fromJS(data, {}, _this);
385 | 
386 | 			_this.DO = func(function() {
387 | 				//Depends on b, which may not be there yet
388 | 				return _this.name() + parent.b.name(); 
389 | 			});
390 | 		};
391 | 
392 | 		var MyClassB = function(data, parent) {
393 | 			var _this = this;
394 | 
395 | 			ko.mapping.fromJS(data, {}, _this);
396 | 
397 | 			_this.DO = func(function() {
398 | 				//depends on a, which may not be there yet
399 | 				return _this.name() + parent.a.name(); 
400 | 			});
401 | 		};
402 | 
403 | 
404 | 		var mapping = {
405 | 			a: {
406 | 				create: function(options) {
407 | 					return new MyClassA(options.data, options.parent);
408 | 				}
409 | 			},
410 | 			b: {
411 | 				create: function(options) {
412 | 					return new MyClassB(options.data, options.parent);
413 | 				}
414 | 			}
415 | 		}
416 | 
417 | 
418 | 		
419 | 		var mappedVM = ko.mapping.fromJS(model, mapping);
420 | 
421 | 
422 | 		equal(mappedVM.a.DO(), "ab");
423 | 		equal(mappedVM.b.DO(), "ba");
424 | 	});
425 | 	
426 | 	test('dependentObservable mappingNesting is reset after exception', function() {
427 | 		var model = {
428 | 			a: { name: "a" }
429 | 		};
430 | 
431 | 		//First we throw a custom exception in the nested create and make sure it does throw
432 | 		function CustomError( message ) {
433 |     		this.message = message;
434 |   		}
435 |   		CustomError.prototype.toString = function() {
436 |     		return this.message;
437 |   		};
438 | 
439 | 		throws( 
440 | 			function()
441 | 			{
442 | 				ko.mapping.fromJS(model, {
443 | 					create:function(){ throw new CustomError("Create Threw");}
444 | 				});
445 | 			},
446 | 			CustomError ,
447 | 			"fromJS throws correct 'CustomError' error type"
448 | 		);
449 | 
450 | 
451 | 		//Second make sure mappingNesting was reset.
452 | 		//if mappingNesting wasn't reset the DO wouldn't have been evaluated before fromJS returning
453 | 		var obj = {
454 | 			inner: {
455 | 				dependency: 1
456 | 			}
457 | 		};
458 | 		
459 | 		var inner = function(data) {
460 | 			var _this = this;
461 | 			ko.mapping.fromJS(data, {}, _this);
462 | 			
463 | 			_this.DO = func(function() {
464 | 				_this.dependency();
465 | 			});
466 | 
467 | 			_this.evaluationCount = 0;
468 | 			_this.DO.subscribe(function() {
469 | 				_this.evaluationCount++;
470 | 			});
471 | 		};
472 | 		
473 | 		var mapping = {
474 | 			inner: {
475 | 				create: function(options) {
476 | 					return new inner(options.data);
477 | 				}
478 | 			}
479 | 		};
480 | 		
481 | 		var mapped = ko.mapping.fromJS(obj, mapping);
482 | 		var i = mapped.inner;
483 | 		equal(i.evaluationCount, 1); //it's evaluated once prior to fromJS returning
484 | 
485 | 	});
486 | 
487 | 	test('dependentObservable evaluation for nested is defferred until after mapping takes place', function() {
488 | 		var model = {
489 | 			a: { 
490 | 				name: "a", 
491 |   				c : {name: "c"} //nested 
492 | 			},
493 |   			b: { 
494 |   				name: "b"
495 |   			}
496 | 		};
497 | 		
498 | 		var MyClassA = function(data, parent) {
499 | 			var _this = this;
500 | 
501 | 			var mapping = {
502 | 				c: {
503 | 					create: function(options) {
504 | 						return new MyClassC(options.data, options.parent, parent); //last param parent here is C's grandparent
505 | 					}
506 | 				}
507 | 			};
508 | 
509 | 			ko.mapping.fromJS(data, mapping, _this);
510 | 
511 | 			_this.DO = func(function() {
512 | 				//Depends on b, which may not be there yet
513 | 				return _this.name() + parent.b.name(); 
514 | 			});
515 | 		};
516 | 
517 | 		var MyClassB = function(data, parent) {
518 | 			var _this = this;
519 | 
520 | 			ko.mapping.fromJS(data, {}, _this);
521 | 
522 | 			_this.DO = func(function() {
523 | 				//depends on a, which may not be there yet
524 | 				return _this.name() + parent.a.name(); 
525 | 			});
526 | 		};
527 | 
528 | 		var MyClassC = function(data, parent, grandparent) {
529 | 			var _this = this;
530 | 
531 | 			ko.mapping.fromJS(data, {}, _this);
532 | 
533 | 			_this.DO = func(function() {
534 | 				//depends on a, which may not be there yet
535 | 				return _this.name() + parent.name() + grandparent.a.name() + grandparent.b.name() ; 
536 | 			});
537 | 		};
538 | 
539 | 
540 | 		var mapping = {
541 | 			a: {
542 | 				create: function(options) {
543 | 					return new MyClassA(options.data, options.parent);
544 | 				}
545 | 			},
546 | 			b: {
547 | 				create: function(options) {
548 | 					return new MyClassB(options.data, options.parent);
549 | 				}
550 | 			},
551 | 			c: {
552 | 				create: function(options) {
553 | 					return new MyClassC(options.data, options.parent);
554 | 				}
555 | 
556 | 			}
557 | 		}
558 | 
559 | 		var mappedVM = ko.mapping.fromJS(model, mapping);
560 | 
561 | 
562 | 		equal(mappedVM.a.DO(), "ab");
563 | 		equal(mappedVM.b.DO(), "ba");
564 | 		equal(mappedVM.a.c.DO(), "caab");
565 | 	});
566 | 
567 | 
568 | 	test('dependentObservable.fn extensions are not missing during mapping', function() {
569 | 		var obj = {
570 | 			x: 1
571 | 		};
572 | 
573 | 		var model = function(data) {
574 | 			var _this = this;
575 | 
576 | 			ko.mapping.fromJS(data, {}, _this);
577 | 			
578 | 			_this.DO = func(_this.x);
579 | 		};
580 | 
581 | 		var mapping = {
582 | 			create: function(options) {
583 | 				return new model(options.data);
584 | 			}
585 | 		};
586 | 		
587 | 		ko.dependentObservable.fn.myExtension = true;
588 | 		
589 | 		var mapped = ko.mapping.fromJS(obj, mapping);
590 | 		
591 | 		equal(mapped.DO.myExtension, true)
592 | 	});
593 | 	
594 | 	test('Dont wrap dependent observables if already marked as deferEvaluation', function() {
595 | 		var obj = {
596 | 			x: 1
597 | 		};
598 | 
599 | 		var model = function(data) {
600 | 			var _this = this;
601 | 
602 | 			ko.mapping.fromJS(data, {}, _this);
603 | 			
604 | 			_this.DO1 = func(_this.x, null, {deferEvaluation: true});
605 | 			_this.DO2 = func({read: _this.x, deferEvaluation: true});
606 | 			_this.DO3 = func(_this.x);
607 | 		};
608 | 
609 | 		var mapping = {
610 | 			create: function(options) {
611 | 				return new model(options.data);
612 | 			}
613 | 		};
614 | 		
615 | 		var mapped = ko.mapping.fromJS(obj, mapping);
616 | 		
617 | 		equal(mapped.DO1._wrapper, undefined);
618 | 		equal(mapped.DO2._wrapper, undefined);
619 | 		equal(mapped.DO3._wrapper, true);
620 | 	});
621 | 	
622 | 	test('ko.mapping.updateViewModel should allow for the avoidance of adding an item to its parent observableArray', function() {
623 | 		var obj = {
624 | 			items: [
625 | 				{ id: "a" },
626 | 				{ id: "b" }
627 | 			]
628 | 		}
629 | 		
630 | 		var dependencyInvocations = 0;
631 | 		
632 | 		var result = ko.mapping.fromJS(obj, {
633 | 			"items": {
634 | 				create: function(options) {
635 | 					if (options.data.id == "b")
636 | 						return options.data;
637 | 					else 
638 | 						return options.skip;
639 | 				}
640 | 			}
641 | 		});
642 | 		
643 | 		
644 | 		equal(result.items().length, 1);
645 | 		equal(result.items()[0].id, "b");
646 | 		
647 | 	});
648 | 
649 | 	//unit test for updating existing arrays (e.g. first item is retained, second item is skipped and the third item gets added)?
650 | 	test('ko.mapping.updateViewModel skipping an item should retain all other items', function() {
651 | 		var obj = {
652 | 			items: [
653 | 				{ id: "a" },
654 | 				{ id: "b" },
655 | 				{ id: "c" }
656 | 			]
657 | 		}
658 | 		
659 | 		var dependencyInvocations = 0;
660 | 		
661 | 		var result = ko.mapping.fromJS(obj, {
662 | 			"items": {
663 | 				create: function(options) {
664 | 					if (options.data.id == "b")
665 | 						return options.skip;
666 | 					else 
667 | 						return options.data;
668 | 				}
669 | 			}
670 | 		});
671 | 		
672 | 		
673 | 		equal(result.items().length, 2);
674 | 		equal(result.items()[0].id, "a");
675 | 		equal(result.items()[1].id, "c");
676 | 		
677 | 	});
678 | };
679 | 
680 | generateProxyTests(false);
681 | generateProxyTests(true);
682 | })();
683 | 


--------------------------------------------------------------------------------
/spec/runner.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html>
 3 | <head>
 4 | 	<meta charset="UTF-8" />
 5 | 	<title>QUnit Test Suite</title>
 6 | 	<link rel="stylesheet" href="lib/qunit-1.10.0.css" type="text/css" media="screen">
 7 | 	<script type="text/javascript" src="lib/qunit-1.10.0.js"></script>
 8 | 	<script type="text/javascript" src="lib/json2.js"></script>
 9 | 	<script type="text/javascript" src="http://knockoutjs.com/downloads/knockout-2.2.0.js"></script>
10 | 	<script type="text/javascript" src="../knockout.mapping.js"></script>
11 | 	<script type="text/javascript">
12 | 		var curModuleName;
13 | 		
14 | 		QUnit.moduleStart = function(module) {
15 | 			curModuleName = module.name;
16 | 		};
17 | 	
18 | 		QUnit.moduleDone = function() {
19 | 			curModuleName = "";
20 | 		};
21 | 	
22 | 		var testStart = [];
23 | 		QUnit.testStart = function() {
24 | 			ko.mapping.resetDefaultOptions();
25 | 			testStart[curModuleName] && testStart[curModuleName]();
26 | 		};
27 | 		
28 | 		var testDone = [];
29 | 		QUnit.testDone = function(module) {
30 | 			testDone[curModuleName] && testDone[curModuleName]();
31 | 		};
32 | 		</script>
33 |     <script type="text/javascript" src="mappingBehaviors.js"></script>
34 |     <script type="text/javascript" src="proxyDependentObservableBehaviors.js"></script>
35 |     <script type="text/javascript" src="issues.js"></script>
36 | </head>
37 | <body>
38 | 	<h1 id="qunit-header">QUnit Test Suite</h1>
39 | 	<h2 id="qunit-banner"></h2>
40 | 	<div id="qunit-testrunner-toolbar"></div>
41 | 	<h2 id="qunit-userAgent"></h2>
42 | 	<ol id="qunit-tests"></ol>
43 | 	<div id="qunit-fixture">test markup</div>
44 | </body>
45 | </html>
46 | 


--------------------------------------------------------------------------------