Refactor

Author: dingosky

src/lib/encoder.spec.ts

@@ -4,36 +4,37 @@ import { Chars } from './chars'
 import alphaEncoder from './encoder/alpha'
 import alphaCaseEncoder from './encoder/alphaCase'
 import alphaNumEncoder from './encoder/alphaNum'
+import alphaNumCaseEncoder from './encoder/alphaNumCase'
 import base32Encoder from './encoder/base32'
 import base32HexCaseEncoder from './encoder/base32HexCase'
 import decimalEncoder from './encoder/decimal'
 import hexCaseEncoder from './encoder/hexCase'
 import safe32Encoder from './encoder/safe32'
 import safe64Encoder from './encoder/safe64'
 import safeAsciiEncoder from './encoder/safeAscii'
+import symbolEncoder from './encoder/symbol'
 
 type PuidEncoder = (n: number) => number
-const encoderString = (n: number, encoder: PuidEncoder) =>
-  String.fromCodePoint(
-    ...new Array(n)
-      .fill(0)
-      .map((zero, ndx) => zero + ndx)
-      .map((v) => encoder(v))
-  )
 
-const testEncoder = (t: ExecutionContext, encoder: PuidEncoder, chars: string) =>
-  t.is(encoderString(chars.length, encoder), chars)
+const encoder = (t: ExecutionContext, encoder: PuidEncoder, chars: string) => {
+  const codes = [...Array(chars.length).keys()].map(code => encoder(code))
+  const encoded = String.fromCharCode(...codes)
+  t.is(encoded, chars)
+}
 
-test('alpha() encoder', (t) => testEncoder(t, alphaEncoder(), Chars.Alpha))
-test('alphaCase() encoder', (t) => testEncoder(t, alphaCaseEncoder(), Chars.AlphaLower))
-test('alphaCase(true) encoder', (t) => testEncoder(t, alphaCaseEncoder(true), Chars.AlphaUpper))
-test('alphaNumEncoder() encoder', (t) => testEncoder(t, alphaNumEncoder(), Chars.AlphaNum))
-test('base32Encoder() encoder', (t) => testEncoder(t, base32Encoder(), Chars.Base32))
-test('base32HexCaseEncoder() encoder', (t) => testEncoder(t, base32HexCaseEncoder(), Chars.Base32Hex))
-test('base32HexCaseEncoder(true) encoder', (t) => testEncoder(t, base32HexCaseEncoder(true), Chars.Base32HexUpper))
-test('decimalEncoder() encoder', (t) => testEncoder(t, decimalEncoder(), Chars.Decimal))
-test('hexCaseEncoder() encoder', (t) => testEncoder(t, hexCaseEncoder(), Chars.Hex))
-test('hexCaseEncoder(true) encoder', (t) => testEncoder(t, hexCaseEncoder(true), Chars.HexUpper))
-test('safe32Encoder() encoder', (t) => testEncoder(t, safe32Encoder(), Chars.Safe32))
-test('safe64Encoder encoder', (t) => testEncoder(t, safe64Encoder(), Chars.Safe64))
-test('safeAsciiEncoder() encoder', (t) => testEncoder(t, safeAsciiEncoder(), Chars.SafeAscii))
+test('alpha() encoder chars', (t) => encoder(t, alphaEncoder(), Chars.Alpha))  
+test('alphaCase() encoder chars', (t) => encoder(t, alphaCaseEncoder(), Chars.AlphaLower))
+test('alphaCase(true) encoder chars', (t) => encoder(t, alphaCaseEncoder(true), Chars.AlphaUpper))
+test('alphaNumEncoder() encoder chars', (t) => encoder(t, alphaNumEncoder(), Chars.AlphaNum))
+test('alphaNumCaseEncoder() encoder chars', (t) => encoder(t, alphaNumCaseEncoder(), Chars.AlphaNumLower))
+test('alphaNumCaseEncoder(true) encoder chars', (t) => encoder(t, alphaNumCaseEncoder(true), Chars.AlphaNumUpper))
+test('base32Encoder() encoder chars', (t) => encoder(t, base32Encoder(), Chars.Base32))
+test('base32HexCaseEncoder() encoder chars', (t) => encoder(t, base32HexCaseEncoder(), Chars.Base32Hex))
+test('base32HexCaseEncoder(true) encoder chars', (t) => encoder(t, base32HexCaseEncoder(true), Chars.Base32HexUpper))
+test('decimalEncoder() encoder chars', (t) => encoder(t, decimalEncoder(), Chars.Decimal))
+test('hexCaseEncoder() encoder chars', (t) => encoder(t, hexCaseEncoder(), Chars.Hex))
+test('hexCaseEncoder(true) encoder chars', (t) => encoder(t, hexCaseEncoder(true), Chars.HexUpper))
+test('safeAsciiEncoder() encoder chars', (t) => encoder(t, safeAsciiEncoder(), Chars.SafeAscii))
+test('safe32Encoder() encoder chars', (t) => encoder(t, safe32Encoder(), Chars.Safe32))
+test('safe64Encoder encoder chars', (t) => encoder(t, safe64Encoder(), Chars.Safe64))
+test('symbolEncoder() encoder chars', (t) => encoder(t, symbolEncoder(), Chars.Symbol))

src/lib/encoder.ts

@@ -31,21 +31,11 @@ import safe32Encoder from './encoder/safe32'
 import safe64Encoder from './encoder/safe64'
 import safeAsciiEncoder from './encoder/safeAscii'
 
-// const predefinedEncoding = (encoder: PuidEncoder) => (puidValues: PuidValues) => puidFromValues(puidValues, encoder)
-
-// const customEncoding = (chars: string): PuidEncoding => {
-//   const encoder = customCharsEncoder(chars)
-//   return (puidValues: PuidValues) => puidFromValues(puidValues, encoder)
-// }
-
 export const customCharsEncoder = (chars: string): PuidEncoder => {
   const charCodes = chars.split('').map((c) => c.charCodeAt(0))
   return (n: number) => charCodes[n]
 }
 
-// export const puidFromValues = (values: PuidValues, encoder: PuidEncoder): string =>
-//   String.fromCharCode(...values.map((v) => encoder(v)))
-
 export default (chars: string): PuidEncoder => {
   if (chars === Chars.Alpha) return alphaEncoder()
   if (chars === Chars.AlphaLower) return alphaCaseEncoder()

src/lib/encoder/safe64.ts

@@ -24,14 +24,14 @@ export default (): PuidEncoder => {
   const decimal = '0'.charCodeAt(0)
   const upper = 'A'.charCodeAt(0) - 10
   const lower = 'a'.charCodeAt(0) - 36
-  const hyphen = '-'.charCodeAt(0) - 62
-  const underscore = '_'.charCodeAt(0) - 63
+  const hyphen = '-'.charCodeAt(0)
+  const underscore = '_'.charCodeAt(0)
 
   return (n: number) => {
     if (n < 10) return n + decimal
     if (n < 36) return n + upper
     if (n < 62) return n + lower
-    if (n === 62) return n + hyphen
-    return n + underscore
+    if (n === 62) return hyphen
+    return underscore
   }
 }

src/lib/encoder/symbol.ts

@@ -21,21 +21,21 @@
 // SOFTWARE.
 
 export default (): PuidEncoder => {
-  const s1 = '!'.charCodeAt(0)
-  const s2 = '#'.charCodeAt(0) - 1
-  const s3 = '('.charCodeAt(0) - 5
-  const s4 = ':'.charCodeAt(0) - 13
-  const s5 = '['.charCodeAt(0)
-  const s6 = ']'.charCodeAt(0) - 21
-  const s7 = '{'.charCodeAt(0) - 24
+  const bang = '!'.charCodeAt(0)
+  const hash = '#'.charCodeAt(0) - 1
+  const openParen = '('.charCodeAt(0) - 5
+  const colon = ':'.charCodeAt(0) - 13
+  const openSquareBracket = '['.charCodeAt(0)
+  const closeSquareBracket = ']'.charCodeAt(0) - 21
+  const openCurlyBracket = '{'.charCodeAt(0) - 24
 
   return (n: number) => {
-    if (n === 0) return s1
-    if (n < 5) return n + s2
-    if (n < 13) return n + s3
-    if (n < 20) return n + s4
-    if (n === 20) return s5
-    if (n < 24) return n + s6
-    return n + s7
+    if (n === 0) return bang
+    if (n < 5) return n + hash
+    if (n < 13) return n + openParen
+    if (n < 20) return n + colon
+    if (n === 20) return openSquareBracket
+    if (n < 24) return n + closeSquareBracket
+    return n + openCurlyBracket
   }
 }