@live-change/serialization 0.9.139

package/binary.js

@@ -0,0 +1,129 @@
+const textEncoder = new TextEncoder()
+const textDecoder = new TextDecoder()
+
+/** Writer that will write data in binary format. */
+class BinaryWriter {
+  #outputBuffer = new ArrayBuffer(1024)
+  #outputPosition = 0
+  #outputView = new DataView(this.#outputBuffer)
+  #structureBuffer 
+  #structurePosition = 0
+  #structureView
+  constructor(structure) {
+    if(structure) {
+      this.#structureBuffer = new ArrayBuffer(1024)
+      this.#structureView = new DataView(this.#structureBuffer)
+    }
+  }
+
+  allocateMore() {
+    const newBuffer = new ArrayBuffer(this.#outputBuffer.byteLength * 2)
+    const newView = new DataView(newBuffer)
+    new Uint8Array(newBuffer).set(new Uint8Array(this.#outputBuffer))
+    this.#outputBuffer = newBuffer
+    this.#outputView = newView
+  }
+
+  writeNumber(num) {
+    if(this.#outputPosition + 8 > this.#outputBuffer.byteLength) this.allocateMore()
+    this.#outputView.setFloat64(this.#outputPosition, num)
+    this.#outputPosition += 8
+    return this
+  }
+
+  writeType(type) {
+    this.writeInteger(type)
+    return this
+  }
+
+  writeSize(size) {
+    this.writeInteger(size)
+    return this
+  }
+
+  writeString(str) {
+    const encoded = textEncoder.encode(str, new Uint8Array(this.#outputBuffer, this.#outputPosition))
+    this.writeInteger(encoded.length)
+    // copy string to output buffer
+    new Uint8Array(this.#outputBuffer, this.#outputPosition).set(encoded)
+    this.#outputPosition += encoded.length
+    return this
+  }
+
+  writeKey(key) {
+    const encoded = textEncoder.encode(str, new Uint8Array(this.#outputBuffer, this.#outputPosition))
+    this.writeInteger(encoded.length)
+    if(this.#structureBuffer) {
+      new Uint8Array(this.#structureBuffer, this.#structurePosition).set(encoded)
+      this.#structurePosition += encoded.length
+      return this
+    }
+    new Uint8Array(this.#outputBuffer, this.#outputPosition).set(encoded)
+    this.#outputPosition += encoded.length
+    return this
+  }
+
+  writeBoolean(bool) {
+    this.#outputView.setUint8(this.#outputPosition++, bool ? 1 : 0)
+    return this
+  }
+
+  writeNull() {
+  }
+
+}
+
+export class BinaryReader {
+  #inputBuffer
+  #inputPosition = 0
+  #inputView = new DataView(this.#inputBuffer)
+  constructor(inputBuffer, structureBuffer) {
+    this.#inputBuffer = inputBuffer
+    this.#inputView = new DataView(inputBuffer)
+  }
+
+  readNumber() {
+    const result = this.#inputView.getFloat64(this.#inputPosition)
+    this.#inputPosition += 8
+    return result
+  }
+
+  readType() {
+    return this.readInteger()
+  }
+
+  readSize() {
+    return this.readInteger()
+  }
+
+  readString() {
+    const size = this.readInteger()
+    const result = textDecoder.decode(new Uint8Array(this.#inputBuffer, this.#inputPosition, size))
+    this.#inputPosition += size
+    return result
+  }
+
+  readKey() {
+    return this.readString()
+  }
+
+  readBoolean() {
+    return this.#inputView.getUint8(this.#inputPosition++) === 1
+  }
+
+  readNull() {
+  }
+}
+
+import { write, read } from './serialization.js'
+
+export function serializeToBinary(key) {
+  const writer = new BinaryWriter()
+  write(key, writer)
+  return writer.getOutput()
+}
+
+export function deserializeFromBinary(serialized, structure) {
+  const reader = new BinaryReader(serialized, structure)
+  return read(reader)
+}

package/index.js

@@ -0,0 +1,7 @@
+export * from './serialization.js'
+
+export * from './stringKey.js'
+
+export * from './string.js'
+
+export * from './binary.js'

package/package.json

@@ -0,0 +1,10 @@
+{
+  "name": "@live-change/serialization",
+  "version": "0.9.139",
+  "scripts": {},
+  "type": "module",
+  "author": "Michał Łaszczewski <michal@laszczewski.pl>",
+  "license": "ISC",
+  "description": "",
+  "gitHead": "9202c36abc25e3baf5fe39806d89c3fab203f428"
+}

package/serialization.js

@@ -0,0 +1,81 @@
+
+export const typeMap = Object.freeze({
+  'string': 's',
+  'number': 'n',
+  'boolean': 'b',
+  'object': 'o',
+  'null': 'z',
+  'array': 'a'
+})
+
+export const types = Object.freeze(Object.fromEntries(
+ Object.entries(typeMap).map(([type, key]) => [key, type])
+))
+
+/** Serialize any data using writer
+ *
+ * @param {any} data
+ * @param {Writer} writer
+ */
+export function write(data, writer) {
+  switch(typeof data) {
+    case 'string': return writer.writeType(typeMap.string).writeString(data)
+    case 'number': {
+      return writer.writeType(typeMap.number).writeNumber(data)
+    }
+    case 'boolean': return writer.writeType(typeMap.boolean).writeBoolean(data)
+    case 'object':
+      if(data === null) return writer.writeType(typeMap.null)
+      if(Array.isArray(data)) {
+        writer.writeType(typeMap.array).writeSize(data.length)
+        for(let value of data) write(value, writer)
+        return writer
+      }
+      const entries = Object.entries(data)
+      writer.writeType(typeMap.object).writeSize(entries.length)
+      for(let [key, value] of entries) {
+        writer.writeKey(key)
+        write(value, writer)
+      }
+      return writer
+    default:
+      throw new Error(`Unsupported type: ${typeof data}`)
+  }
+}
+
+/** Deserialize data using reader
+ *
+ * @param {Reader} reader
+ * @returns {any}
+ */
+export function read(reader) {
+  const type = reader.readType()
+  switch(type) {
+    case typeMap.string:
+      return reader.readString()
+    case typeMap.number:
+      return reader.readNumber()
+    case typeMap.boolean:
+      return reader.readBoolean()
+    case typeMap.object: {
+      const size = reader.readSize()
+      const entries = []
+      for(let i = 0; i < size; i++) {
+        const key = reader.readKey()
+        const value = read(reader)
+        entries.push([key, value])
+      }
+      return Object.fromEntries(entries)
+    }
+    case typeMap.null:
+      return null
+    case typeMap.array: {
+      const size = reader.readSize()
+      const array = []
+      for(let i = 0; i < size; i++) array.push(read(reader))
+      return array
+    }
+    default:
+      throw new Error(`Unsupported type: ${type}`)
+  }
+}

package/string.js

@@ -0,0 +1,104 @@
+/** String writer that writer data to human readable string */
+export class StringWriter {
+  #outputArray = []
+  constructor() {
+  }
+
+  writeType(type) {
+    this.#outputArray.push(type)
+    return this
+  }
+
+  writeSize(size) {
+    this.#outputArray.push(size.toFixed())
+    return this
+  }
+
+  writeKey(key) {
+    this.#outputArray.push(key.length.toFixed())
+    this.#outputArray.push(key)
+    return this
+  }
+
+  writeString(str) {
+    this.#outputArray.push(str.length.toFixed())
+    this.#outputArray.push(str)
+    return this
+  }
+
+  writeNumber(num) {
+    this.#outputArray.push(num.toString())
+    return this
+  }
+
+  writeBoolean(bool) {
+    this.#outputArray.push(bool ? 'true' : 'false')
+    return this
+  }
+
+  getOutput() {
+    return this.#outputArray.join(';')
+  }
+
+}
+
+export class StringReader {
+  #data
+  #dataPointer = 0
+  constructor(serialized) {
+    this.#data = serialized
+  }
+
+  readToken() {
+    const nextSeparator = this.#data.indexOf(';', this.#dataPointer)
+    const token = this.#data.slice(this.#dataPointer, nextSeparator === -1 ? this.#data.length : nextSeparator)
+    this.#dataPointer = nextSeparator + 1
+    return token
+  }
+
+  readType() {
+    return this.readToken()
+  }
+
+  readKey() {
+    const keyLength = parseInt(this.readToken())
+    const key = this.#data.slice(this.#dataPointer, this.#dataPointer + keyLength)
+    this.#dataPointer = this.#dataPointer + keyLength + 1
+    return key
+  }
+
+  readSize() {
+    const size = parseInt(this.readToken())
+    return size
+  }
+
+  readString() {
+    const size = parseInt(this.readToken())
+    const str = this.#data.slice(this.#dataPointer, this.#dataPointer + size)
+    this.#dataPointer = this.#dataPointer + size + 1
+    return str
+  }
+
+  readNumber() {
+    const num = parseFloat(this.readToken())
+    return num
+  }
+
+  readBoolean() {
+    const bool = this.readToken() === 'true'
+    return bool
+  }
+}
+
+import { write, read } from './serialization.js'
+
+export function serializeToString(key) {
+  const writer = new StringWriter()
+  write(key, writer)
+  return writer.getOutput()
+}
+
+export function deserializeFromString(serialized, structure) {
+  const reader = new StringReader(serialized, structure)
+  return read(reader)
+}

package/stringKey.js

@@ -0,0 +1,180 @@
+import { StringWriter, StringReader } from './string.js'
+
+export class StringKeyWriter {
+  // private variable for data buffer, data must be sortable in the same order as keys
+  #data = []
+  // private variable for structure buffer, structure will be added to the end of the data buffer
+  #structureWriter = new StringWriter()
+  #separator = '\x00'
+  constructor(separator) {
+    if(separator) this.#separator = separator
+  }
+
+  writeType(type) {
+    this.#structureWriter.writeType(type)
+    return this
+  }
+
+  writeSize(size) {
+    this.#structureWriter.writeSize(size)
+    return this
+  }
+
+  writeKey(key) {
+    this.#structureWriter.writeKey(key)
+    return this
+  }
+
+  writeString(str) {
+    this.#structureWriter.writeSize(str.length)
+    this.#data.push(str)
+    return this
+  }
+
+/*   writeInteger(num) {
+    const numString = num.toString()
+    const numKey = `${numString.length}:${numString}`
+    this.#structureWriter.writeSize(numString.length)
+    this.#data.push(numKey)
+    return this
+  }
+
+  writeFloat(num) {
+    const numString = num.toString()
+    const numKey = `${numString.length}:${numString}`
+    this.#structureWriter.writeSize(numString.length)
+    this.#data.push(numKey)
+    return this
+  } */
+
+  writeNumber(num) {
+    const exponentialString = num.toExponential()
+    const [mantisaString, exponentString] = exponentialString.split('e')    
+    
+    const mantisa = +mantisaString
+    const negative = mantisa < 0    
+    const mantisaNumbers = mantisaString.slice(negative ? 1 : 0).replace('.', '')
+    const mantisaEncoded = negative 
+      ? (Math.pow(10, mantisaNumbers.length) - (+mantisaNumbers))
+      : mantisaNumbers
+
+    const exponent = +exponentString
+    const negativeExponent = exponent < 0
+    const negativeEncoded = negative ^ negativeExponent
+    const exponentEncoded = negativeEncoded ? 9999 - Math.abs(exponent) : Math.abs(exponent) + 1
+    const digitizedExponent = exponentEncoded.toString(10).padStart(4, '0')
+
+    const prefix = (negativeEncoded ? '/' : '') + digitizedExponent
+    const numKey = `${negative ? '-' : ''}${prefix}v${mantisaEncoded}`
+    this.#structureWriter.writeSize(numKey.length)
+    this.#data.push(numKey)
+    return this
+  }
+
+  writeBoolean(bool) {
+    this.#data.push(bool ? 'true' : 'false')
+    return this
+  }
+
+  writeNull() {
+    return this
+  }
+
+  getOutput() {
+    //console.log('data', this.#data)
+    //console.log('structure', this.#structureWriter.getOutput())
+    const structure = this.#structureWriter.getOutput()
+    return this.#data.join(this.#separator) + this.#separator + structure + ':' + structure.length
+  }
+
+  getStructure() {
+    return this.#structureWriter.getOutput()
+  }
+
+  getData() {
+    return this.#data.join(this.#separator)
+  }
+
+}
+
+export class StringKeyReader {
+  #data
+  #dataPointer = 0
+  #structureReader
+
+  constructor(serialized) {
+    const lastSeparator = serialized.lastIndexOf(':')
+    const structureLength = parseInt(serialized.slice(lastSeparator + 1))
+    const structure = serialized.slice(lastSeparator - structureLength, lastSeparator)
+    this.#data = serialized.slice(0, lastSeparator - structureLength - 1)
+    this.#structureReader = new StringReader(structure)
+  }
+
+  readType() {
+    return this.#structureReader.readType()
+  }
+
+  readSize() {
+    return this.#structureReader.readSize()
+  }
+
+  readKey() {
+    return this.#structureReader.readKey()
+  }
+
+  readNull() {
+    return null
+  }
+
+  readString() {
+    const size = this.#structureReader.readSize()
+    const result = this.#data.slice(this.#dataPointer, this.#dataPointer + size)
+    this.#dataPointer += size + 1
+    return result
+  }
+
+  readNumber() {
+    const size = this.#structureReader.readSize()    
+    const numKey = this.#data.slice(this.#dataPointer, this.#dataPointer + size)
+    this.#dataPointer += size + 1
+
+    const [prefix, encodedMantisa] = numKey.split('v')
+    const negative = prefix[0] === '-'
+    const encodedExponentString = prefix.slice(negative ? 1 : 0)
+    const negativeEncoded = encodedExponentString[0] == '/'    
+    const encodedExponent = +encodedExponentString.slice(negativeEncoded ? 1 : 0)
+    const absoluteExponent = negativeEncoded ? (9999 - encodedExponent) : encodedExponent - 1
+    const negativeExponent = negativeEncoded ^ negative
+    const exponent = negativeExponent ? -absoluteExponent : absoluteExponent
+
+    const mantisaInteger = negative 
+      ? ''+(Math.pow(10, encodedMantisa.length) - (+encodedMantisa))
+      : ''+encodedMantisa
+
+    const mantisa = mantisaInteger.length > 1 
+      ? `${mantisaInteger[0]}.${mantisaInteger.slice(1)}` 
+      : mantisaInteger
+    const exponentialString = `${negative ? '-' : ''}${mantisa}e${exponent}`
+    
+    return +exponentialString
+  }
+
+  readBoolean() {
+    const result = this.#data.slice(this.#dataPointer, this.#dataPointer + 4)
+    this.#dataPointer += 5
+    return result === 'true'
+  }
+}
+
+import { write, read } from './serialization.js'
+
+export function serializeKeyToString(key) {
+  const writer = new StringKeyWriter()
+  write(key, writer)
+  return writer.getOutput()
+}
+
+export function deserializeKeyFromString(serialized, structure) {
+  const reader = new StringKeyReader(serialized, structure)
+  return read(reader)
+}

package/test/stringKey.js

@@ -0,0 +1,144 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert'
+import { serializeKeyToString, deserializeKeyFromString } from '../stringKey.js'
+
+function testSerializeToString(data) {
+  const serialized = serializeKeyToString(data)
+  console.log('serialized', serialized)
+  const deserialized = deserializeKeyFromString(serialized)
+  console.log('deserialized', deserialized)
+  assert.deepStrictEqual(deserialized, data)
+}
+
+function deepCompare(a, b) {
+  if(typeof a !== typeof b) return 'different'
+  if(typeof a === 'object') {
+    if(Array.isArray(a) && Array.isArray(b)) {
+      const maxLength = Math.max(a.length, b.length)
+      for(let i = 0; i < maxLength; i++) {
+        const av = a[i]
+        const bv = b[i]
+        if(av === undefined || bv === undefined) return 'different'              
+        const result = deepCompare(a[i], b[i])
+        if(result !== 'equal') return result
+      }
+    }
+    for(let key in b) {
+      const av = a[key]
+      const bv = b[key]
+      if(av === undefined || bv === undefined) return 'different'
+    }
+    for(let key in a) {
+      const av = a[key]
+      const bv = b[key]
+      if(av === undefined || bv === undefined) return 'different'
+      
+      const result = deepCompare(av, bv)
+      if(result !== 'equal') return result
+    }
+    return 'equal'
+  }
+  if(a === b) return 'equal'
+  if(a > b) return 'greater'
+  if(a < b) return 'less'
+  return 'different'
+}
+
+function testCompareSerialization(a, b) {
+  const serializedA = serializeKeyToString(a)
+  const serializedB = serializeKeyToString(b)
+  const comparison = deepCompare(a, b)
+  const serializedComparison = deepCompare(serializedA, serializedB)
+  if(comparison === 'different') {
+    return // ignore different values
+  }
+  if(comparison !== serializedComparison) {
+    console.log("Compare Failed", JSON.stringify(a), JSON.stringify(b), '=>', comparison, '!=',
+      serializedComparison, JSON.stringify(serializedA), JSON.stringify(serializedB))
+  }
+  assert.deepStrictEqual(comparison, serializedComparison)
+}
+
+describe('stringKey serialization', () => {
+  it('should serialize and deserialize numbers', () => {
+    testSerializeToString(1)
+    testSerializeToString(1.1)
+    testSerializeToString(1.11)
+    testSerializeToString(0.001)
+    testSerializeToString(10000)
+    testSerializeToString(-1)
+    testSerializeToString(-1.1)
+    testSerializeToString(-1.11)
+    testSerializeToString(-0.001)
+    testSerializeToString(-10000)
+  })
+  it('should serialize and deserialize strings', () => {
+    testSerializeToString('')
+    testSerializeToString('a')
+    testSerializeToString('ab')
+    testSerializeToString('abc')
+    testSerializeToString('abcd')
+    testSerializeToString('abcde')
+    testSerializeToString('abcdef')
+    testSerializeToString('a\n\r')
+    testSerializeToString('a{}\t')
+  })
+  it('should serialize and deserialize booleans', () => {
+    testSerializeToString(true)
+    testSerializeToString(false)
+  })
+  it('should serialize and deserialize null', () => {
+    testSerializeToString(null)
+  })
+  it('should serialize and deserialize objects', () => {
+    testSerializeToString({ a: 1, c: 'a', b: 2 })
+  })
+  it('should serialize and deserialize arrays', () => {
+    testSerializeToString([1, 2, 3])
+    testSerializeToString(['a', 'b', 'c'])
+    testSerializeToString([true, false, null])
+    testSerializeToString([{ a: 1, c: 'a', b: 2 }, { a: 3, b: 4 }])
+  })
+
+  it('should leave numbers in the same order', () => {
+    const numers = [1, 2, 1.1, 1.11, 0.001, 10000, 10000.1, -1, -1.1, -1.11, -0.001, -10000, -10000.1]
+    for(let i = 0; i < numers.length; i++) {
+      for(let j = i + 1; j < numers.length; j++) {
+        testCompareSerialization(numers[i], numers[j])
+      }    
+    }
+  })
+  it('should leave strings in the same order', () => {
+    const strings = ['', 'a', 'ab', 'abc', 'abcd', 'abcde', 'abcdef', 'a\n\r', 'a{}\t']
+    for(let i = 0; i < strings.length; i++) {
+      for(let j = i + 1; j < strings.length; j++) {
+        testCompareSerialization(strings[i], strings[j])
+      }
+    }
+  })
+  it('should leave booleans in the same order', () => {
+    const booleans = [true, false]
+    for(let i = 0; i < booleans.length; i++) {
+      for(let j = i + 1; j < booleans.length; j++) {
+        testCompareSerialization(booleans[i], booleans[j])
+      }
+    }
+  })
+  it('should leave arrays in the same order', () => {
+    const arrays = [[], [1], [1, 2], [1, 2, 3], [1, 2, 3, 4], [1, 2, 3, 4, 5], [1, 2, 3, 4, 5, 6], [1, 2, 3, 4, 5, 6, 7], [1, 2, 3, 4, 5, 6, 7, 8], [1, 2, 3, 4, 5, 6, 7, 8, 9], [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]]
+    for(let i = 0; i < arrays.length; i++) {
+      for(let j = i + 1; j < arrays.length; j++) {
+        testCompareSerialization(arrays[i], arrays[j])
+      }
+    }
+  })
+  it('should leave objects in the same order', () => {
+    const objects = [{}, {a: 1}, {a: 1, b: 2}, {a: 1, b: 2, c: 3}, {a:2, b: 1}, {a: 2}, {a:1, b:1}]
+    for(let i = 0; i < objects.length; i++) {
+      for(let j = i + 1; j < objects.length; j++) {
+        testCompareSerialization(objects[i], objects[j])
+      }
+    }
+  })
+  
+})