JAVASCRIPT   109

Type js

Guest on 31st May 2022 02:02:35 AM

  1. /**
  2.  * @author Tom
  3.  */
  4.  
  5. /**
  6.  * Creates a named type from the mixins, the code, and with the constructor.
  7.  * @param {String} name
  8.  * @param {Array} mixins
  9.  * @param {Object} [code]
  10.  * @param {Function} [constructor]
  11.  * @return {Function} constructor
  12.  */
  13. function type(name, mixins, members, constructor) {
  14.         constructor = any(constructor, function() {});
  15.         members = getObject(members);
  16.         members[name] = constructor;
  17.         members.constructor = constructor;
  18.         constructor.prototype = members;
  19.         constructor.mixins = [name];
  20.         mixinType(constructor, mixins);
  21.         this[name] = constructor;
  22.         return constructor;
  23. }
  24.  
  25. /**
  26.  * Mixes mixins into the target type.
  27.  * @param {Function} target
  28.  * @param {Array} mixins
  29.  * @return {Function} target
  30.  */
  31. function mixinType(target, mixins) {
  32.         var code = target.prototype;
  33.         var mixs = target.mixins;
  34.         iterate(mixins, function(mixinName) {
  35.                 var mixinCode = eval(mixinName);
  36.                 enumerate(mixinCode.prototype, function(value, key) {
  37.                         if (!exists(code[key]) || code[key] === Object.prototype[key]) {
  38.                                 code[key] = value;
  39.                         }
  40.                 });
  41.                 if (exists(mixinCode.mixins)) {
  42.                         iterate(mixinCode.mixins, function(item) {
  43.                                 if (!code[item]) {
  44.                                         mixs.push(item);
  45.                                 }
  46.                         });
  47.                 } else {
  48.                         // simple type
  49.                         if (!code[mixinName]) {
  50.                                 mixs.push(mixinName);
  51.                         }
  52.                         init(code, mixinName, mixinCode);
  53.                 }
  54.         });
  55.         return target;
  56. }
  57.  
  58. /**
  59.  * Mixes the mixin of the source into the target instance.
  60.  * @param {Object} target
  61.  * @param {Object} source
  62.  * @param {Object} mixin
  63.  * @return {Object} target;
  64.  */
  65. function mixinInstance(target, source, mixin) {
  66.         enumerate(mixin.prototype, function(value, key) {
  67.                 target[key] = source[key];
  68.         });
  69.         return target;
  70. }
  71.  
  72. /**
  73.  * Creates an enumeration of the given names.
  74.  * @param {String} ... names
  75.  * @constructor
  76.  */
  77. function Enum() {
  78.         var self = this;
  79.         iterate(arguments, function(item, index) {
  80.                 self[item] = index;
  81.         });
  82. }
  83.  
  84. function NamedEnum() {
  85.         var self = this;
  86.         iterate(arguments, function(item) {
  87.                 self[item] = item;
  88.         });
  89. }

Raw Paste


Login or Register to edit or fork this paste. It's free.