@muze-nl/simplystore 0.5.1 → 0.5.3

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@muze-nl/simplystore",
-	"version": "0.5.1",
+	"version": "0.5.3",
 	"main": "src/server.mjs",
 	"type": "module",
 	"scripts": {

package/src/fastParse.mjs

@@ -567,9 +567,9 @@ export default function parse(input, meta, immutable=true)
         error("Input stopped early")
     }
 
-    let object = function()
+    let object = function(object={})
     {
-        let key, val, object={}
+        let key, val
         if (ch !== '{') {
             error("Syntax Error")
         }
@@ -638,10 +638,10 @@ export default function parse(input, meta, immutable=true)
         return parseInt(numString)
     }
 
-    let parseValue = function(position) {
+    let parseValue = function(position, ob={}) {
         at = position.start
         next()
-        return value()
+        return value(ob)
     }
 
     const makeChildProxies = function(parent) {
@@ -704,7 +704,7 @@ export default function parse(input, meta, immutable=true)
                             if (i != index) {
                                 return encoder.encode('~'+index)
                             }
-                            // return newly stringified contents of cache
+                            // return newly stringified contents of target
                             return encoder.encode(fastStringify(target, meta, true, i))
                         }
                     break
@@ -726,7 +726,7 @@ export default function parse(input, meta, immutable=true)
                 if (JSONTag.getType(value)==='object' && !value[isProxy]) {
                     value = getNewValueProxy(value)
                 }
-                cache[prop] = val
+                target[prop] = val
                 return true                    
             }
         }
@@ -744,11 +744,17 @@ export default function parse(input, meta, immutable=true)
             start: at-1,
             end: at-1+length
         }
-        let cache = {} // use a single global dummy cache object here to preserve memory
+        let cache = {}
         let targetIsChanged = false
         let parsed = false
         at += length
         next()
+        let firstParse = function() {
+            if (!parsed) {
+                parseValue(position, cache)
+                parsed = true
+            }
+        }
         // newValueHandler makes sure that value[getBuffer] runs stringify
         // arrayHandler makes sure that changes in the array set targetIsChanged to true
         let arrayHandler = {
@@ -794,13 +800,10 @@ export default function parse(input, meta, immutable=true)
         }
         let handler = {
             get(target, prop, receiver) {
-                if (!parsed) {
-                    cache = parseValue(position)
-                    parsed = true
-                }
+                firstParse()
                 switch(prop) {
                     case source:
-                        return cache
+                        return target
                     break
                     case isProxy:
                         return true
@@ -812,8 +815,8 @@ export default function parse(input, meta, immutable=true)
                             }
                             if (targetIsChanged) {
                                 // return newly stringified contents of cache
-                                let temp = fastStringify(cache, null, true)
-                                return encoder.encode(fastStringify(cache, null, true))
+                                let temp = fastStringify(target, null, true)
+                                return encoder.encode(fastStringify(target, null, true))
                             }
                             return input.slice(position.start,position.end)
                         }
@@ -825,57 +828,41 @@ export default function parse(input, meta, immutable=true)
                         return targetIsChanged
                     break
                     default:
-                        if (!immutable && Array.isArray(cache[prop])) {
-                            return new Proxy(cache[prop], arrayHandler)
+                        if (!immutable && Array.isArray(target[prop])) {
+                            return new Proxy(target[prop], arrayHandler)
                         }
-                        return cache[prop] // FIXME: make arrays immutable as well
+                        return target[prop] // FIXME: make arrays immutable as well
                     break
                 }
             },
-            has(target, prop) {
-                if (!parsed) {
-                    cache = parseValue(position)
-                    parsed = true
-                }
-                return typeof cache[prop] !== 'undefined'
-            },
-            ownKeys() {
-                if (!parsed) {
-                    cache = parseValue(position)
-                    parsed = true
-                }
-                return Reflect.ownKeys(cache)
-            }
-        }
-        if (!immutable) {
-            Object.assign(handler, {
-                set: (target, prop, val) => {
-                    if (!parsed) {
-                        cache = parseValue(position)
-                        parsed = true
-                    }
-                    if (JSONTag.getType(val)==='object' && !val[isProxy]) {
-                        val = getNewValueProxy(val)
+            set(target, prop, value) {
+                if (!immutable) {
+                    firstParse()
+                    if (JSONTag.getType(value)==='object' && !value[isProxy]) {
+                        value = getNewValueProxy(value)
                     }
-                    cache[prop] = val
+                    target[prop] = value
                     targetIsChanged = true
                     return true
-                },
-                deleteProperty: (target, prop) => {
-                    if (!parsed) {
-                        cache = parseValue(position)
-                        parsed = true
-                    }
-                    delete cache[prop]
+                }
+            },
+            deleteProperty: (target, prop) => {
+                if (!immutable) {
+                    firstParse()
+                    delete target[prop]
                     targetIsChanged = true
                     return true
                 }
-            })
+            },
+            'ownKeys': (target) => {
+                firstParse()
+                return Reflect.ownKeys(target)
+            }
         }
         return new Proxy(cache, handler)
     }
 
-    value = function()
+    value = function(ob={})
     {
         let tagOb, result, tagName;
         whitespace()
@@ -893,7 +880,7 @@ export default function parse(input, meta, immutable=true)
                 if (tagName && tagName!=='object') {
                     isTypeError(tagName, ch)
                 }
-                result = object()
+                result = object(ob)
             break
             case '[':
                 if (tagName && tagName!=='array') {

package/src/fastStringify.mjs

@@ -6,7 +6,7 @@ import {source,isProxy,getIndex, getBuffer} from './symbols.mjs'
 const encoder = new TextEncoder()
 const decoder = new TextDecoder()
 
-export default function stringify(value, meta, skipLength=false, index) {
+export default function stringify(value, meta, skipLength=false, index=false) {
 	let resultArray = []
 	if (!meta) {
 		meta = {}
@@ -19,7 +19,87 @@ export default function stringify(value, meta, skipLength=false, index) {
 	}
 	let references = new WeakMap()
 
-	const innerStringify = (value) => {
+	function stringifyValue(value) {
+		let prop
+		let typeString = JSONTag.getTypeString(value)
+		let type = JSONTag.getType(value)
+		switch (type) {
+			case 'string':
+			case 'decimal':
+			case 'money':
+			case 'link':
+			case 'text':
+			case 'blob':
+			case 'color':
+			case 'email':
+			case 'hash':
+			case 'duration':
+			case 'phone':
+			case 'url':
+			case 'uuid':
+			case 'date':
+			case 'time':
+			case 'datetime':
+				if (JSONTag.isNull(value)) {
+					value = 'null'
+				} else {
+					value = JSON.stringify(''+value)
+				}
+				prop = typeString + value
+			break
+			case 'int':
+			case 'uint':
+			case 'int8':
+			case 'uint8':
+			case 'int16':
+			case 'uint16':
+			case 'int32':
+			case 'uint32':
+			case 'int64':
+			case 'uint64':
+			case 'float':
+			case 'float32':
+			case 'float64':
+			case 'timestamp':
+			case 'number':
+			case 'boolean':
+				if (JSONTag.isNull(value)) {
+					value = 'null'
+				} else {
+					value = JSON.stringify(value)
+				}
+				prop = typeString + value
+			break
+			case 'array': 
+				let entries = value.map(e => stringifyValue(e)).join(',')
+				prop = typeString + '[' + entries + ']'
+			break
+			case 'object':
+				if (!value) {
+					prop = 'null'
+				} else if (value[isProxy]) {
+					prop = decoder.decode(value[getBuffer](current))
+				} else {
+					if (!references.has(value)) {
+						references.set(value, resultArray.length)
+						resultArray.push(value)
+					}
+					prop = '~'+references.get(value)
+				}
+			break
+			default:
+				throw new Error(JSONTag.getType(value)+' type not yet implemented')
+			break
+		}
+		return prop
+	}
+
+	const encoder = new TextEncoder()
+	const decoder = new TextDecoder()
+
+	// is only ever called on object values
+	// and should always return a stringified object, not a reference (~n)
+	const innerStringify = (current) => {
 		let indent = ""
 		let gap = ""
 
@@ -29,147 +109,26 @@ export default function stringify(value, meta, skipLength=false, index) {
 			indent = space
 		}
 
-		const encodeProperties = (obj) => {
-			return Object.getOwnPropertyNames(obj).map(prop => {
-				let enumerable = obj.propertyIsEnumerable(prop) ? '' : '#'
-				return enumerable+'"'+prop+'":'+str(prop, obj)
-			}).join(',')
-		}
+		let object = resultArray[current]
+		let result 
 
-		const encodeEntries = (arr) => {
-			let result = arr.map((value,index) => {
-				return str(index, arr)
-			}).join(",")
-			return result
+		// if value is a valueProxy, just copy the input slice
+		if (object && !JSONTag.isNull(object) && object[isProxy]) {
+			return decoder.decode(object[getBuffer](current))
 		}
-
-		const createId = (value) => {
-			if (typeof crypto === 'undefined') {
-				console.error('JSONTag: cannot generate uuid, crypto support is disabled.')
-				throw new Error('Cannot create links to resolve references, crypto support is disabled')
-			}
-			if (typeof crypto.randomUUID === 'function') {
-				var id = crypto.randomUUID()
-			} else {
-				var id = ([1e7]+-1e3+-4e3+-8e3+-1e11).replace(/[018]/g, c =>
-					(c ^ crypto.getRandomValues(new Uint8Array(1))[0] & 15 >> c / 4).toString(16)
-				);
-			}
-			JSONTag.setAttribute(value, 'id', id)
-			return id
+		if (typeof object === 'undefined' || object === null) {
+			return 'null'
 		}
-
-		const encoder = new TextEncoder()
-		const decoder = new TextDecoder()
-
-		const str = (key, holder) => {
-			let value = holder[key]
-			let result, updateReference
-			// if value is a valueProxy, just copy the input slice
-			if (value && !JSONTag.isNull(value) && value[isProxy]) {
-				if (index===0) {
-					resultArray.push(decoder.decode(value[getBuffer](index)))
-				}
-				return decoder.decode(value[getBuffer](index))
-			}
-			if (typeof value === 'undefined' || value === null) {
-				return 'null'
-			}
-			if (JSONTag.getType(value) === 'object' && !Array.isArray(value)) {
-				let id = JSONTag.getAttribute(value, 'id')
-				if (!references.has(value)) {
-					let reference = resultArray.length
-					updateReference = reference
-					references.set(value, updateReference)
-					resultArray.push('')
-					if (id && !meta.index.id.has(id)) {
-						meta.index.id.set(id, updateReference)
-					}
-				} else {
-					return '~'+references.get(value)
-				}
-			}
-			if (Array.isArray(value)) {
-				result = JSONTag.getTypeString(value) + "["+encodeEntries(value)+"]"
-			} else if (value instanceof Object) {
-				let typeString = JSONTag.getTypeString(value)
-				let type = JSONTag.getType(value)
-				switch (type) {
-					case 'string':
-					case 'decimal':
-					case 'money':
-					case 'link':
-					case 'text':
-					case 'blob':
-					case 'color':
-					case 'email':
-					case 'hash':
-					case 'duration':
-					case 'phone':
-					case 'url':
-					case 'uuid':
-					case 'date':
-					case 'time':
-					case 'datetime':
-						if (JSONTag.isNull(value)) {
-							value = 'null'
-						} else {
-							value = JSON.stringify(''+value)
-						}
-						result = typeString + value
-					break
-					case 'int':
-					case 'uint':
-					case 'int8':
-					case 'uint8':
-					case 'int16':
-					case 'uint16':
-					case 'int32':
-					case 'uint32':
-					case 'int64':
-					case 'uint64':
-					case 'float':
-					case 'float32':
-					case 'float64':
-					case 'timestamp':
-					case 'number':
-					case 'boolean':
-						if (JSONTag.isNull(value)) {
-							value = 'null'
-						} else {
-							value = JSON.stringify(value)
-						}
-						result = typeString + value
-					break
-					case 'array': 
-						let entries = encodeEntries(value) // calculate children first so parent references can add id attribute
-						result = typeString + '[' + entries + '}'
-					break
-					case 'object': 
-						if (JSONTag.isNull(value)) {
-							result = typeString + "null"
-						} else {
-							let props = encodeProperties(value); // calculate children first so parent references can add id attribute
-							result = typeString + '{' + props + '}'
-						}
-					break
-					default:
-						throw new Error(JSONTag.getType(value)+' type not yet implemented')
-					break
-				}
-			} else {
-				result = JSON.stringify(value)
-			}
-			if (typeof updateReference != 'undefined') {
-				resultArray[updateReference] = result
-				if (index!==updateReference) {
-					result = '~'+updateReference
-				}
-			}
-			return result
+		
+		let props = []
+		for (let key of Object.getOwnPropertyNames(object)) {
+			let value = object[key]
+			let prop = stringifyValue(value)
+			let enumerable = object.propertyIsEnumerable(key) ? '' : '#'
+			props.push(enumerable+'"'+key+'":'+prop)
 		}
-
-		return str("", {"": value})
+		result = JSONTag.getTypeString(object)+'{'+props.join(',')+'}'
+		return result
 	}
 		
 	const encode = (s) => {
@@ -180,7 +139,13 @@ export default function stringify(value, meta, skipLength=false, index) {
 		return '('+length+')'+s
 	}
 
-	innerStringify(value)
+	resultArray.push(value)
+	let current = 0
+	while(current<resultArray.length) {
+		resultArray[current] = innerStringify(current)
+		current++
+	}
+
 	return resultArray.map(encode).join("\n")
 }