52bd90c27c
!L may result in a undefined error when running tests that also touch including a leaflet plugin.
127 lines
3.2 KiB
JavaScript
127 lines
3.2 KiB
JavaScript
import * as Util from './Util';
|
|
|
|
// @class Class
|
|
// @aka L.Class
|
|
|
|
// @section
|
|
// @uninheritable
|
|
|
|
// Thanks to John Resig and Dean Edwards for inspiration!
|
|
|
|
export function Class() {}
|
|
|
|
Class.extend = function (props) {
|
|
|
|
// @function extend(props: Object): Function
|
|
// [Extends the current class](#class-inheritance) given the properties to be included.
|
|
// Returns a Javascript function that is a class constructor (to be called with `new`).
|
|
var NewClass = function () {
|
|
|
|
// call the constructor
|
|
if (this.initialize) {
|
|
this.initialize.apply(this, arguments);
|
|
}
|
|
|
|
// call all constructor hooks
|
|
this.callInitHooks();
|
|
};
|
|
|
|
var parentProto = NewClass.__super__ = this.prototype;
|
|
|
|
var proto = Util.create(parentProto);
|
|
proto.constructor = NewClass;
|
|
|
|
NewClass.prototype = proto;
|
|
|
|
// inherit parent's statics
|
|
for (var i in this) {
|
|
if (this.hasOwnProperty(i) && i !== 'prototype' && i !== '__super__') {
|
|
NewClass[i] = this[i];
|
|
}
|
|
}
|
|
|
|
// mix static properties into the class
|
|
if (props.statics) {
|
|
Util.extend(NewClass, props.statics);
|
|
delete props.statics;
|
|
}
|
|
|
|
// mix includes into the prototype
|
|
if (props.includes) {
|
|
checkDeprecatedMixinEvents(props.includes);
|
|
Util.extend.apply(null, [proto].concat(props.includes));
|
|
delete props.includes;
|
|
}
|
|
|
|
// merge options
|
|
if (proto.options) {
|
|
props.options = Util.extend(Util.create(proto.options), props.options);
|
|
}
|
|
|
|
// mix given properties into the prototype
|
|
Util.extend(proto, props);
|
|
|
|
proto._initHooks = [];
|
|
|
|
// add method for calling all hooks
|
|
proto.callInitHooks = function () {
|
|
|
|
if (this._initHooksCalled) { return; }
|
|
|
|
if (parentProto.callInitHooks) {
|
|
parentProto.callInitHooks.call(this);
|
|
}
|
|
|
|
this._initHooksCalled = true;
|
|
|
|
for (var i = 0, len = proto._initHooks.length; i < len; i++) {
|
|
proto._initHooks[i].call(this);
|
|
}
|
|
};
|
|
|
|
return NewClass;
|
|
};
|
|
|
|
|
|
// @function include(properties: Object): this
|
|
// [Includes a mixin](#class-includes) into the current class.
|
|
Class.include = function (props) {
|
|
Util.extend(this.prototype, props);
|
|
return this;
|
|
};
|
|
|
|
// @function mergeOptions(options: Object): this
|
|
// [Merges `options`](#class-options) into the defaults of the class.
|
|
Class.mergeOptions = function (options) {
|
|
Util.extend(this.prototype.options, options);
|
|
return this;
|
|
};
|
|
|
|
// @function addInitHook(fn: Function): this
|
|
// Adds a [constructor hook](#class-constructor-hooks) to the class.
|
|
Class.addInitHook = function (fn) { // (Function) || (String, args...)
|
|
var args = Array.prototype.slice.call(arguments, 1);
|
|
|
|
var init = typeof fn === 'function' ? fn : function () {
|
|
this[fn].apply(this, args);
|
|
};
|
|
|
|
this.prototype._initHooks = this.prototype._initHooks || [];
|
|
this.prototype._initHooks.push(init);
|
|
return this;
|
|
};
|
|
|
|
function checkDeprecatedMixinEvents(includes) {
|
|
if (typeof L === 'undefined' || !L || !L.Mixin) { return; }
|
|
|
|
includes = Util.isArray(includes) ? includes : [includes];
|
|
|
|
for (var i = 0; i < includes.length; i++) {
|
|
if (includes[i] === L.Mixin.Events) {
|
|
console.warn('Deprecated include of L.Mixin.Events: ' +
|
|
'this property will be removed in future releases, ' +
|
|
'please inherit from L.Evented instead.', new Error().stack);
|
|
}
|
|
}
|
|
}
|