winjs
Version:
WinJS is a set of JavaScript toolkits that allow developers to build applications using HTML/JS/CSS technology.
195 lines (175 loc) • 8.67 kB
JavaScript
// Copyright (c) Microsoft Corporation. All Rights Reserved. Licensed under the MIT License. See License.txt in the project root for license information.
/* global intellisense, window, document, setTimeout, WinJS */
(function () {
"use strict";
var redirect = intellisense.redirectDefinition;
function makeAllEnumerable(v) {
/// <param name="v" type="Object" />
if (v && typeof v === "object") {
Object.getOwnPropertyNames(v).forEach(function (name) {
var pd = Object.getOwnPropertyDescriptor(v, name);
if (!pd.enumerable && pd.configurable) {
pd.enumerable = true;
Object.defineProperty(v, name, pd);
}
});
}
return v;
}
function wrap(old) {
/// <param name="old" type="Function" />
var wrapper = function () {
var args = [];
for (var i = 0, len = arguments.length; i < len; i++) {
args.push(makeAllEnumerable(arguments[i]));
}
return old.apply(this, args);
};
redirect(wrapper, old);
return wrapper;
}
function wrapAllMethods(v) {
/// <param name="v" type="Object" />
if (v) {
Object.getOwnPropertyNames(v).forEach(function (name) {
var value = v[name];
if (typeof value === "function") {
v[name] = wrap(value);
}
});
}
return v;
}
if (this.WinJS) {
wrapAllMethods(WinJS.Namespace);
wrapAllMethods(WinJS.Class);
}
(function () {
var originalApplicationStart = WinJS.Application.start;
WinJS.Application.start = function () {
// Call app.stop() when execution completes to ensure that the subsequent calls to app.start() do not see the app as running.
var app = this;
setTimeout(function () {
app.stop();
}, 0);
return originalApplicationStart.apply(this, arguments);
};
redirect(WinJS.Application.start, originalApplicationStart);
var originalPagesDefine = WinJS.UI.Pages.define;
WinJS.UI.Pages.define = function (uri, members) {
var result = originalPagesDefine.apply(this, arguments);
intellisense.callerDefines(result, members);
if (typeof uri === 'string') {
intellisense.declareNavigationContainer(result, "Page (" + uri + ")");
}
// Set the call contexts for IPageControlMembers
if (members) {
var pageInstance = new result();
if (typeof members.error === 'function') {
intellisense.setCallContext(members.error, { thisArg: pageInstance, args: [new Error()] });
}
if (typeof members.init === 'function') {
intellisense.setCallContext(members.init, { thisArg: pageInstance, args: [document.createElement('element'), {}] });
}
if (typeof members.load === 'function') {
intellisense.setCallContext(members.load, { thisArg: pageInstance, args: [""] });
}
if (typeof members.processed === 'function') {
intellisense.setCallContext(members.processed, { thisArg: pageInstance, args: [document.createElement('element'), {}] });
}
if (typeof members.ready === 'function') {
intellisense.setCallContext(members.ready, { thisArg: pageInstance, args: [document.createElement('element'), {}] });
}
if (typeof members.render === 'function') {
intellisense.setCallContext(members.render, { thisArg: pageInstance, args: [document.createElement('element'), {}, WinJS.Promise.wrap()] });
}
}
return result;
};
redirect(WinJS.UI.Pages.define, originalPagesDefine);
// Simulate a call to a class' instance/static methods for WinJS.Class.define
var originalClassDefine = WinJS.Class.define;
WinJS.Class.define = function (constructor, instanceMembers, staticMembers) {
var result = originalClassDefine.call(this, constructor, instanceMembers, staticMembers);
// Go through the instance members to find methods
if (instanceMembers) {
var classInstance;
Object.getOwnPropertyNames(instanceMembers).forEach(function (name) {
var member = instanceMembers[name];
if (typeof member === 'function') {
intellisense.setCallContext(member, {
get thisArg() {
if (!classInstance) {
classInstance = new result();
}
return classInstance;
}
});
}
});
}
// Go through the static members to find methods
if (staticMembers) {
Object.getOwnPropertyNames(staticMembers).forEach(function (name) {
var member = staticMembers[name];
if (typeof member === 'function') {
intellisense.setCallContext(member, { thisArg: result });
}
});
}
return result;
};
redirect(WinJS.Class.define, originalClassDefine);
// Define the caller location property for WinJS.Namespace.define
var originalNamespaceDefine = WinJS.Namespace.define;
WinJS.Namespace.define = function (name, members) {
var result = originalNamespaceDefine.call(this, name, members);
if (typeof name === 'string' && result) {
// Get the global object
var globalObj = (function () {
return this;
})();
// Define the caller location of parent namespaces that haven't yet been defined
var path;
var namespaceParts = name.split(".");
for (var i = 0; i < namespaceParts.length - 1; i++) {
path = ((i === 0) ? namespaceParts[i] : path += "." + namespaceParts[i]);
var item = globalObj[path];
if (item) {
intellisense.callerDefines(item);
}
}
// Define the caller location of the original namespace
intellisense.callerDefines(result, members);
}
return result;
};
redirect(WinJS.Namespace.define, originalNamespaceDefine);
intellisense.setCallContext(WinJS.Promise, { thisArg: {}, args: [function () { }] });
})();
(function () {
// In the language serivce all promises are completed promises. The completed promise class is private
// to WinJS, however, we can get access to the prototype through one of the promise instances by
// getting the instance's constructor's prototype.
var promisePrototype = WinJS.Promise.as(1).constructor.prototype;
// Setting the argument calling context of the done and then methods to be an instance of Error().
// The completion callback is handled in WinJS itself through a <returns> metadata comment.
var originalDone = promisePrototype.done;
promisePrototype.done = function (c, e, p) {
intellisense.setCallContext(e, { thisArg: this, args: [new Error()] });
return originalDone.apply(this, arguments);
};
redirect(promisePrototype.done, originalDone);
var originalThen = promisePrototype.then;
promisePrototype.then = function (c, e, p) {
intellisense.setCallContext(e, { thisArg: this, args: [new Error()] });
return originalThen.apply(this, arguments);
};
redirect(promisePrototype.then, originalThen);
})();
if (window._$originalAddEventListener) {
window.addEventListener = window._$originalAddEventListener;
window._$originalAddEventListener = null;
delete window._$originalAddEventListener;
}
})();