@schukai/monster 3.14.1 → 3.15.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@schukai/monster",
-  "version": "3.14.1",
+  "version": "3.15.0",
   "description": "Monster is a simple library for creating fast, robust and lightweight websites.",
   "keywords": [
     "framework",

package/source/dom/customelement.mjs

@@ -354,7 +354,7 @@ class CustomElement extends HTMLElement {
     static getCSSStyleSheet() {
         return undefined;
     }
-
+ 
     /**
      * attach a new observer
      *

package/source/dom/resourcemanager.mjs

@@ -6,8 +6,9 @@
  */
 
 import { extend } from "../data/extend.mjs";
-import { BaseWithOptions } from "../types/basewithoptions.mjs";
+import { Base } from "../types/base.mjs";
 import { getGlobalObject } from "../types/global.mjs";
+import {equipWithInternal} from "../types/internal.mjs";
 import { isArray } from "../types/is.mjs";
 import { ATTRIBUTE_HREF, ATTRIBUTE_SRC } from "./constants.mjs";
 import { Resource } from "./resource.mjs";
@@ -26,7 +27,7 @@ export { ResourceManager };
  * @memberOf Monster.DOM
  * @summary A Resource class
  */
-class ResourceManager extends BaseWithOptions {
+class ResourceManager extends Base {
     /**
      *
      * @param {Object} options
@@ -34,12 +35,21 @@ class ResourceManager extends BaseWithOptions {
      */
     constructor(options) {
         super(options);
+        equipWithInternal.call(this);
 
         if (!(this.getOption("document") instanceof Document)) {
             throw new Error("unsupported document type");
         }
     }
 
+    /**
+     * @deprecated since 3.15.0 use getInternal instead
+     * @property {string} baseurl
+     */
+    getOption(key) {
+        return this.getInternal(key);
+    }
+
     /**
      * @property {string} baseurl
      */
@@ -47,6 +57,14 @@ class ResourceManager extends BaseWithOptions {
         this.getOption("document")?.baseURL;
     }
 
+    /**
+     * @property {string} baseurl
+     * @deprecated since 3.15.0 use internalDefaults instead
+     */
+    get defaults() {
+        return this.internalDefaults;
+    }
+
     /**
      *
      * @property {HTMLDocument} document=document Document
@@ -55,8 +73,8 @@ class ResourceManager extends BaseWithOptions {
      * @property {Array} resources.stylesheets=[] array with {@link Monster.DOM.Resource.Link.Stylesheet} objects
      * @property {Array} resources.data=[] array with {@link Monster.DOM.Resource.Data} objects
      */
-    get defaults() {
-        return Object.assign({}, super.defaults, {
+    get internalDefaults() {
+        return Object.assign({},  {
             document: getGlobalObject("document"),
             resources: {
                 scripts: [],

package/source/types/base.mjs

@@ -10,14 +10,14 @@ import { instanceSymbol } from "../constants.mjs";
 export { Base };
 
 /**
- * This is the base class from which all monster classes are derived.
+ * This is the base class from which the most 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.

package/source/types/basewithoptions.mjs

@@ -26,6 +26,7 @@ export { BaseWithOptions };
  * @since 1.13.0
  * @copyright schukai GmbH
  * @memberOf Monster.Types
+ * @deprecated since 3.15.0 use {@link Monster.Types.Base} with {@link Monster.Types.equipWithInternal} instead.
  */
 class BaseWithOptions extends Base {
     /**

package/source/types/internal.mjs

@@ -0,0 +1,181 @@
+/**
+ * Copyright schukai GmbH and contributors 2022. All Rights Reserved.
+ * Node module: @schukai/monster
+ * This file is licensed under the AGPLv3 License.
+ * License text available at https://www.gnu.org/licenses/agpl-3.0.en.html
+ */
+import {internalSymbol} from "../constants.mjs";
+import {extend} from "../data/extend.mjs";
+import {Pathfinder} from "../data/pathfinder.mjs";
+import {parseDataURL} from "./dataurl.mjs";
+import {isString} from "./is.mjs";
+import {Observer} from "./observer.mjs";
+import {ProxyObserver} from "./proxyobserver.mjs";
+import {validateObject} from "./validate.mjs";
+import {isObject} from "./is.mjs";
+
+export {equipWithInternal}
+
+/**
+ * @private
+ * @type {string}
+ */
+const propertyName = 'internalDefaults'
+
+/**
+ * This function extends the given object with the following methods:
+ * 
+ * - attachInternalObserver
+ * - detachInternalObserver
+ * - containsInternalObserver
+ * - setInternal
+ * - setInternals
+ * - getInternal
+ * 
+ * @license AGPLv3
+ * @since 3.15.0
+ * @copyright schukai GmbH
+ * @memberOf Monster.Types
+ */
+function equipWithInternal() {
+    const self = this;
+    validateObject(self);
+
+    if (!hasGetter(self, propertyName)) {
+        Object.defineProperty(self, propertyName, {
+            get: function () {
+                return {};
+            }
+        });
+    }
+
+    const defaults = extend({}, self[propertyName] || {});
+    self[internalSymbol] = new ProxyObserver(defaults);
+
+    /**
+     * Attach a new observer
+     *
+     * @param {Observer} observer
+     * @returns {ProxyObserver}
+     */
+    self["attachInternalObserver"] = (observer) => {
+        self[internalSymbol].attachObserver(observer);
+        return self;
+    }
+
+    /**
+     * Detach a observer
+     *
+     * @param {Observer} observer
+     * @returns {ProxyObserver}
+     */
+    self["detachInternalObserver"] = (observer) => {
+        self[internalSymbol].detachObserver(observer);
+        return self;
+    }
+
+    /**
+     * Check if a observer is attached
+     * 
+     * @param {Observer} observer
+     * @returns {boolean}
+     */
+    self["containsInternalObserver"] = (observer) => {
+        return self[internalSymbol].containsObserver(observer);
+    }
+
+
+    /**
+     * Set an internal value, nested internals can be specified by path `a.b.c`
+     *
+     * @param {string} path
+     * @param {*} value
+     * @return {Datasource}
+     */
+    self["setInternal"] = (path, value) => {
+        new Pathfinder(self[internalSymbol].getSubject()).setVia(path, value);
+        return self;
+    }
+
+    /**
+     * set multiple internals at once
+     * 
+     * @param {string|object} options
+     * @return {Datasource}
+     * @throws {Error} the options does not contain a valid json definition
+     */
+    self["setInternals"] = (options) => {
+        if (isString(options)) {
+            options = parseOptionsJSON(options);
+        }
+
+        extend(self[internalSymbol].getSubject(), defaults, options);
+        return self;
+    }
+
+    /**
+     * nested internals can be specified by path `a.b.c`
+     *
+     * @param {string} path
+     * @param {*} defaultValue
+     * @return {*}
+     */
+    self["getInternal"] = (path, defaultValue) => {
+        let value;
+
+        try {
+            value = new Pathfinder(self[internalSymbol]
+                .getRealSubject()).getVia(path);
+        } catch (e) {
+        }
+
+        if (value === undefined) return defaultValue;
+        return value;
+    }
+}
+
+/**
+ * @private
+ * @param obj
+ * @param prop
+ * @return {boolean}
+ */
+function hasGetter(obj, prop) {
+
+    while (isObject(obj)) {
+        if (Object.getOwnPropertyDescriptor(obj, prop)?.['get']) {
+            return true;
+        }
+        obj = Object.getPrototypeOf(obj);
+    }
+
+    return false;
+}
+
+/**
+ * @private
+ * @param data
+ * @return {Object}
+ */
+function parseOptionsJSON(data) {
+    let obj = {};
+
+    if (!isString(data)) {
+        return obj;
+    }
+
+    // the configuration can be specified as a data url.
+    try {
+        let dataUrl = parseDataURL(data);
+        data = dataUrl.content;
+    } catch (e) {
+    }
+
+    try {
+        obj = JSON.parse(data);
+    } catch (e) {
+        throw e;
+    }
+
+    return validateObject(obj);
+}

package/source/types/version.mjs

@@ -142,7 +142,7 @@ function getMonsterVersion() {
     }
 
     /** don't touch, replaced by make with package.json version */
-    monsterVersion = new Version("3.14.1");
+    monsterVersion = new Version("3.15.0");
 
     return monsterVersion;
 }

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("3.14.1")
+        monsterVersion = new Version("3.15.0")
 
         let m = getMonsterVersion();
 

package/test/cases/types/internal.mjs

@@ -0,0 +1,153 @@
+"use strict";
+
+import {expect} from "chai"
+import {equipWithInternal} from "../../../../application/source/types/internal.mjs";
+import {Observer} from "../../../../application/source/types/observer.mjs";
+
+class SomeRandomClass1 extends Object {
+
+    doit() {
+        return "done";
+    }
+}
+
+class SomeRandomClass2 extends Object {
+
+    constructor() {
+        super();
+        equipWithInternal.call(this);
+    }
+
+    get defaultInternal() {
+        return {
+            test: "test"
+        }
+    }
+
+}
+
+describe('Base inject with options', function () {
+
+    describe('new SomeRandomClass', function () {
+
+        it('is instance of SomeRandomClass1', function () {
+            expect(new SomeRandomClass2).not.to.be.instanceOf(SomeRandomClass1);
+            expect(new SomeRandomClass2).to.be.instanceOf(SomeRandomClass2);
+        });
+
+        it('is instance of SomeRandomClass2', function () {
+            expect(new SomeRandomClass1).to.be.instanceOf(SomeRandomClass1);
+            expect(new SomeRandomClass1).not.to.be.instanceOf(SomeRandomClass2);
+        });
+
+    })
+
+    describe('Extends SomeRandomClass with internals', function () {
+
+        it('attach and notify internal observer', function (done) {
+            const c = new SomeRandomClass2;
+            c.attachInternalObserver(new Observer(() => {
+                done();
+            }));
+
+            c.setInternal("test", "test");
+
+        });
+
+        it('attach and remove internal observer', function () {
+            const c = new SomeRandomClass2;
+
+
+            const observer = new Observer(() => {
+
+            });
+
+            expect(c.containsInternalObserver(observer)).to.be.false;
+            c.attachInternalObserver(observer);
+            expect(c.containsInternalObserver(observer)).to.be.true;
+            c.detachInternalObserver(observer);
+            expect(c.containsInternalObserver(observer)).to.be.false;
+
+        });
+
+        it("getInternal and setInternal", function () {
+            const c = new SomeRandomClass2;
+            expect(c.setInternal("test", "yeah")).to.be.instanceOf(SomeRandomClass2);
+            expect(c.getInternal("test")).to.be.equal("yeah");
+        });
+
+        it("deal with default values", function () {
+            const testClass = class extends Object {
+                constructor() {
+                    super();
+                    equipWithInternal.call(this);
+                }
+
+                get internalDefaults() {
+                    return {
+                        test: "xyz"
+                    }
+                }
+            }
+
+
+            const c = new testClass;
+            expect(c.getInternal("test")).to.be.equal("xyz");
+            expect(c.getInternal("test2", "abc")).to.be.equal("abc");
+        });
+
+        it("deal with defaults from defaults", function () {
+            const testClass = class extends Object {
+                constructor() {
+                    super();
+                    equipWithInternal.call(this);
+                }
+
+                get internalDefaults() {
+                    return {
+                        test: "xyz"
+                    }
+                }
+            }
+
+            const testClass2 = class extends testClass {
+                constructor() {
+                    super();
+                    equipWithInternal.call(this);
+                }
+
+                get internalDefaults() {
+                    return Object.assign({}, super.internalDefaults, {
+                        test2: "abc"
+                    })
+                }
+            }
+
+            const c = new testClass2;
+            expect(c.getInternal("test")).to.be.equal("xyz");
+            expect(c.getInternal("test2")).to.be.equal("abc");
+        });
+        
+        it("set multiple values", function () {
+            const c = new SomeRandomClass2;
+            expect(c.setInternals({
+                test: "yeah",
+                test2: "yeah2"
+            })).to.be.instanceOf(SomeRandomClass2);
+            expect(c.getInternal("test")).to.be.equal("yeah");
+            expect(c.getInternal("test2")).to.be.equal("yeah2");
+            
+            c.setInternals({
+                test2: "yeah2-new",
+                test3: "yeah3"
+            });
+            
+            expect(c.getInternal("test")).to.be.equal("yeah");
+            expect(c.getInternal("test2")).to.be.equal("yeah2-new");
+            expect(c.getInternal("test3")).to.be.equal("yeah3");
+        });
+
+    });
+
+
+})