ig-serialize 1.0.6 → 1.2.0

package/README.md

@@ -7,6 +7,9 @@ This extends the default JSON serialization adding the following:
 - Function serialization (off by default)
 - Deep and partial-deep cleen object copy
 
+Possible differences to JSON output:
+- Repeating long strings and BigInts can be referenced instead of 
+  reincluded in the output.
 
 
 ## Motivation
@@ -20,6 +23,13 @@ and tooling design, basic parsing, among others.
 
 ## Installation
 
+```shell
+$ npm install ig-serilaize
+```
+
+Or just download and drop [serialize.js](serialize.js) into your code.
+
+
 
 ## Introduction
 
@@ -38,6 +48,7 @@ loosing:
 Thus, care must be taken when serializing structures containing function.
 
 
+
 ## API
 
 ### `serialize(..)` / `eJSON.stringify(..)`
@@ -49,6 +60,20 @@ Thus, care must be taken when serializing structures containing function.
 ### `partialDeepCopy(..)`
 
 
+### `MIN_LENGTH_REF` / `<options>.min_length_ref` 
+
+Defines the default minimum length of repeating string or bin-int to 
+include as a reference in the output.
+
+If set to `0`, referencing will be disabled.
+
+Default: 96  
+
+
+### `DEBUG`
+
+
+
 ## Format
 
 The output of `.serialize(..)` is a strict superset of [standard JSON](https://www.json.org/json-en.html), 
@@ -65,6 +90,8 @@ Extensions to JSON:
 
 ### Recursion
 
+If an object is encountered 
+
 ### null types
 
 ### BigInt

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ig-serialize",
-  "version": "1.0.6",
+  "version": "1.2.0",
   "description": "experimental extended json serializaion...",
   "main": "serialize.js",
   "scripts": {
@@ -10,7 +10,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/flynx/serialize.js"
+    "url": "git+https://github.com/flynx/serialize.js.git"
   },
   "keywords": [
     "JSON",

package/serialize.js

@@ -51,9 +51,9 @@ var NAN = 'NaN'
 var INFINITY = 'Infinity'
 var NEG_INFINITY = '-Infinity'
 
-var RECURSIVE = '<RECURSIVE%>'
+var REFERENCE = '<REF%>'
 
-var FUNCTION = '<FUNCTION[%]>'
+var FUNCTION = '<FUNC[%]>'
 
 
 
@@ -77,7 +77,7 @@ var debug = {
 
 //---------------------------------------------------------------------
 
-module.STRING_LENGTH_REF = RECURSIVE.length * 8
+module.MIN_LENGTH_REF = REFERENCE.length * 16
 
 
 //
@@ -144,15 +144,19 @@ module.STRING_LENGTH_REF = RECURSIVE.length * 8
 var _serialize = 
 module._serialize = 
 function(obj, path=[], seen=new Map(), indent, depth=0, options={}){
-	var string_length_ref = 
-		options.string_length_ref 
-			?? module.STRING_LENGTH_REF
-
-	// recursive...
+	var min_length_ref = 
+		options.min_length_ref 
+			?? module.MIN_LENGTH_REF
+	min_length_ref = 
+		min_length_ref <= 0 ? 
+			Infinity 
+			: min_length_ref
+
+	// reference...
 	var p = seen.get(obj)
 	if(p != null){
 		// NOTE: _serialize(..) is always printed flat here, regardless of indent/depth...
-		return RECURSIVE.replace('%', _serialize(p)) }
+		return REFERENCE.replace('%', _serialize(p)) }
 
 	// functions...
 	// NOTE: we are storing function length to avoid parsing the function...
@@ -171,12 +175,14 @@ function(obj, path=[], seen=new Map(), indent, depth=0, options={}){
 	// long strings...
 	// NOTE: this saves on output size...
 	if(typeof(obj) == 'string' 
-			&& obj.length > string_length_ref){
+			&& obj.length > min_length_ref){
 		seen.set(obj, path) }
 	// BigInt...
 	if(typeof(obj) == 'bigint'){
-		seen.set(obj, path)
-		return obj.toString() +'n' }
+		var res = obj.toString() +'n' 
+		if(res.length > min_length_ref){
+			seen.set(obj, path) }
+		return res }
 
 	// atomics...
 	// NOTE: these are not stored in seen thus are not re-referenced...
@@ -260,7 +266,7 @@ function(obj, indent, depth=0, options){
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
 
 // XXX better error handling...
-// XXX try and make this single stage (see notes for : .recursive(..))
+// XXX try and make this single stage (see notes for : .reference(..))
 var eJSON = 
 module.eJSON = {
 	chars: {
@@ -287,9 +293,9 @@ module.eJSON = {
 		NaN: NaN,
 
 		'<empty>': 'empty',
-		'<RECURSIVE': 'recursive',
+		'<REF': 'reference',
 
-		'<FUNCTION[': 'func',
+		'<FUNC[': 'func',
 	},
 	
 
@@ -614,15 +620,15 @@ module.eJSON = {
 	// 		directly reference that -- this would eliminate the need for 
 	// 		stage two... (XXX TEST)
 	// 		...need to use serialized paths as keys...
-	recursive: function(state, path, match, str, i, line){
-		debug.lex('recursive', str, i, line)
+	reference: function(state, path, match, str, i, line){
+		debug.lex('reference', str, i, line)
 		return this.sequence(
 			state, path, str, i+match.length, line, 
 			'>',
 			function(res, index, str, i, line){
 				var obj
 				;[obj, i, line] = this.array(state, [...path, index], '[', str, i, line)
-				var rec = state.recursive ??= []
+				var rec = state.reference ??= []
 				rec.push([path, obj])
 				return [{}, i, line] }) },
 
@@ -695,8 +701,8 @@ module.eJSON = {
 		var state = {functions: options.functions}
 		var res = this.value(state, [], str)[0] 
 
-		// stage 2: link the recursive structures...
-		for(var [a, b] of state.recursive ?? []){
+		// stage 2: link the reference structures...
+		for(var [a, b] of state.reference ?? []){
 			this.setItem(res, a, this.getItem(res, b)) }
 
 		return res },

package/test.js

@@ -100,19 +100,19 @@ var setups = test.Setups({
 		return ['Map([])'] },
 
 	'function': function(assert){
-		return ['<FUNCTION[14,(function(){})]>'] },
+		return ['<FUNC[14,(function(){})]>'] },
 
 	// recursive...
 	'array-recursive': function(assert){
-		return ['[<RECURSIVE[]>]'] },
+		return ['[<REF[]>]'] },
 	'object-recursive': function(assert){
-		return ['{"r":<RECURSIVE[]>}'] },
+		return ['{"r":<REF[]>}'] },
 	'set-recursive': function(assert){
-		return ['Set([<RECURSIVE[]>])'] },
+		return ['Set([<REF[]>])'] },
 	'map-recursive-key': function(assert){
-		return ['Map([[<RECURSIVE[]>,"value"]])'] },
+		return ['Map([[<REF[]>,"value"]])'] },
 	'map-recursive-value': function(assert){
-		return ['Map([["key",<RECURSIVE[]>]])'] },
+		return ['Map([["key",<REF[]>]])'] },
 })
 
 test.Modifiers({
@@ -213,19 +213,26 @@ test.Cases({
 		['0O77', '63'],
 		['0b11', '3'],
 		['0B11', '3'],
+		// XXX
+		//['010', '8'],
+		//['080', '80'],
 
 		// string quotes...
-		// XXX test new lines...
 		["'abc'", '"abc"'],
 		['`abc`', '"abc"'],
+		/* XXX test new lines...
+		[`\`a
+			b
+			c\``, '"a\\nb\\nc"'],
+		//*/
 
 		// arrays...
 		['[1,2,]', '[1,2]'],
 
 		// sparse arrays...
-		['[<empty>]', '[,]'],
-		['[1,2,<empty>]', '[1,2,,]'],
-		['[1,2,<empty>]', '[1,2,<empty>,]'],
+		['[,]', '[<empty>]'],
+		['[1,2,,]', '[1,2,<empty>]'],
+		['[1,2,<empty>,]', '[1,2,<empty>]'],
 	],
 	'syntax-simplifications': function(assert){
 		var aa, bb