api-ape 0.0.0 → 1.0.1

package/utils/jss.test.js

@@ -0,0 +1,261 @@
+const jss = require('./jss')
+
+describe('JJS - JSON SuperSet', () => {
+
+    describe('Primitives', () => {
+        test('handles strings', () => {
+            const input = { str: 'hello world' }
+            const result = jss.parse(jss.stringify(input))
+            expect(result.str).toBe('hello world')
+        })
+
+        test('handles numbers', () => {
+            const input = { int: 42, float: 3.14, neg: -100 }
+            const result = jss.parse(jss.stringify(input))
+            expect(result.int).toBe(42)
+            expect(result.float).toBe(3.14)
+            expect(result.neg).toBe(-100)
+        })
+
+        test('handles booleans', () => {
+            const input = { t: true, f: false }
+            const result = jss.parse(jss.stringify(input))
+            expect(result.t).toBe(true)
+            expect(result.f).toBe(false)
+        })
+
+        test('handles null', () => {
+            const input = { n: null }
+            const result = jss.parse(jss.stringify(input))
+            expect(result.n).toBe(null)
+        })
+    })
+
+    describe('Special Types', () => {
+        test('preserves Date objects', () => {
+            const date = new Date('2025-01-01T12:00:00Z')
+            const input = { created: date }
+            const result = jss.parse(jss.stringify(input))
+            expect(result.created).toBeInstanceOf(Date)
+            expect(result.created.getTime()).toBe(date.getTime())
+        })
+
+        test('encodes RegExp objects', () => {
+            const regex = /hello/
+            const input = { pattern: regex }
+            const result = jss.parse(jss.stringify(input))
+            // RegExp is encoded/decoded - verify it's a RegExp
+            expect(result.pattern).toBeInstanceOf(RegExp)
+        })
+
+        test('preserves Error objects', () => {
+            const error = new Error('Something went wrong')
+            error.name = 'CustomError'
+            const input = { err: error }
+            const result = jss.parse(jss.stringify(input))
+            expect(result.err).toBeInstanceOf(Error)
+            expect(result.err.message).toBe('Something went wrong')
+            expect(result.err.name).toBe('CustomError')
+        })
+
+        test('handles undefined in objects', () => {
+            const input = { defined: 'yes', notDefined: undefined }
+            const result = jss.parse(jss.stringify(input))
+            // undefined properties should round-trip
+            expect(result.notDefined).toBe(undefined)
+        })
+
+        test('preserves Set objects', () => {
+            const set = new Set([1, 2, 3, 'a', 'b'])
+            const input = { items: set }
+            const result = jss.parse(jss.stringify(input))
+            expect(result.items).toBeInstanceOf(Set)
+            expect(result.items.has(1)).toBe(true)
+            expect(result.items.has('a')).toBe(true)
+            expect(result.items.size).toBe(5)
+        })
+
+        test('preserves Map objects', () => {
+            const map = new Map([['key1', 'value1'], ['key2', 42]])
+            const input = { data: map }
+            const result = jss.parse(jss.stringify(input))
+            expect(result.data).toBeInstanceOf(Map)
+            expect(result.data.get('key1')).toBe('value1')
+            expect(result.data.get('key2')).toBe(42)
+        })
+    })
+
+    describe('Objects and Arrays', () => {
+        test('handles nested objects', () => {
+            const input = {
+                user: {
+                    name: 'Alice',
+                    profile: {
+                        age: 30
+                    }
+                }
+            }
+            const result = jss.parse(jss.stringify(input))
+            expect(result.user.name).toBe('Alice')
+            expect(result.user.profile.age).toBe(30)
+        })
+
+        test('handles arrays', () => {
+            const input = { items: [1, 2, 3, 'four', 'five'] }
+            const result = jss.parse(jss.stringify(input))
+            expect(result.items).toEqual([1, 2, 3, 'four', 'five'])
+        })
+
+        test('handles arrays with Dates', () => {
+            const date = new Date('2025-06-15')
+            const input = { mixed: ['text', 42, date, null] }
+            const result = jss.parse(jss.stringify(input))
+            expect(result.mixed[0]).toBe('text')
+            expect(result.mixed[1]).toBe(42)
+            expect(result.mixed[2]).toBeInstanceOf(Date)
+            expect(result.mixed[3]).toBe(null)
+        })
+    })
+
+    describe('encode/decode', () => {
+        test('encode returns tagged object for Date', () => {
+            const input = { d: new Date('2025-01-01') }
+            const encoded = jss.encode(input)
+            expect(encoded['d<!D>']).toBeDefined()
+        })
+
+        test('decode restores Date from tagged object', () => {
+            const encoded = { 'd<!D>': 1735689600000 }
+            const decoded = jss.decode(encoded)
+            expect(decoded.d).toBeInstanceOf(Date)
+        })
+
+        test('encode handles Error type', () => {
+            const input = { e: new Error('test') }
+            const encoded = jss.encode(input)
+            expect(encoded['e<!E>']).toBeDefined()
+        })
+
+        test('encode handles Set type', () => {
+            const input = { s: new Set([1, 2]) }
+            const encoded = jss.encode(input)
+            expect(encoded['s<!S>']).toBeDefined()
+        })
+
+        test('encode handles Map type', () => {
+            const input = { m: new Map([['a', 1]]) }
+            const encoded = jss.encode(input)
+            expect(encoded['m<!M>']).toBeDefined()
+        })
+    })
+
+    describe('Circular References', () => {
+        test('handles self-referencing object', () => {
+            const original = {
+                id: 123,
+                name: 'Test'
+            }
+            original.foo = original
+
+            const encoded = jss.encode(original)
+            const result = jss.decode(encoded)
+
+            expect(result.id).toBe(123)
+            expect(result.name).toBe('Test')
+            expect(result.foo).toBe(result)
+        })
+
+        test('handles self-referencing object', () => {
+            const original = {
+                name: 'Test',
+                cat: {
+                    cars: true
+                },
+                bar: {
+                    baz: true
+                }
+            }
+            original.cat.foo = original.bar.baz
+
+            const encoded = jss.encode(original)
+            const result = jss.decode(encoded)
+
+            expect(result.cat.foo).toBe(result.bar.baz)
+        })
+
+        test('handles multiple self-references', () => {
+            const original = { id: 1 }
+            original.refA = original
+            original.refB = original
+
+            const result = jss.decode(jss.encode(original))
+
+            expect(result.refA).toBe(result)
+            expect(result.refB).toBe(result)
+        })
+    })
+
+    describe('Shared References', () => {
+        test('shared object referenced twice', () => {
+            const shared = { value: 42 }
+            const original = {
+                first: shared,
+                second: shared
+            }
+
+            const result = jss.decode(jss.encode(original))
+
+            expect(result.first.value).toBe(42)
+            expect(result.second.value).toBe(42)
+            expect(result.first).toBe(result.second) // same object reference
+        })
+
+        test('shared object in array', () => {
+            const shared = { id: 'shared' }
+            const original = {
+                items: [shared, shared, shared]
+            }
+
+            const result = jss.decode(jss.encode(original))
+
+            expect(result.items[0]).toBe(result.items[1])
+            expect(result.items[1]).toBe(result.items[2])
+        })
+
+        test('deeply nested shared reference', () => {
+            const shared = { data: 'test' }
+            const original = {
+                level1: {
+                    level2: {
+                        ref: shared
+                    }
+                },
+                otherRef: shared
+            }
+
+            const result = jss.decode(jss.encode(original))
+
+            expect(result.level1.level2.ref.data).toBe('test')
+            expect(result.level1.level2.ref).toBe(result.otherRef)
+        })
+    })
+
+    describe('Round-trip', () => {
+        test('object with multiple special types survives round-trip', () => {
+            const original = {
+                id: 123,
+                name: 'Test',
+                createdAt: new Date(),
+                tags: new Set(['a', 'b']),
+                meta: new Map([['x', 1]])
+            }
+            const result = jss.parse(jss.stringify(original))
+
+            expect(result.id).toBe(original.id)
+            expect(result.name).toBe(original.name)
+            expect(result.createdAt.getTime()).toBe(original.createdAt.getTime())
+            expect(result.tags).toBeInstanceOf(Set)
+            expect(result.meta).toBeInstanceOf(Map)
+        })
+    })
+})

package/utils/messageHash.js

@@ -0,0 +1,43 @@
+const alphabet = "0123456789ABCDEFGHJKMNPQRSTVWXYZ"
+/*
+function charValue(char){
+    return alphabet.indexOf(char.toUpperCase())
+} // END charValue
+
+function fromBase32(b32){
+    if (0 === b32.length) {
+        return 0
+    }
+    return charValue(b32.slice(-1)) + fromBase32(b32.slice(0,-1)) * 32
+} // END fromBase32
+*/
+function toBase32 (n){
+    const remainder = Math.floor(n/32)
+    const current = n % 32
+    if (0 === remainder) {
+        return alphabet[current]
+    }
+    return toBase32(remainder)+alphabet[current]
+} // END toBase32
+
+function jenkinsOneAtATimeHash(keyString){
+    
+  var hash = 0
+  
+  for (var charIndex = 0; charIndex < keyString.length; ++charIndex)
+  {
+    hash += keyString.charCodeAt(charIndex);
+    hash += hash << 10;
+    hash ^= hash >> 6;
+  }
+  hash += hash << 3;
+  hash ^= hash >> 11;
+  //4,294,967,295 is FFFFFFFF, the maximum 32 bit unsigned integer value, used here as a mask.
+  return (((hash + (hash << 15)) & 4294967295) >>> 0)
+} // END jenkinsOneAtATimeHash
+
+function messageHash(messageSt){
+    return toBase32(jenkinsOneAtATimeHash(messageSt))
+} // END messageHash
+
+module.exports = messageHash

package/utils/messageHash.test.js

@@ -0,0 +1,56 @@
+const messageHash = require('./messageHash')
+
+describe('messageHash', () => {
+
+    test('returns consistent hash for same input', () => {
+        const input = 'hello world'
+        const hash1 = messageHash(input)
+        const hash2 = messageHash(input)
+        expect(hash1).toBe(hash2)
+    })
+
+    test('returns different hashes for different inputs', () => {
+        const hash1 = messageHash('message one')
+        const hash2 = messageHash('message two')
+        expect(hash1).not.toBe(hash2)
+    })
+
+    test('returns base32-encoded string', () => {
+        const hash = messageHash('test message')
+        // Base32 alphabet used: 0-9, A-Z excluding I, L, O, U
+        expect(hash).toMatch(/^[0-9A-HJKMNP-TV-Z]+$/)
+    })
+
+    test('handles empty string', () => {
+        const hash = messageHash('')
+        expect(typeof hash).toBe('string')
+        expect(hash.length).toBeGreaterThan(0)
+    })
+
+    test('handles special characters', () => {
+        const hash = messageHash('特殊文字 🎉 emoji!')
+        expect(typeof hash).toBe('string')
+        expect(hash.length).toBeGreaterThan(0)
+    })
+
+    test('handles long strings', () => {
+        const longString = 'x'.repeat(10000)
+        const hash = messageHash(longString)
+        expect(typeof hash).toBe('string')
+        // Hash should be compact regardless of input length
+        expect(hash.length).toBeLessThan(20)
+    })
+
+    test('handles JSON strings', () => {
+        const json = JSON.stringify({ type: '/message', data: { user: 'test' } })
+        const hash = messageHash(json)
+        expect(typeof hash).toBe('string')
+        expect(hash.length).toBeGreaterThan(0)
+    })
+
+    test('different order produces different hash', () => {
+        const hash1 = messageHash('abc')
+        const hash2 = messageHash('bca')
+        expect(hash1).not.toBe(hash2)
+    })
+})