npm - lightview - Versions diffs - 1.6.3-b → 1.6.4-b - Mend

lightview 1.6.3-b → 1.6.4-b

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (7) hide show

package/README.md CHANGED Viewed

@@ -1,4 +1,4 @@
-# lightview v1.6.3b (BETA)
+# lightview v1.6.4b (BETA)
 Small, simple, powerful web UI and micro front end creation ...

package/jest.config.json CHANGED Viewed

@@ -9,4 +9,4 @@
   "globalSetup": "jest-environment-puppeteer/setup",
   "globalTeardown": "jest-environment-puppeteer/teardown",
   "testEnvironment": "jest-environment-puppeteer"
-}
+}

package/lightview.js CHANGED Viewed

@@ -241,10 +241,13 @@ const {observe} = (() => {
                 const variable = target[property],
                     {type, value, shared, exported, constant, reactive, remote} = variable;
                 if (constant) throw new TypeError(`${property}:${type} is a constant`);
-                newValue = type.validate ? type.validate(newValue,target[property]) : coerce(newValue,type);
+                if(newValue!=null || type.required) newValue = type.validate ? type.validate(newValue,target[property]) : coerce(newValue,type);
                 const newtype = typeof (newValue),
                     typetype = typeof (type);
-                if (newValue == null || type === "any" || (newtype === type && typetype==="string") || (typetype === "function" && (newValue && newtype === "object" && newValue instanceof type) || variable.validityState?.valid)) {
+                if ((newValue == null && !type.required) ||
+                    type === "any" ||
+                    (newtype === type && typetype==="string") ||
+                    (typetype === "function" && !type.validate && (newValue && newtype === "object" && newValue instanceof type) || variable.validityState?.valid)) {
                     if (value !== newValue) {
                         event.oldValue = value;
                         target[property].value = reactive ? Reactor(newValue) : newValue; // do first to prevent loops
@@ -260,7 +263,7 @@ const {observe} = (() => {
                 if (typetype === "function" && newValue && newtype === "object") {
                     throw new TypeError(`Can't assign instance of '${newValue.constructor.name}' to variable '${property}:${type.name.replace("bound ", "")}'`)
                 }
-                throw new TypeError(`Can't assign '${typeof (newValue)} ${newtype === "string" ? '"' + newValue + '"' : newValue}' to variable '${property}:${typetype === "function" ? type.name.replace("bound ", "") : type}'`)
+                throw new TypeError(`Can't assign '${typeof (newValue)} ${newtype === "string" ? '"' + newValue + '"' : newValue}' to variable '${property}:${typetype === "function" ? type.name.replace("bound ", "") : type} ${type.required ? "required" : ""}'`)
             },
             keys() {
                 return [...Object.keys(vars)];
@@ -339,7 +342,7 @@ const {observe} = (() => {
         }
         return nodes;
     }
-    const AsyncFunction = Object.getPrototypeOf(async function(){}).constructor;
     const resolveNodeOrText = (node, component, safe) => {
         const type = typeof (node),
             template = type === "string" ? node.trim() : node.template;
@@ -782,7 +785,7 @@ const {observe} = (() => {
                                 variable.remote = remote;
                                 remote.handleRemote({variable, config:remote.config, reactive,component:this});
                             }
-                            if(type.validate) type.validate(variable.value,variable);
+                            if(type.validate && variable.value!==undefined) type.validate(variable.value,variable);
                         });
                 }
                 return Object.entries(this.vars)

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "lightview",
-  "version": "1.6.3b",
+  "version": "1.6.4b",
   "description": "Small, simple, powerful web UI and micro front end creation ... Great ideas from Svelte, React, Vue and Riot combined.",
   "main": "lightview.js",
   "scripts": {

package/test/extended.html ADDED Viewed

@@ -0,0 +1,29 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <title>Extended</title>
+    <script src="../lightview.js?as=x-body"></script>
+</head>
+<body>
+<script type="lightview/module">
+const {array,boolean,number,object,string} = await import("../types.js");
+self.variables({strictarray:array},{set:[]});
+self.variables({strictboolean:boolean},{set:true});
+self.variables({strictnumber:number},{set:0});
+self.variables({strictobject:object},{set:{}});
+self.variables({strictstring:string},{set:"test"});
+self.variables({requiredarray:array({required:true})});
+self.variables({requiredboolean:boolean({required:true})});
+self.variables({requirednumber:number({required:true})});
+self.variables({requiredobject:object({required:true})});
+self.variables({requiredstring:string({required:true})});
+//self.setVariableValue("requirednumber",null);
+</script>
+</body>
+</html>

package/test/extended.test.mjs ADDED Viewed

@@ -0,0 +1,270 @@
+import 'expect-puppeteer';
+function reviver(property,value) {
+    if(value==="@-Infinity") return -Infinity;
+    if(value==="@Infinity") return Infinity;
+    if(value==="@NaN") return NaN;
+    return value;
+}
+describe('Lightview - Variables', () => {
+    beforeAll(async () => {
+        await page.goto('http://localhost:8080/test/extended.html');
+    });
+    test('should be titled "Extended"', async () => {
+        await expect(page.title()).resolves.toMatch('Extended');
+    });
+    test('strictarray - should be array', async () => {
+        const result = await page.evaluate(() => {
+            return document.body.getVariableValue("strictarray")
+        });
+        expect(Array.isArray(result)).toBe(true);
+    });
+    test('strictarray - should set', async () => {
+        const result = await page.evaluate(() => {
+            try {
+                document.body.setVariableValue("strictarray",[]);
+            } catch(e) {
+                return e;
+            }
+            return document.body.getVariableValue("strictarray")
+        });
+        expect(Array.isArray(result)).toBe(true);
+    });
+    test('strictarray - should allow null', async () => {
+        const result = await page.evaluate(() => {
+            try {
+                document.body.setVariableValue("strictarray",undefined);
+                document.body.setVariableValue("strictarray",null);
+            } catch(e) {
+                return e;
+            }
+            return document.body.getVariableValue("strictarray")
+        });
+        expect(result).toBe(null);
+    });
+    test('strictarray - should throw', async () => {
+        const result = await page.evaluate(() => {
+            try {
+                document.body.setVariableValue("strictarray","false");
+            } catch(e) {
+                return e.message;
+            }
+            return document.body.getVariableValue("strictarray");
+        });
+        const {name,validityState} = JSON.parse(result,reviver);
+        expect(name).toBe("strictarray");
+        expect(validityState.typeMismatch).toBe(true);
+        expect(validityState.value).toBe("false");
+    });
+    test('strictboolean - should be boolean', async () => {
+        const result = await page.evaluate(() => {
+            return document.body.getVariableValue("strictboolean")
+        });
+        expect(result).toBe(true);
+    });
+    test('strictboolean - should set', async () => {
+        const result = await page.evaluate(() => {
+            try {
+                document.body.setVariableValue("strictboolean",false);
+            } catch(e) {
+                return e.message;
+            }
+            return document.body.getVariableValue("strictboolean")
+        });
+        expect(result).toBe(false);
+    });
+    test('strictboolean - should allow null', async () => {
+        const result = await page.evaluate(() => {
+            try {
+                document.body.setVariableValue("strictboolean",undefined);
+                document.body.setVariableValue("strictboolean",null);
+            } catch(e) {
+                return e.message;
+            }
+            return document.body.getVariableValue("strictboolean")
+        });
+        expect(result).toBe(null);
+    });
+    test('strictboolean - should throw', async () => {
+        const result = await page.evaluate(() => {
+            try {
+                document.body.setVariableValue("strictboolean","true");
+            } catch(e) {
+                return e.message;
+            }
+            return document.body.getVariableValue("strictboolean");
+        });
+        const {name,validityState} = JSON.parse(result,reviver);
+        expect(name).toBe("strictboolean");
+        expect(validityState.typeMismatch).toBe(true);
+        expect(validityState.value).toBe("true");
+    });
+    test('strictnumber - should be number', async () => {
+        const result = await page.evaluate(() => {
+            return document.body.getVariableValue("strictnumber")
+        });
+        expect(result).toBe(0);
+    });
+    test('strictnumber - should set', async () => {
+        const result = await page.evaluate(() => {
+            try {
+                document.body.setVariableValue("strictnumber",1);
+            } catch(e) {
+                return e.message;
+            }
+            return document.body.getVariableValue("strictnumber")
+        });
+        expect(result).toBe(1);
+    });
+    test('strictnumber - should allow null', async () => {
+        const result = await page.evaluate(() => {
+            try {
+                document.body.setVariableValue("strictnumber",undefined);
+                document.body.setVariableValue("strictnumber",null);
+            } catch(e) {
+                return e.message;
+            }
+            return document.body.getVariableValue("strictnumber")
+        });
+        expect(result).toBe(null);
+    });
+    test('strictnumber - should throw', async () => {
+        const result = await page.evaluate(() => {
+            try {
+                document.body.setVariableValue("strictnumber","0");
+            } catch(e) {
+                return e.message;
+            }
+            return document.body.getVariableValue("strictnumber");
+        });
+        const {name,validityState} = JSON.parse(result,reviver);
+        expect(name).toBe("strictnumber");
+        expect(validityState.typeMismatch).toBe(true);
+        expect(validityState.value).toBe("0");
+    });
+    test('strictobject - should be object', async () => {
+        const result = await page.evaluate(() => {
+            return document.body.getVariableValue("strictobject")
+        });
+        expect(typeof(result)).toBe("object");
+        expect(Object.keys(result).length).toBe(0);
+    });
+    test('strictobject - should set', async () => {
+        const result = await page.evaluate(() => {
+            try {
+                document.body.setVariableValue("strictobject", {test:"test"});
+            } catch(e) {
+                return e.message;
+            }
+            return document.body.getVariableValue("strictobject")
+        });
+        expect(typeof(result)).toBe("object");
+        expect(Object.keys(result).length).toBe(1);
+        expect(result.test).toBe("test");
+    });
+    test('strictobject - should allow null', async () => {
+        const result = await page.evaluate(() => {
+            try {
+                document.body.setVariableValue("strictobject",undefined);
+                document.body.setVariableValue("strictobject",null);
+            } catch(e) {
+                return e.message;
+            }
+            return document.body.getVariableValue("strictobject")
+        });
+        expect(result).toBe(null);
+    });
+    test('strictobject - should throw', async () => {
+        const result = await page.evaluate(() => {
+            try {
+                document.body.setVariableValue("strictobject","false");
+            } catch(e) {
+                return e.message;
+            }
+            return document.body.getVariableValue("strictobject");
+        });
+        const {name,validityState} = JSON.parse(result,reviver);
+        expect(name).toBe("strictobject");
+        expect(validityState.typeMismatch).toBe(true);
+        expect(validityState.value).toBe("false");
+    });
+    test('strictstring - should be string', async () => {
+        const result = await page.evaluate(() => {
+            return document.body.getVariableValue("strictstring")
+        });
+        expect(result).toBe("test");
+    });
+    test('strictstring - should set', async () => {
+        const result = await page.evaluate(() => {
+            try {
+                document.body.setVariableValue("strictstring","anothertest");
+            } catch(e) {
+                return e.message;
+            }
+            return document.body.getVariableValue("strictstring")
+        });
+        expect(result).toBe("anothertest");
+    });
+    test('strictstring - should allow null', async () => {
+        const result = await page.evaluate(() => {
+            try {
+                document.body.setVariableValue("strictstring",undefined);
+                document.body.setVariableValue("strictstring",null);
+            } catch(e) {
+                return e.message;
+            }
+            return document.body.getVariableValue("strictstring")
+        });
+        expect(result).toBe(null);
+    });
+    test('strictstring - should throw', async () => {
+        const result = await page.evaluate(() => {
+            try {
+                document.body.setVariableValue("strictstring",0);
+            } catch(e) {
+                return e.message;
+            }
+            return document.body.getVariableValue("strictstring");
+        });
+        const {name,validityState} = JSON.parse(result,reviver);
+        expect(name).toBe("strictstring");
+        expect(validityState.typeMismatch).toBe(true);
+        expect(validityState.value).toBe(0);
+    });
+    test('requirednumber - should throw and not allow null', async () => {
+        const result = await page.evaluate(() => {
+            try {
+                document.body.setVariableValue("requirednumber",null);
+            } catch(e) {
+                return e.message;
+            }
+            return document.body.getVariableValue("requirednumber")
+        });
+        const {name,validityState} = JSON.parse(result,reviver);
+        expect(name).toBe("requirednumber");
+        expect(validityState.valueMissing).toBe(true);
+        //expect(validityState.value).toBe(null);
+    });
+})

package/types.js CHANGED Viewed

@@ -1,3 +1,23 @@
+const toJSON = (value) => {
+        if([-Infinity,Infinity].includes(value)) return `@${value}`;
+        if(typeof(value)==="number" && isNaN(value)) return "@NaN";
+        if(value && typeof(value)==="object") {
+            return Object.entries(value)
+                .reduce((json,[key,value]) => {
+                    if(value && typeof(value)==="object" && value.toJSON) value = value.toJSON();
+                    json[key] = toJSON(value);
+                    return json;
+                },Array.isArray(value) ? [] : {})
+        }
+        return value;
+    };
+function reviver(property,value) {
+    if(value==="@-Infinity") return -Infinity;
+    if(value==="@Infinity") return Infinity;
+    if(value==="@NaN") return NaN;
+   return value;
+}
 function ValidityState(options) {
     if(!this || !(this instanceof ValidityState)) return new ValidityState(options);
     Object.assign(this,{
@@ -15,9 +35,17 @@ function ValidityState(options) {
     },options);
 }
+function DataType(options) {
+    if(!this || !(this instanceof DataType)) return new DataType(options);
+    Object.assign(this,options);
+}
+DataType.prototype.toJSON = function() {
+    return toJSON(this);
+}
 const tryParse = (value) => {
     try {
-        return JSON.parse(value+"")
+        return JSON.parse(value+"",reviver)
     } catch(e) {
     }
@@ -25,7 +53,7 @@ const tryParse = (value) => {
 const ifInvalid = (variable) => {
     variable.validityState.type = typeof(variable.type)==="string" ? variable.type : variable.type.type;
-    throw new TypeError(JSON.stringify(variable));
+    throw new TypeError(JSON.stringify(DataType(variable)));
     // or could return existing value variable.value
     // or could return nothing
 }
@@ -99,6 +127,7 @@ const array = ({coerce=false, required = false,whenInvalid = ifInvalid,maxlength
     }
 }
 array.validate = validateArray;
+array.whenInvalid = ifInvalid;
 array.coerce = false;
 array.required = false;
@@ -110,7 +139,7 @@ const validateBoolean  = function(value,variable) {
     if(this.required && value==null) {
         variable.validityState = ValidityState({valueMissing: true});
     } else {
-        const result = !!(this.coerce ? tryParse(value) : value);
+        const result = this.coerce ? tryParse(value) : value;
         if(typeof(result)!=="boolean") {
             variable.validityState = ValidityState({typeMismatch: true, value});
         } else {
@@ -135,6 +164,7 @@ const boolean = ({coerce=false,required=false, whenInvalid = ifInvalid,...rest})
     }
 }
 boolean.validate = validateBoolean;
+boolean.whenInvalid = ifInvalid;
 boolean.coerce = false;
 boolean.required = false;
@@ -186,11 +216,12 @@ const number = ({coerce=false,required = false,whenInvalid = ifInvalid,min=-Infi
     }
 }
 number.validate = validateNumber;
+number.whenInvalid = ifInvalid;
 number.min = -Infinity;
 number.max = Infinity;
 number.coerce = false;
 number.required = false;
-number.allwNaN = true;
+number.allowNaN = true;
 number.step = 1;
 const validateObject  = function(value,variable) {
@@ -225,6 +256,7 @@ const object = ({coerce=false, required = false,whenInvalid = ifInvalid,...rest}
     }
 }
 object.validate = validateObject;
+object.whenInvalid = ifInvalid;
 object.coerce = false;
 object.required = false;
@@ -269,6 +301,7 @@ const string = ({coerce=false, required = false,whenInvalid = ifInvalid, maxleng
     }
 }
 string.validate = validateString;
+string.whenInvalid = ifInvalid;
 string.coerce = false;
 string.required = false;
 string.maxlength = Infinity;
@@ -306,6 +339,7 @@ const symbol = ({coerce=false,required=false, whenInvalid = ifInvalid,...rest})
     }
 }
 symbol.validate = validateSymbol;
+symbol.whenInvalid = ifInvalid;
 symbol.coerce = false;
 symbol.required = false;
@@ -442,4 +476,4 @@ const remote = (config) => {
     }
 }
-export {ValidityState,any,array,boolean,number,string,symbol,remote}
+export {ValidityState,any,array,boolean,number,object,string,symbol,remote,reviver}