Files
cocos4/cocos/core/data/class.js
T
2019-01-25 18:46:37 +08:00

1244 lines
40 KiB
JavaScript

/****************************************************************************
Copyright (c) 2013-2016 Chukong Technologies Inc.
Copyright (c) 2017-2018 Xiamen Yaji Software Co., Ltd.
http://www.cocos.com
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated engine source code (the "Software"), a limited,
worldwide, royalty-free, non-assignable, revocable and non-exclusive license
to use Cocos Creator solely to develop games on your target platforms. You shall
not use Cocos Creator software for developing other software or tools that's
used for developing games. You are not granted to publish, distribute,
sublicense, and/or sell copies of Cocos Creator.
The software or tools in this License Agreement are licensed, not sold.
Xiamen Yaji Software Co., Ltd. reserves all rights not expressly granted to you.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
****************************************************************************/
import * as js from '../utils/js';
import {isPlainEmptyObj_DEV, cloneable_DEV} from '../utils/misc';
import Enum from '../value-types/enum';
import {preprocessAttrs, validateMethodWithProps} from './utils/preprocess-class';
import * as Attr from './utils/attribute';
import * as RF from './utils/requiring-frame';
const DELIMETER = Attr.DELIMETER;
var getTypeChecker = Attr.getTypeChecker;
const BUILTIN_ENTRIES = ['name', 'extends', 'mixins', 'ctor', '__ctor__', 'properties', 'statics', 'editor', '__ES6__'];
const INVALID_STATICS_DEV = CC_DEV && ['name', '__ctors__', '__props__', 'arguments', 'call', 'apply', 'caller',
'length', 'prototype'];
function pushUnique (array, item) {
if (array.indexOf(item) < 0) {
array.push(item);
}
}
var deferredInitializer = {
// Configs for classes which needs deferred initialization
datas: null,
// register new class
// data - {cls: cls, cb: properties, mixins: options.mixins}
push: function (data) {
if (this.datas) {
this.datas.push(data);
}
else {
this.datas = [data];
// start a new timer to initialize
var self = this;
setTimeout(function () {
self.init();
}, 0);
}
},
init: function () {
var datas = this.datas;
if (datas) {
for (var i = 0; i < datas.length; ++i) {
var data = datas[i];
var cls = data.cls;
var properties = data.props;
if (typeof properties === 'function') {
properties = properties();
}
var name = js.getClassName(cls);
if (properties) {
declareProperties(cls, name, properties, cls.$super, data.mixins);
}
else {
cc.errorID(3633, name);
}
}
this.datas = null;
}
}
};
// both getter and prop must register the name into __props__ array
function appendProp (cls, name) {
if (CC_DEV) {
//if (!IDENTIFIER_RE.test(name)) {
// cc.error('The property name "' + name + '" is not compliant with JavaScript naming standards');
// return;
//}
if (name.indexOf('.') !== -1) {
cc.errorID(3634);
return;
}
}
pushUnique(cls.__props__, name);
}
var tmpArray = [];
function defineProp (cls, className, propName, val, es6) {
var defaultValue = val.default;
if (CC_DEV) {
if (!es6) {
// check default object value
if (typeof defaultValue === 'object' && defaultValue) {
if (Array.isArray(defaultValue)) {
// check array empty
if (defaultValue.length > 0) {
cc.errorID(3635, className, propName, propName);
return;
}
}
else if (!isPlainEmptyObj_DEV(defaultValue)) {
// check cloneable
if (!cloneable_DEV(defaultValue)) {
cc.errorID(3636, className, propName, propName);
return;
}
}
}
}
// check base prototype to avoid name collision
if (CCClass.getInheritanceChain(cls)
.some(function (x) { return x.prototype.hasOwnProperty(propName); }))
{
cc.errorID(3637, className, propName, className);
return;
}
}
// set default value
Attr.setClassAttr(cls, propName, 'default', defaultValue);
appendProp(cls, propName);
// apply attributes
var attrs = parseAttributes(cls, val, className, propName, false);
if (attrs) {
var onAfterProp = tmpArray;
for (var i = 0; i < attrs.length; i++) {
var attr = attrs[i];
Attr.attr(cls, propName, attr);
if (attr['serializable'] === false) {
pushUnique(cls.__values__, propName);
}
// register callback
if (attr._onAfterProp) {
onAfterProp.push(attr._onAfterProp);
}
}
// call callback
for (var c = 0; c < onAfterProp.length; c++) {
onAfterProp[c](cls, propName);
}
tmpArray.length = 0;
attrs.length = 0;
}
}
function defineGetSet (cls, name, propName, val, es6) {
var getter = val.get;
var setter = val.set;
var proto = cls.prototype;
var d = Object.getOwnPropertyDescriptor(proto, propName);
var setterUndefined = !d;
if (getter) {
if (CC_DEV && !es6 && d && d.get) {
cc.errorID(3638, name, propName);
return;
}
var attrs = parseAttributes(cls, val, name, propName, true);
for (var i = 0; i < attrs.length; i++) {
Attr.attr(cls, propName, attrs[i]);
}
attrs.length = 0;
Attr.setClassAttr(cls, propName, 'serializable', false);
if (CC_DEV) {
// 不论是否 visible 都要添加到 props,否则 asset watcher 不能正常工作
appendProp(cls, propName);
}
if (!es6) {
js.get(proto, propName, getter, setterUndefined, setterUndefined);
}
if (CC_EDITOR || CC_DEV) {
Attr.setClassAttr(cls, propName, 'hasGetter', true); // 方便 editor 做判断
}
}
if (setter) {
if (!es6) {
if (CC_DEV && d && d.set) {
return cc.errorID(3640, name, propName);
}
js.set(proto, propName, setter, setterUndefined, setterUndefined);
}
if (CC_EDITOR || CC_DEV) {
Attr.setClassAttr(cls, propName, 'hasSetter', true); // 方便 editor 做判断
}
}
}
function getDefault (defaultVal) {
if (typeof defaultVal === 'function') {
if (CC_EDITOR) {
try {
return defaultVal();
}
catch (e) {
cc._throw(e);
return undefined;
}
}
else {
return defaultVal();
}
}
return defaultVal;
}
function mixinWithInherited (dest, src, filter) {
for (var prop in src) {
if (!dest.hasOwnProperty(prop) && (!filter || filter(prop))) {
Object.defineProperty(dest, prop, js.getPropertyDescriptor(src, prop));
}
}
}
function doDefine (className, baseClass, mixins, options) {
var shouldAddProtoCtor;
var __ctor__ = options.__ctor__;
var ctor = options.ctor;
var __es6__ = options.__ES6__;
if (CC_DEV) {
// check ctor
var ctorToUse = __ctor__ || ctor;
if (ctorToUse) {
if (CCClass._isCCClass(ctorToUse)) {
cc.errorID(3618, className);
}
else if (typeof ctorToUse !== 'function') {
cc.errorID(3619, className);
}
else {
if (baseClass && /\bprototype.ctor\b/.test(ctorToUse)) {
if (__es6__) {
cc.errorID(3651, className || "");
}
else {
cc.warnID(3600, className || "");
shouldAddProtoCtor = true;
}
}
}
if (ctor) {
if (__ctor__) {
cc.errorID(3649, className);
}
else {
ctor = options.ctor = _validateCtor_DEV(ctor, baseClass, className, options);
}
}
}
}
var ctors;
var fireClass;
if (__es6__) {
ctors = [ctor];
fireClass = ctor;
}
else {
ctors = __ctor__ ? [__ctor__] : _getAllCtors(baseClass, mixins, options);
fireClass = _createCtor(ctors, baseClass, className, options);
// extend - Create a new Class that inherits from this Class
js.value(fireClass, 'extend', function (options) {
options.extends = this;
return CCClass(options);
}, true);
}
js.value(fireClass, '__ctors__', ctors.length > 0 ? ctors : null, true);
var prototype = fireClass.prototype;
if (baseClass) {
if (!__es6__) {
js.extend(fireClass, baseClass); // 这里会把父类的 __props__ 复制给子类
prototype = fireClass.prototype; // get extended prototype
}
fireClass.$super = baseClass;
if (CC_DEV && shouldAddProtoCtor) {
prototype.ctor = function () {};
}
}
if (mixins) {
for (var m = mixins.length - 1; m >= 0; m--) {
var mixin = mixins[m];
mixinWithInherited(prototype, mixin.prototype);
// mixin statics (this will also copy editor attributes for component)
mixinWithInherited(fireClass, mixin, function (prop) {
return mixin.hasOwnProperty(prop) && (!CC_DEV || INVALID_STATICS_DEV.indexOf(prop) < 0);
});
// mixin attributes
if (CCClass._isCCClass(mixin)) {
mixinWithInherited(
Attr.getClassAttrs(fireClass).constructor.prototype,
Attr.getClassAttrs(mixin).constructor.prototype
);
}
}
// restore constuctor overridden by mixin
prototype.constructor = fireClass;
}
if (!__es6__) {
prototype.__initProps__ = compileProps;
}
js.setClassName(className, fireClass);
return fireClass;
}
function define (className, baseClass, mixins, options) {
var Component = cc.Component;
var frame = RF.peek();
if (frame && js.isChildClassOf(baseClass, Component)) {
// project component
if (js.isChildClassOf(frame.cls, Component)) {
cc.errorID(3615);
return null;
}
if (CC_DEV && frame.uuid && className) {
cc.warnID(3616, className);
}
className = className || frame.script;
}
var cls = doDefine(className, baseClass, mixins, options);
if (frame) {
if (js.isChildClassOf(baseClass, Component)) {
var uuid = frame.uuid;
if (uuid) {
js._setClassId(uuid, cls);
if (CC_EDITOR) {
Component._addMenuItem(cls, "i18n:menu.custom_script/" + className, -1);
cls.prototype.__scriptUuid = Editor.Utils.UuidUtils.decompressUuid(uuid);
}
}
frame.cls = cls;
}
else if (!js.isChildClassOf(frame.cls, Component)) {
frame.cls = cls;
}
}
return cls;
}
function normalizeClassName_DEV (className) {
var DefaultName = 'CCClass';
if (className) {
className = className.replace(/^[^$A-Za-z_]/, '_').replace(/[^0-9A-Za-z_$]/g, '_');
try {
// validate name
Function('function ' + className + '(){}')();
return className;
}
catch (e) {
;
}
}
return DefaultName;
}
function getNewValueTypeCodeJit (value) {
var clsName = js.getClassName(value);
var type = value.constructor;
var res = 'new ' + clsName + '(';
for (var i = 0; i < type.__props__.length; i++) {
var prop = type.__props__[i];
var propVal = value[prop];
if (CC_DEV && typeof propVal === 'object') {
cc.errorID(3641, clsName);
return 'new ' + clsName + '()';
}
res += propVal;
if (i < type.__props__.length - 1) {
res += ',';
}
}
return res + ')';
}
// TODO - move escapeForJS, IDENTIFIER_RE, getNewValueTypeCodeJit to misc.js or a new source file
// convert a normal string including newlines, quotes and unicode characters into a string literal
// ready to use in JavaScript source
function escapeForJS (s) {
return JSON.stringify(s).
// see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify
replace(/\u2028/g, '\\u2028').
replace(/\u2029/g, '\\u2029');
}
function getInitPropsJit (attrs, propList) {
// functions for generated code
var F = [];
var func = '';
for (var i = 0; i < propList.length; i++) {
var prop = propList[i];
var attrKey = prop + DELIMETER + 'default';
if (attrKey in attrs) { // getter does not have default
var statement;
if (IDENTIFIER_RE.test(prop)) {
statement = 'this.' + prop + '=';
}
else {
statement = 'this[' + escapeForJS(prop) + ']=';
}
var expression;
var def = attrs[attrKey];
if (typeof def === 'object' && def) {
if (def instanceof cc.ValueType) {
expression = getNewValueTypeCodeJit(def);
}
else if (Array.isArray(def)) {
expression = '[]';
}
else {
expression = '{}';
}
}
else if (typeof def === 'function') {
var index = F.length;
F.push(def);
expression = 'F[' + index + ']()';
if (CC_EDITOR) {
func += 'try {\n' + statement + expression + ';\n}\ncatch(e) {\ncc._throw(e);\n' + statement + 'undefined;\n}\n';
continue;
}
}
else if (typeof def === 'string') {
expression = escapeForJS(def);
}
else {
// number, boolean, null, undefined
expression = def;
}
statement = statement + expression + ';\n';
func += statement;
}
}
// if (CC_TEST && !isPhantomJS) {
// console.log(func);
// }
var initProps;
if (F.length === 0) {
initProps = Function(func);
}
else {
initProps = Function('F', 'return (function(){\n' + func + '})')(F);
}
return initProps;
}
function getInitProps (attrs, propList) {
var advancedProps = [];
var advancedValues = [];
var simpleProps = [];
var simpleValues = [];
for (var i = 0; i < propList.length; ++i) {
var prop = propList[i];
var attrKey = prop + DELIMETER + 'default';
if (attrKey in attrs) { // getter does not have default
var def = attrs[attrKey];
if ((typeof def === 'object' && def) || typeof def === 'function') {
advancedProps.push(prop);
advancedValues.push(def);
}
else {
// number, boolean, null, undefined, string
simpleProps.push(prop);
simpleValues.push(def);
}
}
}
return function () {
for (let i = 0; i < simpleProps.length; ++i) {
this[simpleProps[i]] = simpleValues[i];
}
for (let i = 0; i < advancedProps.length; i++) {
let prop = advancedProps[i];
var expression;
var def = advancedValues[i];
if (typeof def === 'object') {
if (def instanceof cc.ValueType) {
expression = def.clone();
}
else if (Array.isArray(def)) {
expression = [];
}
else {
expression = {};
}
}
else {
// def is function
if (CC_EDITOR) {
try {
expression = def();
}
catch (err) {
cc._throw(e);
continue;
}
}
else {
expression = def();
}
}
this[prop] = expression;
}
};
}
// simple test variable name
const IDENTIFIER_RE = /^[A-Za-z_$][0-9A-Za-z_$]*$/;
function compileProps (actualClass) {
// init deferred properties
var attrs = Attr.getClassAttrs(actualClass);
var propList = actualClass.__props__;
if (propList === null) {
deferredInitializer.init();
propList = actualClass.__props__;
}
// Overwite __initProps__ to avoid compile again.
var initProps = CC_SUPPORT_JIT ? getInitPropsJit(attrs, propList) : getInitProps(attrs, propList);
actualClass.prototype.__initProps__ = initProps;
// call instantiateProps immediately, no need to pass actualClass into it anymore
// (use call to manually bind `this` because `this` may not instanceof actualClass)
initProps.call(this);
}
var _createCtor = CC_SUPPORT_JIT ? function (ctors, baseClass, className, options) {
var superCallBounded = baseClass && boundSuperCalls(baseClass, options, className);
var ctorName = CC_DEV ? normalizeClassName_DEV(className) : 'CCClass';
var body = 'return function ' + ctorName + '(){\n';
if (superCallBounded) {
body += 'this._super=null;\n';
}
// instantiate props
body += 'this.__initProps__(' + ctorName + ');\n';
// call user constructors
var ctorLen = ctors.length;
if (ctorLen > 0) {
var useTryCatch = CC_DEV && ! (className && className.startsWith('cc.'));
if (useTryCatch) {
body += 'try{\n';
}
var SNIPPET = '].apply(this,arguments);\n';
if (ctorLen === 1) {
body += ctorName + '.__ctors__[0' + SNIPPET;
}
else {
body += 'var cs=' + ctorName + '.__ctors__;\n';
for (var i = 0; i < ctorLen; i++) {
body += 'cs[' + i + SNIPPET;
}
}
if (useTryCatch) {
body += '}catch(e){\n' +
'cc._throw(e);\n' +
'}\n';
}
}
body += '}';
return Function(body)();
} : function (ctors, baseClass, className, options) {
var superCallBounded = baseClass && boundSuperCalls(baseClass, options, className);
var ctorLen = ctors.length;
var Class;
if (ctorLen > 0) {
if (superCallBounded) {
if (ctorLen === 2) {
// User Component
Class = function () {
this._super = null;
this.__initProps__(Class);
ctors[0].apply(this, arguments);
ctors[1].apply(this, arguments);
};
}
else {
Class = function () {
this._super = null;
this.__initProps__(Class);
for (let i = 0; i < ctors.length; ++i) {
ctors[i].apply(this, arguments);
}
};
}
}
else {
if (ctorLen === 3) {
// Node
Class = function () {
this.__initProps__(Class);
ctors[0].apply(this, arguments);
ctors[1].apply(this, arguments);
ctors[2].apply(this, arguments);
};
}
else {
Class = function () {
this.__initProps__(Class);
var ctors = Class.__ctors__;
for (let i = 0; i < ctors.length; ++i) {
ctors[i].apply(this, arguments);
}
};
}
}
}
else {
Class = function () {
if (superCallBounded) {
this._super = null;
}
this.__initProps__(Class);
};
}
return Class;
};
function _validateCtor_DEV (ctor, baseClass, className, options) {
if (CC_EDITOR && baseClass) {
// check super call in constructor
var originCtor = ctor;
if (SuperCallReg.test(ctor)) {
if (options.__ES6__) {
cc.errorID(3651, className);
}
else {
cc.warnID(3600, className);
// suppresss super call
ctor = function () {
this._super = function () {};
var ret = originCtor.apply(this, arguments);
this._super = null;
return ret;
};
}
}
}
// check ctor
if (ctor.length > 0 && (!className || !className.startsWith('cc.'))) {
// To make a unified CCClass serialization process,
// we don't allow parameters for constructor when creating instances of CCClass.
// For advanced user, construct arguments can still get from 'arguments'.
cc.warnID(3617, className);
}
return ctor;
}
function _getAllCtors (baseClass, mixins, options) {
// get base user constructors
function getCtors (cls) {
if (CCClass._isCCClass(cls)) {
return cls.__ctors__ || [];
}
else {
return [cls];
}
}
var ctors = [];
// if (options.__ES6__) {
// if (mixins) {
// let baseOrMixins = getCtors(baseClass);
// for (let b = 0; b < mixins.length; b++) {
// let mixin = mixins[b];
// if (mixin) {
// let baseCtors = getCtors(mixin);
// for (let c = 0; c < baseCtors.length; c++) {
// if (baseOrMixins.indexOf(baseCtors[c]) < 0) {
// pushUnique(ctors, baseCtors[c]);
// }
// }
// }
// }
// }
// }
// else {
let baseOrMixins = [baseClass].concat(mixins);
for (let b = 0; b < baseOrMixins.length; b++) {
let baseOrMixin = baseOrMixins[b];
if (baseOrMixin) {
let baseCtors = getCtors(baseOrMixin);
for (let c = 0; c < baseCtors.length; c++) {
pushUnique(ctors, baseCtors[c]);
}
}
}
// }
// append subclass user constructors
var ctor = options.ctor;
if (ctor) {
ctors.push(ctor);
}
return ctors;
}
var SuperCallReg = /xyz/.test(function(){xyz}) ? /\b\._super\b/ : /.*/;
var SuperCallRegStrict = /xyz/.test(function(){xyz}) ? /this\._super\s*\(/ : /(NONE){99}/;
function boundSuperCalls (baseClass, options, className) {
var hasSuperCall = false;
for (var funcName in options) {
if (BUILTIN_ENTRIES.indexOf(funcName) >= 0) {
continue;
}
var func = options[funcName];
if (typeof func !== 'function') {
continue;
}
var pd = js.getPropertyDescriptor(baseClass.prototype, funcName);
if (pd) {
var superFunc = pd.value;
// ignore pd.get, assume that function defined by getter is just for warnings
if (typeof superFunc === 'function') {
if (SuperCallReg.test(func)) {
hasSuperCall = true;
// boundSuperCall
options[funcName] = (function (superFunc, func) {
return function () {
var tmp = this._super;
// Add a new ._super() method that is the same method but on the super-Class
this._super = superFunc;
var ret = func.apply(this, arguments);
// The method only need to be bound temporarily, so we remove it when we're done executing
this._super = tmp;
return ret;
};
})(superFunc, func);
}
continue;
}
}
if (CC_DEV && SuperCallRegStrict.test(func)) {
cc.warnID(3620, className, funcName);
}
}
return hasSuperCall;
}
function declareProperties (cls, className, properties, baseClass, mixins, es6) {
cls.__props__ = [];
if (baseClass && baseClass.__props__) {
cls.__props__ = baseClass.__props__.slice();
}
if (mixins) {
for (var m = 0; m < mixins.length; ++m) {
var mixin = mixins[m];
if (mixin.__props__) {
cls.__props__ = cls.__props__.concat(mixin.__props__.filter(function (x) {
return cls.__props__.indexOf(x) < 0;
}));
}
}
}
if (properties) {
// 预处理属性
preprocessAttrs(properties, className, cls, es6);
for (var propName in properties) {
var val = properties[propName];
if ('default' in val) {
defineProp(cls, className, propName, val, es6);
}
else {
defineGetSet(cls, className, propName, val, es6);
}
}
}
var attrs = Attr.getClassAttrs(cls);
cls.__values__ = cls.__props__.filter(function (prop) {
return attrs[prop + DELIMETER + 'serializable'] !== false;
});
}
/**
* @module cc
*/
/**
* !#en Defines a CCClass using the given specification, please see [Class](/docs/editors_and_tools/creator-chapters/scripting/class.html) for details.
* !#zh 定义一个 CCClass,传入参数必须是一个包含类型参数的字面量对象,具体用法请查阅[类型定义](/docs/creator/scripting/class.html)。
*
* @method Class
*
* @param {Object} [options]
* @param {String} [options.name] - The class name used for serialization.
* @param {Function} [options.extends] - The base class.
* @param {Function} [options.ctor] - The constructor.
* @param {Function} [options.__ctor__] - The same as ctor, but less encapsulated.
* @param {Object} [options.properties] - The property definitions.
* @param {Object} [options.statics] - The static members.
* @param {Function[]} [options.mixins]
*
* @param {Object} [options.editor] - attributes for Component listed below.
* @param {Boolean} [options.editor.executeInEditMode=false] - Allows the current component to run in edit mode. By default, all components are executed only at runtime, meaning that they will not have their callback functions executed while the Editor is in edit mode.
* @param {Function} [options.editor.requireComponent] - Automatically add required component as a dependency.
* @param {String} [options.editor.menu] - The menu path to register a component to the editors "Component" menu. Eg. "Rendering/Camera".
* @param {Number} [options.editor.executionOrder=0] - The execution order of lifecycle methods for Component. Those less than 0 will execute before while those greater than 0 will execute after. The order will only affect onLoad, onEnable, start, update and lateUpdate while onDisable and onDestroy will not be affected.
* @param {Boolean} [options.editor.disallowMultiple] - If specified to a type, prevents Component of the same type (or subtype) to be added more than once to a Node.
* @param {Boolean} [options.editor.playOnFocus=false] - This property is only available when executeInEditMode is set. If specified, the editor's scene view will keep updating this node in 60 fps when it is selected, otherwise, it will update only if necessary.
* @param {String} [options.editor.inspector] - Customize the page url used by the current component to render in the Properties.
* @param {String} [options.editor.icon] - Customize the icon that the current component displays in the editor.
* @param {String} [options.editor.help] - The custom documentation URL
*
* @param {Function} [options.update] - lifecycle method for Component, see {{#crossLink "Component/update:method"}}{{/crossLink}}
* @param {Function} [options.lateUpdate] - lifecycle method for Component, see {{#crossLink "Component/lateUpdate:method"}}{{/crossLink}}
* @param {Function} [options.onLoad] - lifecycle method for Component, see {{#crossLink "Component/onLoad:method"}}{{/crossLink}}
* @param {Function} [options.start] - lifecycle method for Component, see {{#crossLink "Component/start:method"}}{{/crossLink}}
* @param {Function} [options.onEnable] - lifecycle method for Component, see {{#crossLink "Component/onEnable:method"}}{{/crossLink}}
* @param {Function} [options.onDisable] - lifecycle method for Component, see {{#crossLink "Component/onDisable:method"}}{{/crossLink}}
* @param {Function} [options.onDestroy] - lifecycle method for Component, see {{#crossLink "Component/onDestroy:method"}}{{/crossLink}}
* @param {Function} [options.onFocusInEditor] - lifecycle method for Component, see {{#crossLink "Component/onFocusInEditor:method"}}{{/crossLink}}
* @param {Function} [options.onLostFocusInEditor] - lifecycle method for Component, see {{#crossLink "Component/onLostFocusInEditor:method"}}{{/crossLink}}
* @param {Function} [options.resetInEditor] - lifecycle method for Component, see {{#crossLink "Component/resetInEditor:method"}}{{/crossLink}}
* @param {Function} [options.onRestore] - for Component only, see {{#crossLink "Component/onRestore:method"}}{{/crossLink}}
* @param {Function} [options._getLocalBounds] - for Component only, see {{#crossLink "Component/_getLocalBounds:method"}}{{/crossLink}}
*
* @return {Function} - the created class
*
* @example
// define base class
var Node = cc.Class();
// define sub class
var Sprite = cc.Class({
name: 'Sprite',
extends: Node,
ctor: function () {
this.url = "";
this.id = 0;
},
statics: {
// define static members
count: 0,
getBounds: function (spriteList) {
// compute bounds...
}
},
properties {
width: {
default: 128,
type: 'Integer',
tooltip: 'The width of sprite'
},
height: 128,
size: {
get: function () {
return cc.v2(this.width, this.height);
}
}
},
load: function () {
// load this.url...
};
});
// instantiate
var obj = new Sprite();
obj.url = 'sprite.png';
obj.load();
*/
export default function CCClass (options) {
options = options || {};
var name = options.name;
var base = options.extends/* || CCObject*/;
var mixins = options.mixins;
// create constructor
var cls = define(name, base, mixins, options);
if (!name) {
name = cc.js.getClassName(cls);
}
cls._sealed = true;
if (base) {
base._sealed = false;
}
// define Properties
var properties = options.properties;
if (typeof properties === 'function' ||
(base && base.__props__ === null) ||
(mixins && mixins.some(function (x) {
return x.__props__ === null;
}))
) {
if (CC_DEV && options.__ES6__) {
cc.error('not yet implement deferred properties for ES6 Classes');
}
else {
deferredInitializer.push({cls: cls, props: properties, mixins: mixins});
cls.__props__ = cls.__values__ = null;
}
}
else {
declareProperties(cls, name, properties, base, options.mixins, options.__ES6__);
}
// define statics
var statics = options.statics;
if (statics) {
var staticPropName;
if (CC_DEV) {
for (staticPropName in statics) {
if (INVALID_STATICS_DEV.indexOf(staticPropName) !== -1) {
cc.errorID(3642, name, staticPropName,
staticPropName);
}
}
}
for (staticPropName in statics) {
cls[staticPropName] = statics[staticPropName];
}
}
// define functions
for (var funcName in options) {
if (BUILTIN_ENTRIES.indexOf(funcName) >= 0) {
continue;
}
var func = options[funcName];
if (!validateMethodWithProps(func, funcName, name, cls, base)) {
continue;
}
// use value to redefine some super method defined as getter
js.value(cls.prototype, funcName, func, true, true);
}
var editor = options.editor;
if (editor) {
if (js.isChildClassOf(base, cc.Component)) {
cc.Component._registerEditorProps(cls, editor);
}
else if (CC_DEV) {
cc.warnID(3623, name);
}
}
return cls;
}
/**
* Checks whether the constructor is created by cc.Class
*
* @method _isCCClass
* @param {Function} constructor
* @return {Boolean}
* @private
*/
CCClass._isCCClass = function (constructor) {
return constructor &&
constructor.hasOwnProperty('__ctors__'); // is not inherited __ctors__
};
//
// Optimized define function only for internal classes
//
// @method fastDefine
// @param {String} className
// @param {Function} constructor
// @param {Object} serializableFields
// @private
//
CCClass.fastDefine = function (className, constructor, serializableFields) {
js.setClassName(className, constructor);
//constructor.__ctors__ = constructor.__ctors__ || null;
var props = constructor.__props__ = constructor.__values__ = Object.keys(serializableFields);
var attrProtos = Attr.getClassAttrsProto(constructor);
for (var i = 0; i < props.length; i++) {
var key = props[i];
attrProtos[key + DELIMETER + 'visible'] = false;
attrProtos[key + DELIMETER + 'default'] = serializableFields[key];
}
};
CCClass.Attr = Attr;
CCClass.attr = Attr.attr;
/*
* Return all super classes
* @method getInheritanceChain
* @param {Function} constructor
* @return {Function[]}
*/
CCClass.getInheritanceChain = function (klass) {
var chain = [];
for (;;) {
klass = js.getSuper(klass);
if (!klass) {
break;
}
if (klass !== Object) {
chain.push(klass);
}
}
return chain;
};
var PrimitiveTypes = {
// Specify that the input value must be integer in Properties.
// Also used to indicates that the type of elements in array or the type of value in dictionary is integer.
Integer: 'Number',
// Indicates that the type of elements in array or the type of value in dictionary is double.
Float: 'Number',
Boolean: 'Boolean',
String: 'String',
};
var tmpAttrs = [];
function parseAttributes (cls, attrs, className, propName, usedInGetter) {
var ERR_Type = CC_DEV ? 'The %s of %s must be type %s' : '';
var attrsProto = null;
var attrsProtoKey = '';
function getAttrsProto () {
attrsProtoKey = propName + DELIMETER;
return attrsProto = Attr.getClassAttrsProto(cls);
}
tmpAttrs.length = 0;
var result = tmpAttrs;
var type = attrs.type;
if (type) {
var primitiveType = PrimitiveTypes[type];
if (primitiveType) {
result.push({
type: type,
_onAfterProp: getTypeChecker(primitiveType, 'cc.' + type)
});
}
else if (type === 'Object') {
if (CC_DEV) {
cc.errorID(3644, className, propName);
}
}
else {
if (typeof type === 'object') {
if (Enum.isEnum(type)) {
result.push({
type: 'Enum',
enumList: Enum.getList(type)
});
}
else if (CC_DEV) {
cc.errorID(3645, className, propName, type);
}
}
else if (typeof type === 'function') {
if (attrs.url) {
result.push({
type: 'Object',
ctor: type,
_onAfterProp: getTypeChecker('String', 'cc.String')
});
}
else {
result.push(attrs._short ? {
type: 'Object',
ctor: type
} : Attr.ObjectType(type));
}
}
else if (CC_DEV) {
cc.errorID(3646, className, propName, type);
}
}
}
function parseSimpleAttr (attrName, expectType) {
if (attrName in attrs) {
var val = attrs[attrName];
if (typeof val === expectType) {
(attrsProto || getAttrsProto())[attrsProtoKey + attrName] = val;
}
else if (CC_DEV) {
cc.error(ERR_Type, attrName, className, propName, expectType);
}
}
}
if (attrs.editorOnly) {
if (CC_DEV && usedInGetter) {
cc.errorID(3613, "editorOnly", name, propName);
}
else {
(attrsProto || getAttrsProto())[attrsProtoKey + 'editorOnly'] = true;
}
}
//parseSimpleAttr('preventDeferredLoad', 'boolean');
if (CC_DEV) {
parseSimpleAttr('displayName', 'string');
parseSimpleAttr('multiline', 'boolean');
if (attrs.readonly) {
(attrsProto || getAttrsProto())[attrsProtoKey + 'readonly'] = true;
}
parseSimpleAttr('tooltip', 'string');
parseSimpleAttr('slide', 'boolean');
}
if (attrs.url) {
(attrsProto || getAttrsProto())[attrsProtoKey + 'saveUrlAsAsset'] = true;
}
if (attrs.serializable === false) {
if (CC_DEV && usedInGetter) {
cc.errorID(3613, "serializable", name, propName);
}
else {
(attrsProto || getAttrsProto())[attrsProtoKey + 'serializable'] = false;
}
}
parseSimpleAttr('formerlySerializedAs', 'string');
if (CC_EDITOR) {
if ('animatable' in attrs && !attrs.animatable) {
(attrsProto || getAttrsProto())[attrsProtoKey + 'animatable'] = false;
}
}
if (CC_DEV) {
var visible = attrs.visible;
if (typeof visible !== 'undefined') {
if (!visible) {
(attrsProto || getAttrsProto())[attrsProtoKey + 'visible'] = false;
}
else if (typeof visible === 'function') {
(attrsProto || getAttrsProto())[attrsProtoKey + 'visible'] = visible;
}
}
else {
var startsWithUS = (propName.charCodeAt(0) === 95);
if (startsWithUS) {
(attrsProto || getAttrsProto())[attrsProtoKey + 'visible'] = false;
}
}
}
var range = attrs.range;
if (range) {
if (Array.isArray(range)) {
if (range.length >= 2) {
(attrsProto || getAttrsProto())[attrsProtoKey + 'min'] = range[0];
attrsProto[attrsProtoKey + 'max'] = range[1];
if (range.length > 2) {
attrsProto[attrsProtoKey + 'step'] = range[2];
}
}
else if (CC_DEV) {
cc.errorID(3647);
}
}
else if (CC_DEV) {
cc.error(ERR_Type, 'range', className, propName, 'array');
}
}
parseSimpleAttr('min', 'number');
parseSimpleAttr('max', 'number');
parseSimpleAttr('step', 'number');
return result;
}
CCClass.isArray = function (defaultVal) {
defaultVal = getDefault(defaultVal);
return Array.isArray(defaultVal);
}
CCClass.getDefault = getDefault;
CCClass.escapeForJS = escapeForJS;
CCClass.IDENTIFIER_RE = IDENTIFIER_RE;
CCClass.getNewValueTypeCode = CC_SUPPORT_JIT && getNewValueTypeCodeJit;
cc.Class = CCClass;