npm - lightview - Versions diffs - 1.6.5-b → 1.7.2-b - Mend

lightview 1.6.5-b → 1.7.2-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 (28) hide show

package/README.md +3 -3
package/components/chart/chart.html +15 -0
package/components/chart/example.html +32 -0
package/components/chart.html +22 -18
package/components/components.js +93 -0
package/components/gantt/example.html +27 -0
package/components/gantt/gantt.html +34 -0
package/components/gauge/example.html +28 -0
package/components/gauge/guage.html +19 -0
package/components/timeline.html +81 -0
package/examples/counter.html +1 -1
package/examples/foreign.html +27 -13
package/examples/forgeinform.html +29 -8
package/examples/form.html +1 -1
package/examples/invalid-template-literals.html +1 -4
package/examples/medium/remote.html +2 -1
package/examples/message.html +0 -1
package/examples/object-bound-form.html +32 -0
package/examples/remote.json +1 -1
package/examples/timeline.html +21 -0
package/examples/todo.html +38 -0
package/examples/types.html +3 -2
package/lightview.js +376 -243
package/package.json +1 -1
package/test/basic.html +8 -4
package/test/extended.html +10 -7
package/test/extended.test.mjs +182 -4
package/types.js +98 -52

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "lightview",
-  "version": "1.6.5b",
+  "version": "1.7.2b",
   "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/basic.html CHANGED Viewed

@@ -3,12 +3,16 @@
 <head>
     <meta charset="UTF-8">
     <title>Basic</title>
-    <template id="x-test" name="joe" open="true" count=1 children='["mary"]' l-on:click="bump">
+    <template id="x-test" name="joe" open="true" count=1 children='["mary"]' l-on:click="${bump}">
+        <span id="children">${children}</span>
+        <input id="idatetime" type="datetime" value="${idatetime}">
         <span id="name">${name}</span>
         <span id="open">${open}</span>
         <span id="count">${count}</span>
-        <span id="children">${children}</span>
         <span id="color">${color}</span>
         <span id="checked">${checked}</span>
         <span id="age">${age}</span>
@@ -28,12 +32,12 @@
         <input id="inumber" type="number" value="${inumber}">
         <input id="irange" type="range" value="${irange}">
-        <input id="idatetime" type="datetime" value="${idatetime}">
         <input id="icheckbox" type="checkbox" value="${icheckbox}">
         <script type="lightview/module">
-        //debugger;
+       // debugger;
             self.variables({name:"string",open:"boolean",count:"number",children:Array},{imported,reactive});
             self.variables({color:"string",checked:"boolean",age:"number",hamburger:Array},{exported,reactive});
             self.variables({counter:"number"},{reactive});

package/test/extended.html CHANGED Viewed

@@ -14,15 +14,18 @@ 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({extendedarray:array({required:true,minlength:2,maxlength:3})});
+self.variables({extendedboolean:boolean({required:true})});
+self.variables({extendednumber:number({required:true,min:1,max:4,step:2,allowNaN:false})});
+self.variables({extendedobject:object({required:true})});
+self.variables({extendedstring:string({required:true,minlength:2,maxlength:4})});
+self.variables({allowNaNnumber:number({min:null,max:null,step:null})});
+self.variables({noNaNnumber:number({allowNaN:false})});
-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);
+//debugger;
+//self.setVariableValue("extendedarray",[]);
+//console.log(typeof(extendedarray),extendedarray);
 </script>
 </body>

package/test/extended.test.mjs CHANGED Viewed

@@ -253,18 +253,196 @@ describe('Lightview - Variables', () => {
         expect(validityState.value).toBe(0);
     });
-    test('requirednumber - should throw and not allow null', async () => {
+    test('extendedarray - should respect minlength', async () => {
         const result = await page.evaluate(() => {
             try {
-                document.body.setVariableValue("requirednumber",null);
+                document.body.setVariableValue("extendedarray",[]);
             } catch(e) {
                 return e.message;
             }
-            return document.body.getVariableValue("requirednumber")
+            return document.body.getVariableValue("extendedarray")
         });
         const {name,validityState} = JSON.parse(result,reviver);
-        expect(name).toBe("requirednumber");
+        expect(name).toBe("extendedarray");
+        expect(validityState.tooShort).toBe(true);
+    });
+    test('extendedarray - should respect maxlength', async () => {
+        const result = await page.evaluate(() => {
+            try {
+                document.body.setVariableValue("extendedarray",[1,2,3,4,5]);
+            } catch(e) {
+                return e.message;
+            }
+            return document.body.getVariableValue("extendedarray")
+        });
+        const {name,validityState} = JSON.parse(result,reviver);
+        expect(name).toBe("extendedarray");
+        expect(validityState.tooLong).toBe(true);
+    });
+    test('extendedarray - should throw and not allow null', async () => {
+        const result = await page.evaluate(() => {
+            try {
+                document.body.setVariableValue("extendedarray",null);
+            } catch(e) {
+                return e.message;
+            }
+            return document.body.getVariableValue("extendedarray")
+        });
+        const {name,validityState} = JSON.parse(result,reviver);
+        expect(name).toBe("extendedarray");
         expect(validityState.valueMissing).toBe(true);
+    });
+    test('extendednumber - should throw and not allow null', async () => {
+        const result = await page.evaluate(() => {
+            try {
+                document.body.setVariableValue("extendednumber",null);
+            } catch(e) {
+                return e.message;
+            }
+            return document.body.getVariableValue("extendednumber")
+        });
+        const {name,validityState} = JSON.parse(result,reviver);
+        expect(name).toBe("extendednumber");
+        expect(validityState.valueMissing).toBe(true);
+    });
+    test('extendednumber - should throw and not allow NaN', async () => {
+        const result = await page.evaluate(() => {
+            try {
+                document.body.setVariableValue("extendednumber",NaN);
+            } catch(e) {
+                return e.message;
+            }
+            return document.body.getVariableValue("extendednumber")
+        });
+        const {name,validityState} = JSON.parse(result,reviver);
+        expect(name).toBe("extendednumber");
+        expect(validityState.badInput).toBe(true);
         //expect(validityState.value).toBe(null);
     });
+    test('extendednumber - should respect min', async () => {
+        const result = await page.evaluate(() => {
+            try {
+                document.body.setVariableValue("extendednumber",0);
+            } catch(e) {
+                return e.message;
+            }
+            return document.body.getVariableValue("extendednumber")
+        });
+        const {name,validityState} = JSON.parse(result,reviver);
+        expect(name).toBe("extendednumber");
+        expect(validityState.rangeUnderflow).toBe(true);
+    });
+    test('extendednumber - should allow between and allow step', async () => {
+        const result = await page.evaluate(() => {
+            try {
+                document.body.setVariableValue("extendednumber",4);
+            } catch(e) {
+                return e.message;
+            }
+            return document.body.getVariableValue("extendednumber")
+        });
+        expect(result).toBe(4);
+    });
+    test('extendednumber - should respect max', async () => {
+        const result = await page.evaluate(() => {
+            try {
+                document.body.setVariableValue("extendednumber",5);
+            } catch(e) {
+                return e.message;
+            }
+            return document.body.getVariableValue("extendednumber")
+        });
+        const {name,validityState} = JSON.parse(result,reviver);
+        expect(name).toBe("extendednumber");
+        expect(validityState.rangeOverflow).toBe(true);
+    });
+    test('extendednumber - should respect step', async () => {
+        const result = await page.evaluate(() => {
+            try {
+                document.body.setVariableValue("extendednumber",3);
+            } catch(e) {
+                return e.message;
+            }
+            return document.body.getVariableValue("extendednumber")
+        });
+        const {name,validityState} = JSON.parse(result,reviver);
+        expect(name).toBe("extendednumber");
+        expect(validityState.rangeUnderflow).toBe(true);
+    });
+    test('allowNaNnumber - should allow NaN', async () => {
+        const result = await page.evaluate(() => {
+            try {
+                document.body.setVariableValue("allowNaNnumber",NaN);
+            } catch(e) {
+                return e.message;
+            }
+            return document.body.getVariableValue("allowNaNnumber")
+        });
+        expect(typeof(result)==="number" && isNaN(result)).toBe(true);
+    });
+    test('noNaNnumber - should not allow NaN', async () => {
+        const result = await page.evaluate(() => {
+            try {
+                document.body.setVariableValue("noNaNnumber",NaN);
+            } catch(e) {
+                return e.message;
+            }
+            return document.body.getVariableValue("noNaNnumber")
+        });
+        const {name,validityState} = JSON.parse(result,reviver);
+        expect(name).toBe("noNaNnumber");
+        expect(validityState.badInput).toBe(true);
+    });
+    test('extendedstring - should respect minlength', async () => {
+        const result = await page.evaluate(() => {
+            try {
+                document.body.setVariableValue("extendedstring","a");
+            } catch(e) {
+                return e.message;
+            }
+            return document.body.getVariableValue("extendedstring")
+        });
+        const {name,validityState} = JSON.parse(result,reviver);
+        expect(name).toBe("extendedstring");
+        expect(validityState.tooShort).toBe(true);
+    });
+    test('extendedstring - should respect maxlength', async () => {
+        const result = await page.evaluate(() => {
+            try {
+                document.body.setVariableValue("extendedstring","abcdefg");
+            } catch(e) {
+                return e.message;
+            }
+            return document.body.getVariableValue("extendedstring")
+        });
+        const {name,validityState} = JSON.parse(result,reviver);
+        expect(name).toBe("extendedstring");
+        expect(validityState.tooLong).toBe(true);
+    });
+    test('extendedstring - should throw and not allow null', async () => {
+        const result = await page.evaluate(() => {
+            try {
+                document.body.setVariableValue("extendedstring",null);
+            } catch(e) {
+                return e.message;
+            }
+            return document.body.getVariableValue("extendedstring")
+        });
+        const {name,validityState} = JSON.parse(result,reviver);
+        expect(name).toBe("extendedstring");
+        expect(validityState.valueMissing).toBe(true);
+    });
 })

package/types.js CHANGED Viewed

@@ -108,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`);
@@ -126,10 +126,7 @@ const array = ({coerce=false, required = false,whenInvalid = ifInvalid,maxlength
         validate: validateArray
     }
 }
-array.validate = validateArray;
-array.whenInvalid = ifInvalid;
-array.coerce = false;
-array.required = false;
 const validateBoolean  = function(value,variable) {
     if(value===undefined && variable.value===undefined) {
@@ -149,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`);
@@ -163,10 +160,78 @@ const boolean = ({coerce=false,required=false, whenInvalid = ifInvalid,...rest})
         validate: validateBoolean
     }
 }
-boolean.validate = validateBoolean;
-boolean.whenInvalid = ifInvalid;
-boolean.coerce = false;
-boolean.required = false;
+const isDuration = (value) => {
+    return parseDuration(value)!==undefined;
+}
+const durationMilliseconds = {
+    ms: 1,
+    s: 1000,
+    m: 1000 * 60,
+    h: 1000 * 60 * 60,
+    d: 1000 * 60 * 60 * 24,
+    w: 1000 * 60 * 60 * 24 * 7,
+    mo: (1000 * 60 * 60 * 24 * 365.25)/12,
+    q: (1000 * 60 * 60 * 24 * 365.25)/4,
+    y: (1000 * 60 * 60 * 24 * 365.25)
+}
+const parseDuration = (value) => {
+    if(typeof(value)==="number") return value;
+    if(typeof(value)==="string") {
+        const num = parseFloat(value),
+            suffix = value.substring((num+"").length);
+        if(typeof(num)==="number" && !isNaN(num) && suffix in durationMilliseconds) {
+            return durationMilliseconds[suffix] * num;
+        }
+    }
+    return null;
+}
+const validateDuration  = function(value,variable) {
+    const result = parseDuration(value);
+    if(result==null && variable.value===undefined) {
+        return parseDuration(this.default);
+    }
+    if(this.required && result==null) {
+        variable.validityState = ValidityState({valueMissing: true});
+    } else {
+        if(typeof(result)!=="number") {
+            variable.validityState = ValidityState({typeMismatch:true,value});
+        } else if(isNaN(result)) {
+            variable.validityState = ValidityState({badInput:true,value});
+        } else if(this.min!=null && result<parseDuration(this.min)) {
+            variable.validityState = ValidityState({rangeUnderflow:true,value});
+        } else if(this.max!=null && result>parseDuration(this.max)) {
+            variable.validityState = ValidityState({rangeOverflow:true,value});
+        }  else if(this.step!==null && (result % parseDuration(this.step)!==0)) {
+            variable.validityState = ValidityState({rangeUnderflow:true,value});
+        } else {
+            variable.validityState = ValidityState({valid:true});
+            return result;
+        }
+    }
+    return this.whenInvalid(variable,value);
+}
+const duration = ({required = false,whenInvalid = ifInvalid,min=-Infinity,max=Infinity,step = 1,...rest}={}) => {
+    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(min!=null && !parseDuration(min)) throw new TypeError(`min, ${JSON.stringify(min)}, must be a duration`);
+    if(max!=null && !parseDuration(max)) throw new TypeError(`max, ${JSON.stringify(max)}, must be a duration`);
+    if(step!=null && !parseDuration(step)) throw new TypeError(`step, ${JSON.stringify(step)}, must be a duration`);
+    if(rest.default!==undefined && !parseDuration(rest.default)) throw new TypeError(`default, ${JSON.stringify(rest.default)}, must be a duration`);
+    return {
+        type: "duration",
+        coerce: false,
+        required,
+        whenInvalid,
+        min,
+        max,
+        step,
+        ...rest,
+        validate: validateDuration
+    }
+}
+duration.parse = parseDuration;
 const validateNumber  = function(value,variable) {
     if(value===undefined && variable.value===undefined) {
@@ -178,13 +243,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});
@@ -193,15 +258,15 @@ 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`);
+    if(rest.default!==undefined && typeof(rest.default)!=="number") throw new TypeError(`default, ${JSON.stringify(rest.default)}, must be a number`);
     return {
         type: "number",
         coerce,
@@ -215,14 +280,7 @@ const number = ({coerce=false,required = false,whenInvalid = ifInvalid,min=-Infi
         validate: validateNumber
     }
 }
-number.validate = validateNumber;
-number.whenInvalid = ifInvalid;
-number.min = -Infinity;
-number.max = Infinity;
-number.coerce = false;
-number.required = false;
-number.allowNaN = true;
-number.step = 1;
 const validateObject  = function(value,variable) {
     if(value===undefined && variable.value===undefined) {
@@ -241,7 +299,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`);
@@ -255,10 +313,7 @@ const object = ({coerce=false, required = false,whenInvalid = ifInvalid,...rest}
         validate: validateObject
     }
 }
-object.validate = validateObject;
-object.whenInvalid = ifInvalid;
-object.coerce = false;
-object.required = false;
 const validateString  = function(value,variable) {
     if(value===undefined && variable.value===undefined) {
@@ -281,7 +336,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`);
@@ -300,12 +355,7 @@ const string = ({coerce=false, required = false,whenInvalid = ifInvalid, maxleng
         validate: validateString
     }
 }
-string.validate = validateString;
-string.whenInvalid = ifInvalid;
-string.coerce = false;
-string.required = false;
-string.maxlength = Infinity;
-string.minlength = 0;
 const validateSymbol  = function(value,variable) {
     if(value===undefined && variable.value===undefined) {
@@ -324,7 +374,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`);
@@ -338,10 +388,6 @@ const symbol = ({coerce=false,required=false, whenInvalid = ifInvalid,...rest})
         validate: validateSymbol
     }
 }
-symbol.validate = validateSymbol;
-symbol.whenInvalid = ifInvalid;
-symbol.coerce = false;
-symbol.required = false;
 const remoteProxy = ({json, variable,config, reactive, component}) => {
     const type = typeof (config);
@@ -428,7 +474,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") {
@@ -444,14 +490,14 @@ const handleRemote = async ({variable, config, reactive, component},doput) => {
         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);
         }
@@ -459,13 +505,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});
+        if (json && typeof (json) === "object" && variable.reactive) {
+            variable.value = remoteProxy({json, variable,config, component});
         } else {
             component.setVariableValue(variable.name,json);
         }
-        //})
     }
 }
@@ -476,4 +520,6 @@ const remote = (config) => {
     }
 }
-export {ValidityState,any,array,boolean,number,object,string,symbol,remote,reviver}
+const remoteGenerator = handleRemote;
+export {ValidityState,any,array,boolean,duration,number,object,remote,remoteGenerator,string,symbol,reviver}