Class: decl

This convenience property is true if the environment supports property getters and setters.

Convenience property to ease defining a read only property on an Interface. It as simply a shortcut for '{ allowGet: true, allowSet: false }':

 decl.declareInterface( function MyInterface() {},
 {
     // The following two definitions have exactly the same effect:
     myProperty: decl.readOnlyProperty,
     myProperty: { allowGet: true, allowSet: false }
 } );

Convenience property to ease defining a read/write property on an Interface. It as simply a shortcut for '{ allowGet: true, allowSet: true }':

 decl.declareInterface( function MyInterface() {},
 {
     // The following two definitions have exactly the same effect:
     myProperty: decl.readWriteProperty,
     myProperty: { allowGet: true, allowSet: true }
 } );

Declare a constructor function to be an abstract class. Allows specifying an optional base class and interfaces implemented. When reading or writing decl.abstractClass statements, it might help to know it was designed to mimic popular languages in its format. Here's an example:

 // With common languages
 abstract class ClassName : BaseClass, Interface1, Interface2 // C#
 abstract class ClassName extends BaseClass implements Interface1, Interface2 // Java
 {
     private String _name;

     public ClassName( _name )
     {
         super( 42 );
         this._name = _name;
     }

     public String toString()
     {
         return this._name;
     }
 }

 // With barejs.decl:

 function ClassName( _name )
 {
     BaseClass.call( this, 42 );
     this._name = _name;
 }

 decl.abstractClass( ClassName, BaseClass, Interface1, Interface2,
 {
     // This puts the _name property as null on the prototype,
     // which is purely for clarity (e.g. stating it exists).
     _name: null,

     toString: function()
     {
         return this._name;
     }
 }

• If a base class is provided, decl will ensure _class.prototype is instanceof _base.prototype.
• For abstract classes, decl will not validate if interface methods are implemented.
• If a _static argument is specified, it will be applied to the constructor function using defineObject.
• If a _prototype argument is specified, it will be applied to the prototype using defineObject.
• If only 1 object is supplied, it is always interpreted as prototype definition, never as static. You must specify null for the prototype object if you only want to specify static members.

By default, any static members (except name, prototype, constructor, superclass and other metadata) will inherit. A class can make static functions "private" by defining a static $private function, accepting a String/Symbol as key. This function should return true for any keys that should not inherit. The $private function itself will never inherit.

Interpret _target as implementing a Java Functional Interface. A functional interface is an Interface with exactly 1 function defined. Java allows lambda expressions to be generated for arguments of this type of interface. This method allows normalizing a function or object to a "Functional Interface Object", so Java behavior can be emulated. This function will accept:

• null/undefined (then null is returned)
• A function (an 'instance' of _functionalInterface is returned, with this function in place).
• An object complying with _functionalInterface

Any other argument will throw a TypeError.

Declare a constructor function to be a class. Allows specifying an optional base class and interfaces implemented. When reading or writing decl.declareClass statements, it might help to know it was designed to mimic popular languages in its format. Here's an example:

 // With common languages
 class ClassName : BaseClass, Interface1, Interface2 // C#
 class ClassName extends BaseClass implements Interface1, Interface2 // Java
 {
     private String _name;

     public ClassName( _name )
     {
         super( 42 );
         this._name = _name;
     }

     public String toString()
     {
         return this._name;
     }
 }

 // With barejs.decl:

 function ClassName( _name )
 {
     BaseClass.call( this, 42 );
     this._name = _name;
 }

 decl.declareClass( ClassName, BaseClass, Interface1, Interface2,
 {
     // This puts the _name property as null on the prototype,
     // which is purely for clarity (e.g. stating it exists).
     _name: null,

     toString: function()
     {
         return this._name;
     }
 }

• If a base class is provided, decl will ensure _class.prototype is instanceof _base.prototype.
• If interfaces are declared, decl will validate methods are implemented.
• If a _static argument is specified, it will be applied to the constructor function using defineObject.
• If a _prototype argument is specified, it will be applied to the prototype using defineObject.
• If only 1 object is supplied, it is always interpreted as prototype definition, never as static. You must specify null for the prototype object if you only want to specify static members.

By default, any static members (except name, prototype, constructor, superclass and other metadata) will inherit. A class can make static functions "private" by defining a static $private function, accepting a String/Symbol as key. This function should return true for any keys that should not inherit. The $private function itself will never inherit.

Declare an enum. decl will make _class derive from the special internal Enum type, and return a new instance of it. Enum values should be set on 'this' in the constructor, utility methods should be added to the prototype.

 var SampleEnum = decl.declareEnum( function SampleEnum()
 {
     this.Bit1 = 1;
     this.Bit2 = 2;
     this.Bit3 = 4;
     this.Bit4 = 8;
 },
 // End of constructor, what follows is the prototype definition:
 {
     hasBit: function( _bit, _value )
     {
         // hasValue is provided by the Enum base class
         if ( !this.hasValue( _bit ) )
             throw new TypeError( "Unknown SampleEnum value: " + _bit );
         return _value & _bit === _bit
     }
 } );

 // SampleEnum is now instanceof the SampleEnum function passed to decl.
 SampleEnum.hasBit( SampleEnum.Bit2, 3 ); // true
 // And it inherited decl's Enum type members
 SampleEnum.names(); // ["Bit1", "Bit2", "Bit3", "Bit4"]
 SampleEnum instanceof Object; // false

Note that the prototype property, if specified, is applied using defineObject.

Declare an interface. An interface can extend multiple interfaces by passing them as additional parameters. The constructor function _class will be made to derive from the special internal Interface type. It is not meant to be instantiated, and decl will never call the interface's constructor.

defineObject is similar to decl.defineProperties, but it expands the _definition's properties if needed. It will update values of properties that are not property assigment definitions to be proper property definitions, defaulting to:

 { configurable: false, writable: true, enumerable: true, value: <value> }

(Note: enumerable will be false if the name starts with _ or is a Symbol). defineObject will iterate the _definition object and expand properties on it. Please be aware of the following:

1. _destination will be modified. If that's a problem, use Object.assign to create a copy first.

2. Existing properties are scanned for presence of a value, get or set property. If these are present on a value, you must use the full property syntax:

   decl.defineObject( MyClass,
   {
       // Since the object we want to assign to the MyClass constructor function has properties that make it look like
       // a property definition, we have to wrap it in a property definition as required by Object.defineProperties.
       staticFlags: { enumerable: true, value: { get: true, set: false } }
   } );

3. defineObject will silently ignore getter/setter properties in environments that don't support them, unlike module:barejs.decl.defineProperties.

4. You can reference a getter or setter by name, provided it is also on the definition object:

   decl.defineObject( {},
   {
       // underlying data Array, not enumerable, configurable or writable
       _values: { value: [] },
       // getSize function that returns the length of the _values
       getSize: function() { return this._values.length; },
       // Size property. Refers to the getSize function for the getter, instead of using an inline function.
       size: { enumerable: true, get: "getSize" }
   } );

decl re-exports Object.defineProperties.

If the native version is not available, a fall-back is used. The fallback supports the same syntax as the original, and uses the defineProperty fallback.

decl re-exports Object.defineProperty.

If the native version is not available, a fall-back is used. The fallback supports the same syntax as the original, but falls back to simple assignment or deprecated constructs like __defineGetter__. Be aware that property getters or setters may not be supported in some environments, which is indicated by hasPropertySupport being false.

decl re-exports Object.freeze. A frozen object may not be altered in any way. No properties may be added or removed (like seal), and all values are made read-only.

If the native version is not available, a no-operation function is used. The object is not altered in any way and simply returned.

Checks if _class has _base as a superclass. Also true if _class === _base. Do not use this method to check if an Object is of a specific type, use the instanceof operator for that instead.

Checks if _target (or a base class) implements the specified Interface. Works on both instances and the class constructor.

Wrapper for Object.is that will "unproxy" values.

 // This returns false, Object.is sees two different objects:
 Object.is( instance, instance.as( MyInterface );

 // This returns true, decl will unproxy proxies.
 decl.is( instance, instance.as( MyInterface ) );

Check if the _target is an enum. Only works with instances, since enums should not expose their class constructor directly.

decl re-exports Object.isFrozen.

If the native version is not available, a no-operation function is used. The object is not altered by the fallback, and it always returns false (since freezing objects is not supported).

Check if the _target is an interface. Only works with class constructors, since there should be no instance of an interface.

Check if the target is a proxy object.

decl re-exports Object.isSealed. A sealed object may not be altered by adding or removing properties. Existing properties may be altered (provided they are writable).

If the native version is not available, a no-operation function is used. The object is not altered by the fallback, and it always returns false (since sealing objects is not supported).

Tells the proxy system casting to this type is not allowed. Should only be used for very low level classes, otherwise performance will be impacted.

Create and return a proxy object for the target

decl re-exports Object.seal.

If the native version is not available, a no-operation function is used. The object is not altered in any way and simply returned.