neo.mjs 5.1.0 → 5.1.1

package/apps/ServiceWorker.mjs

@@ -20,9 +20,9 @@ class ServiceWorker extends ServiceBase {
          */
         singleton: true,
         /**
-         * @member {String} version='5.1.0'
+         * @member {String} version='5.1.1'
          */
-        version: '5.1.0'
+        version: '5.1.1'
     }
 
     /**

package/apps/realworld/view/HomeComponent.mjs

@@ -62,26 +62,26 @@ class HomeComponent extends Component {
          * @member {Object} _vdom
          */
         _vdom:
-            {cn: [
-                {cls: ['banner'], cn: [
-                    {cls: ['container'], cn: [
-                        {tag: 'h1', cls: ['logo-font'], html: 'conduit'},
-                        {tag: 'p', html: 'A place to share your knowledge.'}
-                    ]}
-                ]},
-                {cls: ['container', 'page'], cn: [
-                    {cls: ['row'], cn: [
-                        {cls: ['col-md-9'], cn: [
-                            {cls: ['feed-toggle'], cn: [
-                                {tag: 'ul', cls: ['nav', 'nav-pills', 'outline-active'], flag: 'feed-header', cn: []}
-                            ]},
-                            {tag: 'nav', cn: [
-                                {tag: 'ul', cls: ['pagination'], flag: 'pagination'}
-                            ]}
+        {cn: [
+            {cls: ['banner'], cn: [
+                {cls: ['container'], cn: [
+                    {tag: 'h1', cls: ['logo-font'], html: 'conduit'},
+                    {tag: 'p', html: 'A place to share your knowledge.'}
+                ]}
+            ]},
+            {cls: ['container', 'page'], cn: [
+                {cls: ['row'], cn: [
+                    {cls: ['col-md-9'], cn: [
+                        {cls: ['feed-toggle'], cn: [
+                            {tag: 'ul', cls: ['nav', 'nav-pills', 'outline-active'], flag: 'feed-header', cn: []}
+                        ]},
+                        {tag: 'nav', cn: [
+                            {tag: 'ul', cls: ['pagination'], flag: 'pagination'}
                         ]}
                     ]}
                 ]}
             ]}
+        ]}
     }
 
     /**

package/apps/realworld/view/MainContainerController.mjs

@@ -11,6 +11,13 @@ import UserApi             from '../api/User.mjs';
  * @extends Neo.controller.Component
  */
 class MainContainerController extends ComponentController {
+    /**
+     * True automatically applies the core.Observable mixin
+     * @member {Boolean} observable=false
+     * @static
+     */
+    static observable = true
+
     static config = {
         /**
          * @member {String} className='RealWorld.view.MainContainerController'

package/examples/ServiceWorker.mjs

@@ -20,9 +20,9 @@ class ServiceWorker extends ServiceBase {
          */
         singleton: true,
         /**
-         * @member {String} version='5.1.0'
+         * @member {String} version='5.1.1'
          */
-        version: '5.1.0'
+        version: '5.1.1'
     }
 
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "neo.mjs",
-    "version": "5.1.0",
+    "version": "5.1.1",
     "description": "The webworkers driven UI framework",
     "type": "module",
     "repository": {

package/src/DefaultConfig.mjs

@@ -237,12 +237,12 @@ const DefaultConfig = {
     useVdomWorker: true,
     /**
      * buildScripts/injectPackageVersion.mjs will update this value
-     * @default '5.1.0'
+     * @default '5.1.1'
      * @memberOf! module:Neo
      * @name config.version
      * @type String
      */
-    version: '5.1.0'
+    version: '5.1.1'
 };
 
 Object.assign(DefaultConfig, {

package/src/Neo.mjs

@@ -70,13 +70,13 @@ Neo = globalThis.Neo = Object.assign({
 
         protos.forEach(element => {
             let mixins;
-              
+
             ctor = element.constructor;
 
             cfg = ctor.config || {};
             
-            if (Neo.overrides) {
-                ctor.applyOverrides(cfg);
+            if (Neo.overwrites) {
+                ctor.applyOverwrites(cfg);
             }
 
             Object.entries(cfg).forEach(([key, value]) => {

package/src/container/Base.mjs

@@ -215,6 +215,7 @@ class Base extends Component {
 
             case 'NeoInstance': {
                 item.set(config);
+                item.getController()?.parseConfig(item);
                 break;
             }
 

package/src/controller/Component.mjs

@@ -141,6 +141,7 @@ class Component extends Base {
         let me        = this,
             listeners = component.listeners,
             reference = component.reference,
+            validator = component.validator,
             eventHandler, handlerScope;
 
         if (listeners) {
@@ -174,6 +175,16 @@ class Component extends Base {
             });
         }
 
+        if (Neo.isString(validator)) {
+            handlerScope = me.getHandlerScope(validator);
+
+            if (!handlerScope) {
+                Logger.logError('Unknown validator for', component.id, component);
+            } else {
+                component.validator = handlerScope[validator].bind(handlerScope);
+            }
+        }
+
         if (reference) {
             me.references[reference] = component;
         }

package/src/core/Base.mjs

@@ -23,10 +23,10 @@ class Base {
      */
     static observable = false
     /**
-     * Keep the overriden methods
+     * Keep the overwritten methods
      * @type {Object}
      */
-    static overriddenMethods = {}
+    static overwrittenMethods = {}
 
     /**
      * Set this one to false in case you don't want to stick
@@ -150,29 +150,29 @@ class Base {
     }
 
     /**
-     * Applying overrides and adding overriddenMethods to the class constructors
+     * Applying overwrites and adding overwrittenMethods to the class constructors
      * @param {Object} cfg
      * @protected
      */
-    static applyOverrides(cfg) {
-        let overrides = Neo.ns(cfg.className, false, Neo.overrides),
+    static applyOverwrites(cfg) {
+        let overwrites = Neo.ns(cfg.className, false, Neo.overwrites),
             cls, item;
 
-        if (overrides) {
+        if (overwrites) {
             // Apply all methods
-            for (item in overrides) {
-                if (Neo.isFunction(overrides[item])) {
+            for (item in overwrites) {
+                if (Neo.isFunction(overwrites[item])) {
                     // Already existing ones
                     cls = this.prototype;
 
                     if (cls[item]) {
-                        // add to overriddenMethods
-                        cls.constructor.overriddenMethods[item] = cls[item];
+                        // add to overwrittenMethods
+                        cls.constructor.overwrittenMethods[item] = cls[item];
                     }
                 }
             }
             // Apply configs to prototype
-            overrides && Object.assign(cfg, overrides);
+            overwrites && Object.assign(cfg, overwrites);
         }
     }
 
@@ -196,12 +196,12 @@ class Base {
     }
 
     /**
-     * From within an override, a method can call a parent method, by using callOVerridden.
+     * From within an overwrite, a method can call a parent method, by using callOverwritten.
      *
      * @example
      *    afterSetHeight(value, oldValue) {
      *        // do the standard
-     *        this.callOverridden(...arguments);
+     *        this.callOverwritten(...arguments);
      *        // do you own stuff
      *    }
      *
@@ -209,17 +209,17 @@ class Base {
      * This is based on the following error structure, e.g. afterSetHeight.
      *
      *     Error
-     *         at Base.callOverridden (Base.mjs:176:21)
+     *         at Base.callOverwritten (Base.mjs:176:21)
      *         at Base.afterSetHeight (Overrides.mjs:19:26)
      *
      * @param args
      */
-    callOverridden(...args) {
+    callOverwritten(...args) {
         let stack      = new Error().stack,
             regex      = Base.methodNameRegex,
             methodName = stack.match(regex)[1];
 
-        this.__proto__.constructor.overriddenMethods[methodName].call(this, ...args);
+        this.__proto__.constructor.overwrittenMethods[methodName].call(this, ...args);
     }
 
     /**

package/src/core/Observable.mjs

@@ -148,8 +148,10 @@ class Observable extends Base {
         }
 
         while (proto?.constructor.isClass) {
+            ctor = proto.constructor;
+
             if (ctor.observable && !ctor.listeners) {
-                Object.assign(proto.constructor, {
+                Object.assign(ctor, {
                     addListener   : me.addListener,
                     fire          : me.fire,
                     listeners     : {},

package/src/form/field/Text.mjs

@@ -158,6 +158,11 @@ class Text extends Base {
          * @member {Object|Object[]|null} triggers_=null
          */
         triggers_: null,
+        /**
+         * A string based value will get resolved into the closest controller which implements it
+         * @member {Function|String|null} validator=null
+         */
+        validator: null,
         /**
          * @member {Object} _vdom
          */
@@ -1289,9 +1294,17 @@ class Text extends Base {
             value       = me.value,
             valueLength = value?.toString().length,
             isEmpty     = !value || valueLength < 1,
-            errorParam  = {maxLength, minLength, valueLength};
+            errorParam  = {maxLength, minLength, valueLength},
+            errorText;
+
+        if (Neo.isFunction(me.validator)) {
+            errorText = me.validator(me);
 
-        if (required && isEmpty) {
+            if (errorText !== true) {
+                me[errorField] = errorText;
+                returnValue = false;
+            }
+        } else if (required && isEmpty) {
             me[errorField] = me.errorTextRequired;
             returnValue = false;
         } else if (Neo.isNumber(maxLength) && valueLength > maxLength) {