@schukai/monster 3.14.1 → 3.16.0

package/package.json

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

package/source/data/transformer.mjs

@@ -5,6 +5,7 @@
  * License text available at https://www.gnu.org/licenses/agpl-3.0.en.html
  */
 
+import {getLocaleOfDocument} from "../dom/locale.mjs";
 import {Base} from "../types/base.mjs";
 import {getGlobal, getGlobalObject} from "../types/global.mjs";
 import {ID} from "../types/id.mjs";
@@ -169,6 +170,11 @@ function transform(value) {
     let element;
     let attribute;
     let translations;
+    let date;
+    let locale;
+    let timestamp;
+    let map;
+    let keyValue;
 
     switch (this.command) {
         case "static":
@@ -405,25 +411,25 @@ function transform(value) {
                 if (key === undefined) {
                     throw new Error("missing key parameter");
                 }
-                
+
                 // add empty strings
-                if (isString(key)&&key.trim()==="") {
-                    concat += key; 
+                if (isString(key) && key.trim() === "") {
+                    concat += key;
                     continue;
                 }
-                
+
                 if (!pf2.exists(key)) {
                     concat += key;
                     continue;
                 }
                 let v = pf2.getVia(key);
-                if(!isPrimitive(v)) {
+                if (!isPrimitive(v)) {
                     throw new Error("value is not primitive");
                 }
 
                 concat += v;
             }
-            
+
             return concat;
         case "path":
             key = args.shift();
@@ -491,6 +497,117 @@ function transform(value) {
 
             throw new Error("type not supported");
 
+            
+        case "map":
+            map = new Map();
+            while (args.length > 0) {
+                keyValue = args.shift();
+                if (keyValue === undefined) {
+                    throw new Error("missing key parameter");
+                }
+                
+                keyValue = keyValue.split("=");
+                map.set(keyValue[0], keyValue[1]);
+            }
+            
+            return map.get(value);
+            
+        case "timestamp":
+            date = new Date(value);
+            timestamp = date.getTime();
+            if (isNaN(timestamp)) {
+                throw new Error("invalid date");
+            }
+            return timestamp;
+
+        case "time":
+            date = new Date(value);
+            if (isNaN(date.getTime())) {
+                throw new Error("invalid date");
+            }
+
+            try {
+                locale = getLocaleOfDocument();
+                return date.toLocaleTimeString(locale);
+
+            } catch (e) {
+                throw new Error("unsupported locale or missing format (" + e.message + ")");
+            }
+
+
+        case "year":
+            date = new Date(value);
+            if (isNaN(date.getTime())) {
+                throw new Error("invalid date");
+            }
+
+            return date.getFullYear();
+
+        case "month":
+            date = new Date(value);
+            if (isNaN(date.getTime())) {
+                throw new Error("invalid date");
+            }
+
+            return date.getMonth() + 1;
+
+        case "day":
+            date = new Date(value);
+            if (isNaN(date.getTime())) {
+                throw new Error("invalid date");
+            }
+
+            return date.getDate();
+
+        case "weekday":
+            date = new Date(value);
+            if (isNaN(date.getTime())) {
+                throw new Error("invalid date");
+            }
+
+            return date.getDay();
+
+        case "hour":
+        case "hours":
+            date = new Date(value);
+            if (isNaN(date.getTime())) {
+                throw new Error("invalid date");
+            }
+
+            return date.getHours();
+
+        case "minute":
+        case "minutes":
+            date = new Date(value);
+            if (isNaN(date.getTime())) {
+                throw new Error("invalid date");
+            }
+
+            return date.getMinutes();
+
+        case "second":
+        case "seconds":
+            date = new Date(value);
+            if (isNaN(date.getTime())) {
+                throw new Error("invalid date");
+            }
+
+            return date.getSeconds();
+
+        case "date":
+            date = new Date(value);
+            if (isNaN(date.getTime())) {
+                throw new Error("invalid date");
+            }
+
+            try {
+                locale = getLocaleOfDocument();
+                return date.toLocaleDateString(locale);
+
+            } catch (e) {
+                throw new Error("unsupported locale or missing format (" + e.message + ")");
+            }
+
         case "i18n":
         case "translation":
             translations = getDocumentTranslations();

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.16.0");
 
     return monsterVersion;
 }

package/test/cases/data/transformer.mjs

@@ -27,6 +27,17 @@ describe('Transformer', function () {
     describe('Transformer.run()', function () {
 
         [
+            ['map:a=4:b=5:c=6', "a", "4"],
+            ['date', "2023-02-14", "14.2.2023"],
+            ['year', "2023-02-14", 2023],
+            ['month', "2023-02-14", 2],
+            ['day', "2023-02-14", 14],
+            ['weekday', "2023-02-14", 2],
+            ['minutes', "2023-02-14 06:12:21", 12],
+            ['seconds', "2023-02-14 06:12:21", 21],
+            ['hours', "2023-02-14 06:12:21", 6],
+            ['time', "2023-02-14 06:12:21", "06:12:21"],
+            ['timestamp', "2023-02-14", 1676332800000],
             ['concat:a.b.c:test:a.b.d', {a: {b: {c: 4, d: 6}}}, "4test6"],
             ['concat:a.b.c:\\ \\ :a.b.d', {a: {b: {c: 4, d: 6}}}, "4  6"],
             ['concat:a.b.c:,:a.b.d', {a: {b: {c: 4, d: 6}}}, "4,6"],

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.16.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");
+        });
+
+    });
+
+
+})