lightview 1.6.3-b → 1.6.6-b

package/types.js

@@ -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
 }
@@ -80,7 +108,7 @@ const validateArray  = function(value,variable) {
     }
     return this.whenInvalid(variable,value);
 }
-const array = ({coerce=false, required = false,whenInvalid = ifInvalid,maxlength=Infinity,minlength=0,...rest}) => {
+const array = ({coerce=false, required = false,whenInvalid = ifInvalid,maxlength=Infinity,minlength=0,...rest}={}) => {
     if(typeof(coerce)!=="boolean") throw new TypeError(`coerce, ${JSON.stringify(coerce)}, must be a boolean`);
     if(typeof(required)!=="boolean") throw new TypeError(`required, ${JSON.stringify(required)}, must be a boolean`);
     if(typeof(whenInvalid)!=="function") throw new TypeError(`whenInvalid, ${whenInvalid}, must be a function`);
@@ -98,9 +126,7 @@ const array = ({coerce=false, required = false,whenInvalid = ifInvalid,maxlength
         validate: validateArray
     }
 }
-array.validate = validateArray;
-array.coerce = false;
-array.required = false;
+
 
 const validateBoolean  = function(value,variable) {
     if(value===undefined && variable.value===undefined) {
@@ -110,7 +136,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 {
@@ -120,7 +146,7 @@ const validateBoolean  = function(value,variable) {
     }
     return this.whenInvalid(variable,value);
 }
-const boolean = ({coerce=false,required=false, whenInvalid = ifInvalid,...rest}) =>{
+const boolean = ({coerce=false,required=false, whenInvalid = ifInvalid,...rest}={}) =>{
     if(typeof(coerce)!=="boolean") throw new TypeError(`coerce, ${JSON.stringify(coerce)}, must be a boolean`);
     if(typeof(required)!=="boolean") throw new TypeError(`required, ${JSON.stringify(required)}, must be a boolean`);
     if(typeof(whenInvalid)!=="function") throw new TypeError(`whenInvalid, ${whenInvalid}, must be a function`);
@@ -134,9 +160,7 @@ const boolean = ({coerce=false,required=false, whenInvalid = ifInvalid,...rest})
         validate: validateBoolean
     }
 }
-boolean.validate = validateBoolean;
-boolean.coerce = false;
-boolean.required = false;
+
 
 const validateNumber  = function(value,variable) {
     if(value===undefined && variable.value===undefined) {
@@ -148,13 +172,13 @@ const validateNumber  = function(value,variable) {
         const result = this.coerce ? tryParse(value) : value;
         if(typeof(result)!=="number") {
             variable.validityState = ValidityState({typeMismatch:true,value});
-        } else if(isNaN(result) && !allowNaN) {
+        } else if(isNaN(result) && !this.allowNaN) {
             variable.validityState = ValidityState({badInput:true,value});
-        } else if(result<this.min) {
+        } else if(this.min!=null && result<this.min) {
             variable.validityState = ValidityState({rangeUnderflow:true,value});
-        } else if(result>this.max) {
+        } else if(this.max!=null && result>this.max) {
             variable.validityState = ValidityState({rangeOverflow:true,value});
-        }  else if((result % this.step)!==0) {
+        }  else if(this.step!==null && (result % this.step)!==0) {
             variable.validityState = ValidityState({rangeUnderflow:true,value});
         } else {
             variable.validityState = ValidityState({valid:true});
@@ -163,13 +187,13 @@ const validateNumber  = function(value,variable) {
     }
     return this.whenInvalid(variable,value);
 }
-const number = ({coerce=false,required = false,whenInvalid = ifInvalid,min=-Infinity,max=Infinity,step = 1,allowNaN = true,...rest}) => {
+const number = ({coerce=false,required = false,whenInvalid = ifInvalid,min=-Infinity,max=Infinity,step = 1,allowNaN = true,...rest}={}) => {
     if(typeof(coerce)!=="boolean") throw new TypeError(`coerce, ${JSON.stringify(coerce)}, must be a boolean`);
     if(typeof(required)!=="boolean") throw new TypeError(`required, ${JSON.stringify(required)}, must be a boolean`);
     if(typeof(whenInvalid)!=="function") throw new TypeError(`whenInvalid, ${whenInvalid}, must be a function`);
-    if(typeof(min)!=="number") throw new TypeError(`min, ${JSON.stringify(min)}, must be a number`);
-    if(typeof(max)!=="number") throw new TypeError(`max, ${JSON.stringify(max)}, must be a number`);
-    if(typeof(step)!=="number") throw new TypeError(`step, ${JSON.stringify(step)}, must be a number`);
+    if(min!=null && typeof(min)!=="number") throw new TypeError(`min, ${JSON.stringify(min)}, must be a number`);
+    if(max!=null && typeof(max)!=="number") throw new TypeError(`max, ${JSON.stringify(max)}, must be a number`);
+    if(step!=null && typeof(step)!=="number") throw new TypeError(`step, ${JSON.stringify(step)}, must be a number`);
     if(typeof(allowNaN)!=="boolean") throw new TypeError(`step, ${JSON.stringify(allowNaN)}, must be a boolean`);
     if(rest.default!==undefined && typeof(rest.default)!=="number") throw new TypeError(`default, ${rest.default}, must be a number`);
     return {
@@ -185,13 +209,7 @@ const number = ({coerce=false,required = false,whenInvalid = ifInvalid,min=-Infi
         validate: validateNumber
     }
 }
-number.validate = validateNumber;
-number.min = -Infinity;
-number.max = Infinity;
-number.coerce = false;
-number.required = false;
-number.allwNaN = true;
-number.step = 1;
+
 
 const validateObject  = function(value,variable) {
     if(value===undefined && variable.value===undefined) {
@@ -210,7 +228,7 @@ const validateObject  = function(value,variable) {
     }
     return this.whenInvalid(variable,value);
 }
-const object = ({coerce=false, required = false,whenInvalid = ifInvalid,...rest}) => {
+const object = ({coerce=false, required = false,whenInvalid = ifInvalid,...rest}={}) => {
     if(typeof(coerce)!=="boolean") throw new TypeError(`coerce, ${JSON.stringify(coerce)}, must be a boolean`);
     if(typeof(required)!=="boolean") throw new TypeError(`required, ${JSON.stringify(required)}, must be a boolean`);
     if(typeof(whenInvalid)!=="function") throw new TypeError(`whenInvalid, ${whenInvalid}, must be a function`);
@@ -224,9 +242,7 @@ const object = ({coerce=false, required = false,whenInvalid = ifInvalid,...rest}
         validate: validateObject
     }
 }
-object.validate = validateObject;
-object.coerce = false;
-object.required = false;
+
 
 const validateString  = function(value,variable) {
     if(value===undefined && variable.value===undefined) {
@@ -249,7 +265,7 @@ const validateString  = function(value,variable) {
     }
     return this.whenInvalid(variable,value);
 }
-const string = ({coerce=false, required = false,whenInvalid = ifInvalid, maxlength = Infinity, minlength = 0, pattern, ...rest}) => {
+const string = ({coerce=false, required = false,whenInvalid = ifInvalid, maxlength = Infinity, minlength = 0, pattern,...rest}={}) => {
     if(typeof(coerce)!=="boolean") throw new TypeError(`coerce, ${JSON.stringify(coerce)}, must be a boolean`);
     if(typeof(required)!=="boolean") throw new TypeError(`required, ${JSON.stringify(required)}, must be a boolean`);
     if(typeof(whenInvalid)!=="function") throw new TypeError(`whenInvalid, ${whenInvalid}, must be a function`);
@@ -268,11 +284,7 @@ const string = ({coerce=false, required = false,whenInvalid = ifInvalid, maxleng
         validate: validateString
     }
 }
-string.validate = validateString;
-string.coerce = false;
-string.required = false;
-string.maxlength = Infinity;
-string.minlength = 0;
+
 
 const validateSymbol  = function(value,variable) {
     if(value===undefined && variable.value===undefined) {
@@ -291,7 +303,7 @@ const validateSymbol  = function(value,variable) {
     }
     return this.whenInvalid(variable,value);
 }
-const symbol = ({coerce=false,required=false, whenInvalid = ifInvalid,...rest}) =>{
+const symbol = ({coerce=false,required=false, whenInvalid = ifInvalid,...rest}={}) =>{
     if(typeof(coerce)!=="boolean") throw new TypeError(`coerce, ${JSON.stringify(coerce)}, must be a boolean`);
     if(typeof(required)!=="boolean") throw new TypeError(`required, ${JSON.stringify(required)}, must be a boolean`);
     if(typeof(whenInvalid)!=="function") throw new TypeError(`whenInvalid, ${whenInvalid}, must be a function`);
@@ -305,9 +317,6 @@ const symbol = ({coerce=false,required=false, whenInvalid = ifInvalid,...rest})
         validate: validateSymbol
     }
 }
-symbol.validate = validateSymbol;
-symbol.coerce = false;
-symbol.required = false;
 
 const remoteProxy = ({json, variable,config, reactive, component}) => {
     const type = typeof (config);
@@ -394,7 +403,7 @@ const put = (href,variable) => {
     })
 }
 
-const handleRemote = async ({variable, config, reactive, component},doput) => {
+const handleRemote = async ({variable, functionalType, config=functionalType, component},doput) => {
     const type = typeof (config);
     let value;
     if (type === "string") {
@@ -404,20 +413,20 @@ const handleRemote = async ({variable, config, reactive, component},doput) => {
             : get(href,variable));
         if(variable.value===undefined) variable.value = value; // do not await here
     } else if (remote && type === "object") {
-        let href;
         if(!config.path) config.path = `./${variable.name}`;
-        if(config.path) href = new URL(config.path,window.location.href).href;
+        if(config.path.endsWith("/")) config.path = `${config.path}${variable.name}`;
+        const href = new URL(config.path,window.location.href).href;
         if(!config.get || !config.put) {
             if(!href) throw new Error(`A remote path is required if no put function is provided for remote data`)
             if(!config.get) config.get = get;
-            if(!config.put && reactive) config.put = put;
+            if(!config.put && variable.reactive) config.put = put;
         }
         value = (doput
             ? config.put(href,variable)
             : config.get(href,variable));
         if(config.ttl && !doput && !config.intervalId) {
             config.intervalId = setInterval(async () => {
-                await handleRemote({variable, config, reactive, component});
+                await handleRemote({variable, config, component});
                 //schedule();
             },config.ttl);
         }
@@ -425,13 +434,11 @@ const handleRemote = async ({variable, config, reactive, component},doput) => {
     }
     if(value) {
         const json = await value;
-       //value.then((json) => {
-            if (json && typeof (json) === "object" && reactive) {
-                variable.value = remoteProxy({json, variable,config, reactive, component});
-            } else {
-                component.setVariableValue(variable.name,json);
-            }
-        //})
+        if (json && typeof (json) === "object" && variable.reactive) {
+            variable.value = remoteProxy({json, variable,config, component});
+        } else {
+            component.setVariableValue(variable.name,json);
+        }
     }
 }
 
@@ -442,4 +449,6 @@ const remote = (config) => {
     }
 }
 
-export {ValidityState,any,array,boolean,number,string,symbol,remote}
+const remoteGenerator = handleRemote;
+
+export {ValidityState,any,array,boolean,number,object,remote,remoteGenerator,string,symbol,reviver}