neo.mjs 4.0.51 → 4.0.52

package/buildScripts/createClass.mjs

@@ -1,24 +1,42 @@
-import chalk       from 'chalk';
-import { Command } from 'commander/esm.mjs';
-import envinfo     from 'envinfo';
-import fs          from 'fs-extra';
-import inquirer    from 'inquirer';
-import os          from 'os';
-import path        from 'path';
-
-const __dirname   = path.resolve(),
+#!/usr/bin/env node
+
+import chalk           from 'chalk';
+import { Command }     from 'commander/esm.mjs';
+import envinfo         from 'envinfo';
+import fs              from 'fs-extra';
+import inquirer        from 'inquirer';
+import os              from 'os';
+import path            from 'path';
+import {fileURLToPath} from 'url';
+
+const
+      __dirname   = fileURLToPath(new URL('../', import.meta.url)),
       cwd         = process.cwd(),
       requireJson = path => JSON.parse(fs.readFileSync((path))),
       packageJson = requireJson(path.join(__dirname, 'package.json')),
       insideNeo   = packageJson.name === 'neo.mjs',
       program     = new Command(),
       programName = `${packageJson.name} create-class`,
-      questions   = [];
+      questions   = [],
+      /**
+       * Maintain a list of dir-names recognized as source root directories.
+       * When not using dot notation with a class-name, the program assumes
+       * that we want to create the class inside the cwd. The proper namespace
+       * is then looked up by traversing the directory path up to the first
+       * folder that matches an entry in "sourceRootDirs". The owning
+       * folder (parent of cwd, child of sourceRootDirs[n]) will then be used as the
+       * namespace for this created class.
+       * Can be overwritten with the -s option.
+       * @type {string[]}
+       */
+      sourceRootDirs = ['apps'];
 
 program
     .name(programName)
     .version(packageJson.version)
     .option('-i, --info',              'print environment debug info')
+    .option('-d, --drop',              'drops class in the currently selected folder')
+    .option('-s, --source <value>',    `name of the folder containing the project. Defaults to any of ${sourceRootDirs.join(',')}`)
     .option('-b, --baseClass <value>')
     .option('-c, --className <value>')
     .allowUnknownOption()
@@ -33,7 +51,7 @@ const programOpts = program.opts();
 if (programOpts.info) {
     console.log(chalk.bold('\nEnvironment Info:'));
     console.log(`\n  current version of ${packageJson.name}: ${packageJson.version}`);
-    console.log(`  running from ${__dirname}`);
+    console.log(`  running from ${cwd}`);
 
     envinfo
         .run({
@@ -49,6 +67,28 @@ if (programOpts.info) {
 } else {
     console.log(chalk.green(programName));
 
+    if (programOpts.drop) {
+        // change source folder if the user wants to
+        if (programOpts.source) {
+            while (sourceRootDirs.length) {
+                sourceRootDirs.pop();
+            }
+            sourceRootDirs.push(programOpts.source);
+        }
+
+        if (!programOpts.className || !programOpts.baseClass) {
+            console.error(chalk.red('-d is non interactive. Please provide name base class, and optionally the source parent for the class to create'));
+            console.info(chalk.bgCyan('Usage: createClass -d -c <className> -b <baseClass> [-s sourceParent]'));
+            process.exit(1);
+        }
+
+        if (programOpts.className.indexOf('.') !== -1) {
+            console.error(chalk.red('No .dot-notation avcailable when -d option is selected.'));
+            console.info(chalk.bgCyan('Usage: createClass -d -c <className> -b <baseClass> [-s sourceParent]'));
+            process.exit(1);
+        }
+    }
+
     if (!programOpts.className) {
         questions.push({
             type   : 'input',
@@ -71,6 +111,7 @@ if (programOpts.info) {
     inquirer.prompt(questions).then(answers => {
         let baseClass = programOpts.baseClass || answers.baseClass,
             className = programOpts.className || answers.className,
+            isDrop    = programOpts.drop,
             startDate = new Date(),
             classFolder, file, folderDelta, index, ns, root, rootLowerCase, viewFile;
 
@@ -78,36 +119,97 @@ if (programOpts.info) {
             className = className.slice(0, -4);
         }
 
-        ns            = className.split('.');
-        file          = ns.pop();
-        root          = ns.shift();
-        rootLowerCase = root.toLowerCase();
+        if (!isDrop) {
+            ns            = className.split('.');
+            file          = ns.pop();
+            root          = ns.shift();
+            rootLowerCase = root.toLowerCase();
+        }
 
         if (root === 'Neo') {
             console.log('todo: create the file inside the src folder');
         } else {
-            if (fs.existsSync(path.resolve(cwd, 'apps', rootLowerCase))) {
-                classFolder = path.resolve(cwd, 'apps', rootLowerCase, ns.join('/'));
+            if (isDrop === true) {
+                ns = [];
+
+                let pathInfo = path.parse(cwd),
+                    sep      = path.sep,
+                    baseName, loc = baseName = '',
+                    tmpNs;
+
+                sourceRootDirs.some(dir => {
+                    loc   = cwd;
+                    tmpNs = [];
+
+                    while (pathInfo.root !== loc) {
+                        baseName = path.resolve(loc, './').split(sep).pop();
+
+                        if (baseName === dir) {
+                            ns          = tmpNs.reverse();
+                            classFolder = path.resolve(loc, ns.join(sep));
+                            file        = className;
+                            className   = ns.concat(className).join('.');
+                            loc         = path.resolve(loc, ns.join(sep));
+                            return true;
+                        }
+
+                        tmpNs.push(baseName);
+                        loc = path.resolve(loc, '../');
+                    }
+                });
+
+                if (!ns.length) {
+                    console.error(chalk.red(
+                        'Could not determine namespace for application. Did you provide the ' +
+                            `correct source parent with -s? (was: ${sourceRootDirs.join(',')}`));
+                    process.exit(1);
+                }
+
+                console.info(
+                    chalk.yellow(`Creating ${chalk.bgGreen(className)} extending ${chalk.bgGreen(baseClass)} in ${loc}${sep}${file}.mjs`)
+                );
+
+                let delta_l = path.normalize(__dirname),
+                    delta_r = path.normalize(loc);
+
+                if (delta_r.indexOf(delta_l) !== 0) {
+                    console.error(chalk.red(`Could not determine ${loc} being a child of ${__dirname}`));
+                    process.exit(1);
+                }
+
+                let delta = delta_r.replace(delta_l, ''),
+                    parts = delta.split(sep);
+
+                folderDelta = parts.length;
+            }
+
+            if (isDrop !== true) {
+                if (fs.existsSync(path.resolve(__dirname, 'apps', rootLowerCase))) {
+                    classFolder = path.resolve(__dirname, 'apps', rootLowerCase, ns.join('/'));
+                } else {
+                    console.log('\nNon existing neo app name:', chalk.red(root));
+                    process.exit(1);
+                }
+            }
+
+            if (folderDelta === undefined) {
                 folderDelta = ns.length + 2;
+            }
 
-                fs.mkdirpSync(classFolder);
+            fs.mkdirpSync(classFolder);
 
-                fs.writeFileSync(path.join(classFolder, file + '.mjs'), createContent({baseClass, className, file, folderDelta, ns, root}));
+            fs.writeFileSync(path.join(classFolder, file + '.mjs'), createContent({baseClass, className, file, folderDelta, ns, root}));
 
-                if (baseClass === 'controller.Component') {
-                    index = file.indexOf('Controller');
+            if (baseClass === 'controller.Component') {
+                index = file.indexOf('Controller');
 
-                    if (index > 0) {
-                        viewFile = path.join(classFolder, file.substr(0, index) + '.mjs');
+                if (index > 0) {
+                    viewFile = path.join(classFolder, file.substr(0, index) + '.mjs');
 
-                        if (fs.existsSync(viewFile)) {
-                            adjustView({file, viewFile});
-                        }
+                    if (fs.existsSync(viewFile)) {
+                        adjustView({file, viewFile});
                     }
                 }
-            } else {
-                console.log('\nNon existing neo app name:', chalk.red(root));
-                process.exit(1);
             }
         }
 

package/examples/form/field/text/MainContainer.mjs

@@ -97,6 +97,22 @@ class MainContainer extends ConfigurationViewport {
             minValue : 50,
             stepSize : 5,
             value    : me.exampleComponent.labelWidth
+        }, {
+            module   : NumberField,
+            labelText: 'maxLength',
+            listeners: {change: me.onConfigChange.bind(me, 'maxLength')},
+            maxValue : 50,
+            minValue : 1,
+            stepSize : 1,
+            value    : me.exampleComponent.maxLength
+        }, {
+            module   : NumberField,
+            labelText: 'minLength',
+            listeners: {change: me.onConfigChange.bind(me, 'minLength')},
+            maxValue : 50,
+            minValue : 1,
+            stepSize : 1,
+            value    : me.exampleComponent.minLength
         }, {
             module   : TextField,
             clearable: true,

package/package.json

@@ -1,12 +1,15 @@
 {
     "name": "neo.mjs",
-    "version": "4.0.51",
+    "version": "4.0.52",
     "description": "The webworkers driven UI framework",
     "type": "module",
     "repository": {
         "type": "git",
         "url": "https://github.com/neomjs/neo.git"
     },
+    "bin": {
+        "neo-cc": "./buildScripts/createClass.mjs"
+    },
     "scripts": {
         "build-all": "node ./buildScripts/buildAll.mjs -f -n",
         "build-all-questions": "node ./buildScripts/buildAll.mjs -f",
@@ -51,7 +54,7 @@
         "neo-jsdoc": "^1.0.1",
         "neo-jsdoc-x": "^1.0.4",
         "postcss": "^8.4.14",
-        "sass": "^1.52.3",
+        "sass": "^1.53.0",
         "webpack": "^5.73.0",
         "webpack-cli": "^4.10.0",
         "webpack-dev-server": "4.9.2",
@@ -59,7 +62,8 @@
         "webpack-node-externals": "^3.0.0"
     },
     "devDependencies": {
-        "siesta-lite": "^5.5.2"
+        "siesta-lite": "^5.5.2",
+        "url": "^0.11.0"
     },
     "funding": {
         "type": "GitHub Sponsors",

package/src/data/RecordFactory.mjs

@@ -28,9 +28,9 @@ class RecordFactory extends Base {
          */
         ovPrefix: 'ov_',
         /**
-         * @member {String} recordNamespace='Neo.data.record.'
+         * @member {String} recordNamespace='Neo.data.record'
          */
-        recordNamespace: 'Neo.data.record.'
+        recordNamespace: 'Neo.data.record'
     }}
 
     /**
@@ -39,7 +39,7 @@ class RecordFactory extends Base {
      * @returns {Object}
      */
     createRecord(model, config) {
-        let recordClass = Neo.ns(this.recordNamespace + model.className);
+        let recordClass = Neo.ns(`${this.recordNamespace}.${model.className}.${model.id}`);
 
         if (!recordClass) {
             recordClass = this.createRecordClass(model);
@@ -54,7 +54,7 @@ class RecordFactory extends Base {
      */
     createRecordClass(model) {
         if (model instanceof Model) {
-            let className = this.recordNamespace + model.className,
+            let className = `${this.recordNamespace}.${model.className}.${model.id}`,
                 ns        = Neo.ns(className),
                 key, nsArray;
 
@@ -76,7 +76,7 @@ class RecordFactory extends Base {
 
                         if (Array.isArray(model.fields)) {
                             model.fields.forEach(field => {
-                                let parsedValue = instance.parseRecordValue(field, config[field.name], config),
+                                let parsedValue = instance.parseRecordValue(me, field, config[field.name], config),
                                     symbol      = Symbol.for(field.name);
 
                                 properties = {
@@ -97,9 +97,9 @@ class RecordFactory extends Base {
                                             let me       = this,
                                                 oldValue = me[symbol];
 
-                                            if (!Neo.isEqual(value, oldValue)) {
-                                                value = instance.parseRecordValue(field, value, null);
+                                            value = instance.parseRecordValue(me, field, value);
 
+                                            if (!Neo.isEqual(value, oldValue)) {
                                                 me[symbol] = value;
 
                                                 me._isModified = true;
@@ -221,14 +221,18 @@ class RecordFactory extends Base {
 
     /**
      * todo: parse value for more field types
+     * @param {Object} record
      * @param {Object} field
      * @param {*} value
-     * @param {Object} recordConfig
+     * @param {Object} recordConfig=null
      * @returns {*}
      */
-    parseRecordValue(field, value, recordConfig) {
-        let mapping = field.mapping,
-            type    = field.type?.toLowerCase();
+    parseRecordValue(record, field, value, recordConfig=null) {
+        let mapping   = field.mapping,
+            maxLength = field.maxLength,
+            minLength = field.minLength,
+            oldValue  = recordConfig?.[field.name] || record[field.name],
+            type      = field.type?.toLowerCase();
 
         // only trigger mappings for initial values
         // dynamic changes of a field will not pass the recordConfig
@@ -240,7 +244,21 @@ class RecordFactory extends Base {
             value = ns[key];
         }
 
-        if (type === 'date') {
+        if (Object.hasOwn(field, maxLength)) {
+            if (value?.toString() > maxLength) {
+                console.warn(`Setting record field: ${field} value: ${value} conflicts with the maxLength: ${maxLength}`);
+                return oldValue;
+            }
+        }
+
+        if (Object.hasOwn(field, minLength)) {
+            if (value?.toString() < minLength) {
+                console.warn(`Setting record field: ${field} value: ${value} conflicts with the minLength: ${minLength}`);
+                return oldValue;
+            }
+        }
+
+        if (type === 'date' && Neo.typeOf(value) !== 'Date') {
             return new Date(value);
         }
 
@@ -259,6 +277,7 @@ class RecordFactory extends Base {
 
         Object.entries(fields).forEach(([key, value]) => {
             oldValue = record[key];
+            value    = instance.parseRecordValue(record, model.getField(key), value);
 
             if (!Neo.isEqual(oldValue, value)) {
                 record[Symbol.for(key)] = value; // silent update

package/src/form/field/Number.mjs

@@ -237,12 +237,13 @@ class Number extends Text {
      */
     onSpinButtonDownClick() {
         let me       = this,
-            oldValue = me.value || (me.maxValue + me.stepSize),
-            value    = Math.max(me.minValue, oldValue - me.stepSize);
+            stepSize = me.stepSize,
+            oldValue = Neo.isNumber(me.value) ? me.value : me.minValue,
+            value    = (oldValue - stepSize) < me.minValue ? me.maxValue : (oldValue - stepSize);
 
         if (me.excludedValues) {
             while(me.excludedValues.includes(value)) {
-                value = Math.max(me.minValue, value - me.stepSize);
+                value = Math.max(me.minValue, value - stepSize);
             }
         }
 
@@ -256,12 +257,13 @@ class Number extends Text {
      */
     onSpinButtonUpClick() {
         let me       = this,
-            oldValue = me.value || (me.minValue - me.stepSize),
-            value    = Math.min(me.maxValue, oldValue + me.stepSize);
+            stepSize = me.stepSize,
+            oldValue = Neo.isNumber(me.value) ? me.value : me.maxValue,
+            value    = (oldValue + stepSize) > me.maxValue ? me.minValue : (oldValue + stepSize);
 
         if (me.excludedValues) {
             while(me.excludedValues.includes(value)) {
-                value = Math.min(me.maxValue, value + me.stepSize);
+                value = Math.min(me.maxValue, value + stepSize);
             }
         }
 

package/src/main/mixin/DeltaUpdates.mjs

@@ -186,11 +186,15 @@ class DeltaUpdates extends Base {
                                 }
                             } else if (key === 'id') {
                                 node[Neo.config.useDomIds ? 'id' : 'data-neo-id'] = val;
-                            }else if (key === 'spellcheck' && val === 'false') {
+                            } else if (key === 'spellcheck' && val === 'false') {
                                 // see https://github.com/neomjs/neo/issues/1922
                                 node[key] = false;
                             } else {
-                                node[key] = val;
+                                if (key === 'value') {
+                                    node[key] = val;
+                                } else {
+                                    node.setAttribute(key, val);
+                                }
                             }
                         });
                         break;

package/src/table/Container.mjs

@@ -247,9 +247,9 @@ class Container extends BaseContainer {
         }
 
         if (value) {
-            let me = this;
+            let me = this,
 
-            const listeners = {
+            listeners = {
                 filter      : me.onStoreFilter,
                 load        : me.onStoreLoad,
                 recordChange: me.onStoreRecordChange,
@@ -258,13 +258,10 @@ class Container extends BaseContainer {
 
             if (value instanceof Store) {
                 value.on(listeners);
-
-                if (value.getCount() > 0) {
-                    me.onStoreLoad(value.items);
-                }
+                value.getCount() > 0 && me.onStoreLoad(value.items);
             } else {
                 value = ClassSystemUtil.beforeSetInstance(value, Store, {
-                    listeners: listeners
+                    listeners
                 });
             }