@schukai/monster 2.0.16 → 2.1.0

package/source/types/base.mjs

@@ -5,10 +5,29 @@
  * License text available at https://www.gnu.org/licenses/agpl-3.0.en.html
  */
 
+import {instanceSymbol} from "../constants.mjs";
+
 export {Base}
 
+
 /**
  * This is the base class from which all monster classes are derived.
+ * 
+ * This class has besides a `toString` which returns the json representation of the object
+ * also a functionality to check if an object is an instance of a class.
+ * 
+ * Therefor the class has a static method ` [Symbol.hasInstance](that)` which returns true if the object 
+ * is an instance of the class. 
+ * F
+ * @see [https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol/hasInstance](developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol/hasInstance)
+ *
+ * Derived classes should implement a static getter `instanceSymbol` which returns a unique symbol.
+ * 
+ * ```javascript
+ * static get [instanceSymbol]() {
+ *    return Symbol.for("@schukai/monster/types/base");
+ * }
+ * ```
  *
  * The class was formerly called Object.
  *
@@ -27,5 +46,86 @@ class Base extends Object {
         return JSON.stringify(this);
     };
 
+    /**
+     * This method is called by the `instanceof` operator.
+     * @returns {symbol}
+     * @since 2.1.0
+     */
+    static get [instanceSymbol]() {
+        return Symbol.for("@schukai/monster/types/base");
+    }
+
+    /**
+     * This method is called by the `instanceof` operator.
+     * @param that
+     * @returns {boolean}
+     * @since 2.1.0
+     */
+    static [Symbol.hasInstance](that) {
+
+        if (that === undefined || that === null || (typeof that !== "object" && typeof that !== "function")) {
+            return false;
+        }
+
+        const thatClass = Object.getPrototypeOf(that)
+        if (thatClass === undefined || thatClass === null || (typeof thatClass !== "object" && typeof thatClass !== "function")) {
+            return false;
+        }
+
+        if (checkInstanceSymbol.apply(this, [thatClass]) === true) {
+            return true;
+        }
+
+
+        // this call the static method of the super class, if there is one
+        return super[Symbol.hasInstance](that);
+
+    }
+
+}
+
+/**
+ * this function checks if the class has a static getter `instanceSymbol` and if the value of this getter is equal to the
+ * 
+ * @private
+ * @param obj
+ * @returns {boolean|any|boolean}
+ * @since 2.1.0
+ */
+function checkInstanceSymbol(obj) {
+
+    if (this.hasOwnProperty(instanceSymbol) === false) {
+        return false;
+    }
+
+    const proto = obj?.constructor;
+    if (proto === undefined || proto === null || (typeof proto !== "object" && typeof proto !== "function")) {
+        return false;
+    }
+
+    if (proto.hasOwnProperty(instanceSymbol) !== true) {
+        return checkInstanceSymbol.apply(this, [obj.__proto__]);
+    }
+
+    const symbol = proto[instanceSymbol];
+    if (symbol === undefined) {
+
+        if (obj.__proto__) {
+            return checkInstanceSymbol(obj.__proto__);
+        } else {
+            return false;
+        }
+
+    }
+
+    if (symbol === this[instanceSymbol]) {
+        return true;
+    }
+    
+    return checkInstanceSymbol.apply(this, [obj.__proto__]);
+
 
 }
+
+
+

package/source/types/dataurl.mjs

@@ -9,7 +9,7 @@ import {Base} from "./base.mjs";
 import {isString} from "./is.mjs";
 import {MediaType, parseMediaType} from "./mediatype.mjs";
 import {validateBoolean, validateInstance, validateString} from "./validate.mjs";
-
+import {instanceSymbol} from '../constants.mjs';
 export {DataUrl, parseDataURL}
 
 /**
@@ -52,6 +52,16 @@ class DataUrl extends Base {
 
     }
 
+    /**
+     * This method is called by the `instanceof` operator.
+     * @returns {symbol}
+     * @since 2.1.0
+     */
+    static get [instanceSymbol]() {
+        return Symbol.for("@schukai/monster/types/data-url");
+    }
+
+
     get content() {
         return this[internal].base64 ? atob(this[internal].content) : this[internal].content;
     }

package/source/types/mediatype.mjs

@@ -8,7 +8,7 @@
 import {Base} from "./base.mjs";
 import {isString} from "./is.mjs";
 import {validateArray, validateString} from "./validate.mjs";
-
+import {instanceSymbol} from '../constants.mjs';
 export {MediaType, parseMediaType}
 
 /**
@@ -57,6 +57,16 @@ class MediaType extends Base {
 
     }
 
+    /**
+     * This method is called by the `instanceof` operator.
+     * @returns {symbol}
+     * @since 2.1.0
+     */
+    static get [instanceSymbol]() {
+        return Symbol.for("@schukai/monster/types/media-type");
+    }
+
+
     /**
      * @return {String}
      */

package/source/types/node.mjs

@@ -9,7 +9,7 @@ import {Base} from './base.mjs';
 import {isPrimitive} from "./is.mjs";
 import {NodeList} from './nodelist.mjs';
 import {validateInstance} from './validate.mjs';
-
+import {instanceSymbol} from '../constants.mjs';
 export {Node}
 
 /**
@@ -52,6 +52,16 @@ class Node extends Base {
 
     }
 
+    /**
+     * This method is called by the `instanceof` operator.
+     * @returns {symbol}
+     * @since 2.1.0
+     */
+    static get [instanceSymbol]() {
+        return Symbol.for("@schukai/monster/types/node");
+    }
+    
+
     /**
      * @property {*}
      */

package/source/types/nodelist.mjs

@@ -8,7 +8,7 @@
 import {isArray, isInstance} from "./is.mjs";
 import {Node} from "./node.mjs";
 import {validateInstance} from "./validate.mjs";
-
+import {instanceSymbol} from '../constants.mjs';
 export {NodeList}
 
 /**
@@ -44,6 +44,16 @@ class NodeList extends Set {
         }
     }
 
+    /**
+     * This method is called by the `instanceof` operator.
+     * @returns {symbol}
+     * @since 2.1.0
+     */
+    static get [instanceSymbol]() {
+        return Symbol.for("@schukai/monster/types/node-list");
+    }
+    
+
     /**
      *
      * @param {Node} node

package/source/types/observer.mjs

@@ -9,7 +9,7 @@ import {Base} from './base.mjs';
 import {isObject} from './is.mjs';
 import {TokenList} from './tokenlist.mjs';
 import {UniqueQueue} from './uniquequeue.mjs';
-
+import {instanceSymbol} from '../constants.mjs';
 export {Observer}
 
 /**
@@ -64,6 +64,16 @@ class Observer extends Base {
         this.queue = new UniqueQueue();
     }
 
+    /**
+     * This method is called by the `instanceof` operator.
+     * @returns {symbol}
+     * @since 2.1.0
+     */
+    static get [instanceSymbol]() {
+        return Symbol.for("@schukai/monster/types/observer");
+    }
+    
+    
     /**
      *
      * @param {string} tag

package/source/types/proxyobserver.mjs

@@ -11,7 +11,7 @@ import {Observer} from "./observer.mjs";
 import {ObserverList} from "./observerlist.mjs";
 import {validateObject} from "./validate.mjs";
 import {extend} from "../data/extend.mjs";
-
+import {instanceSymbol} from '../constants.mjs';
 export {ProxyObserver}
 
 /**
@@ -50,6 +50,16 @@ export {ProxyObserver}
         this.observers = new ObserverList;
     }
 
+    /**
+     * This method is called by the `instanceof` operator.
+     * @returns {symbol}
+     * @since 2.1.0
+     */
+    static get [instanceSymbol]() {
+        return Symbol.for("@schukai/monster/types/proxy-observer");
+    }
+
+
     /**
      * get the real object
      *

package/source/types/queue.mjs

@@ -6,7 +6,7 @@
  */
 
 import {Base} from './base.mjs';
-
+import {instanceSymbol} from '../constants.mjs';
 export {Queue}
 
 /**
@@ -29,6 +29,16 @@ class Queue extends Base {
         this.data = [];
     }
 
+    /**
+     * This method is called by the `instanceof` operator.
+     * @returns {symbol}
+     * @since 2.1.0
+     */
+    static get [instanceSymbol]() {
+        return Symbol.for("@schukai/monster/types/queue");
+    }
+
+
 
     /**
      * @return {boolean}

package/source/types/stack.mjs

@@ -6,7 +6,7 @@
  */
 
 import {Base} from './base.mjs';
-
+import {instanceSymbol} from '../constants.mjs';
 export {Stack}
 
 /**
@@ -27,6 +27,15 @@ class Stack extends Base {
         this.data = [];
     }
 
+    /**
+     * This method is called by the `instanceof` operator.
+     * @returns {symbol}
+     * @since 2.1.0
+     */
+    static get [instanceSymbol]() {
+        return Symbol.for("@schukai/monster/types/stack");
+    }
+
 
     /**
      * @return {boolean}

package/source/types/version.mjs

@@ -6,9 +6,11 @@
  */
 
 import {Base} from './base.mjs';
+import {instanceSymbol} from '../constants.mjs';
 
 export {Version, getMonsterVersion}
 
+
 /**
  * The version object contains a semantic version number
  *
@@ -72,6 +74,16 @@ class Version extends Base {
 
     }
 
+    /**
+     * This method is called by the `instanceof` operator.
+     * @returns {symbol}
+     * @since 2.1.0
+     */
+    static get [instanceSymbol]() {
+        return Symbol.for("@schukai/monster/types/version");
+    }
+
+
     /**
      *
      * @returns {string}
@@ -135,9 +147,9 @@ function getMonsterVersion() {
     if (monsterVersion instanceof Version) {
         return monsterVersion;
     }
-    
+
     /** don't touch, replaced by make with package.json version */
-    monsterVersion = new Version('2.0.16')
+    monsterVersion = new Version('2.1.0')
 
     return monsterVersion;
 

package/test/cases/constraint/abstractoperator.mjs

@@ -0,0 +1,38 @@
+import {Base} from "../../../../application/source/types/base.mjs";
+import {AbstractOperator} from "../../../../application/source/constraints/abstractoperator.mjs";
+import {expect} from "chai"
+
+class AbstractConstraintMock extends Base {
+
+    constructor() {
+        super();
+    }
+
+    isValid(value) {
+        return Promise.reject(value);
+    }
+}
+
+
+describe('AbstractOperator', function () {
+    it('should throw an error when the constraint is not call with parameter', function (done) {
+        try {
+            new AbstractOperator()
+        } catch (e) {
+            done();
+        }
+    });
+
+    it('should throw not an error when the constraint is not call with parameter', function (done) {
+
+        try {
+            const c = new AbstractOperator(new AbstractConstraintMock(), new AbstractConstraintMock())    
+        } catch (e) {
+            done();
+        }
+        
+    
+
+    });
+});
+

package/test/cases/dom/resource.mjs

@@ -0,0 +1,48 @@
+'use strict';
+
+
+import {initJSDOM} from "../../util/jsdom.mjs";
+import {expect} from "chai"
+let Resource,DerivedResource;
+
+
+
+describe('Resource', function() {
+
+    before(function (done) {
+        initJSDOM().then(() => {
+
+            import("../../../../application/source/dom/resource.mjs").then((m) => {
+                Resource = m['Resource'];
+
+
+                DerivedResource = class  extends Resource {
+                    constructor() {
+                        super({
+                            "data-url": "http://example.com",
+                        });
+                    }
+
+                    static getURLAttribute() {
+                        return 'data-url';
+                    }
+                }                
+                
+                done()
+            });
+
+        });
+
+
+    })
+
+    describe('DerivedResource', function () {
+
+        it('should instanceof Resource', function () {
+            expect(new DerivedResource()).to.be.an.instanceof(Resource);
+        });
+
+    });
+
+
+});

package/test/cases/monster.mjs

@@ -7,7 +7,7 @@ describe('Monster', function () {
         let monsterVersion
 
         /** don´t touch, replaced by make with package.json version */
-        monsterVersion = new Version('2.0.16')
+        monsterVersion = new Version('2.1.0')
 
         let m = getMonsterVersion();
 

package/test/cases/types/base.mjs

@@ -2,8 +2,29 @@
 
 import {expect} from "chai"
 import {Base} from "../../../../application/source/types/base.mjs";
+import {instanceSymbol} from "../../../../application/source/constants.mjs";
 
 
+
+class BaseDifferentRealm extends Object {
+    
+
+    static get [instanceSymbol]() {
+        return Symbol.for("@schukai/monster/types/base");
+    }
+
+
+}
+
+class Subclass extends BaseDifferentRealm {
+    constructor() {
+        super();
+    }
+    static get [instanceSymbol]() {
+        return Symbol.for("@schukai/monster/types/subclass");
+    }
+}
+
 describe('Base', function () {
 
     describe('new Base', function () {
@@ -17,5 +38,26 @@ describe('Base', function () {
         });
 
     })
+    
+    describe('instancof', function () {
+
+        it('is instance of Base', function () {
+            expect(new Base).to.be.instanceOf(Base);
+        });
+        
+        it('subclass instanceof', function () {
+            
+            if (new Subclass instanceof Base) {
+                expect(true).to.be.true;
+            } else  {
+                expect(false).to.be.true;
+            }
+            
+            
+            
+        });
+
+
+    })
 
 })