feat: b64encode() and b64decode()

Author: waitingsong

package.json

@@ -1,28 +1,33 @@
 {
-  "name": "npm-base",
+  "name": "@waiting/base64",
   "author": "waiting",
   "version": "0.0.1",
-  "description": "npm boilerplate",
+  "description": "Base64 encoding/decoding in pure JS on both modern Browsers and Node.js",
   "keywords": [
-    "种子项目",
+    "base64",
+    "browser",
+    "Node.js",
+    "rfc4648",
+    "TextEncoder",
+    "TextDecoder",
     "typescript"
   ],
   "engines": {
     "node": ">=8.10.0"
   },
   "bin": {},
-  "browser": "",
+  "browser": "./dist/index.esm.js",
   "es2015": "./dist/index.esm.js",
   "main": "./dist/index.cjs.js",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "bugs": {
-    "url": "https://github.com/waitingsong/npm-base/issues"
+    "url": "https://github.com/waitingsong/base64/issues"
   },
-  "homepage": "https://github.com/waitingsong/npm-base#readme",
+  "homepage": "https://github.com/waitingsong/base64#readme",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/waitingsong/npm-base.git"
+    "url": "git+https://github.com/waitingsong/base64.git"
   },
   "license": "MIT",
   "nyc": {
@@ -46,16 +51,14 @@
     ],
     "all": true
   },
-  "dependencies": {
-    "@waiting/shared-core": "^1.9.1",
-    "rxjs": "^6.5.2"
-  },
+  "dependencies": {},
   "devDependencies": {
     "@types/mocha": "*",
     "@types/node": "^12.0.2",
     "@types/power-assert": "*",
     "@types/rewire": "*",
     "@types/rimraf": "*",
+    "@waiting/shared-core": "^1.9.1",
     "@types/yargs": "^13.0.0",
     "coveralls": "^3.0.3",
     "intelli-espower-loader": "^1.0.1",

src/index.ts

@@ -0,0 +1,5 @@
+
+export * from './lib/index'
+export * from './lib/model'
+export { ErrorMsg } from './lib/config'
+export { validB64Chars } from './lib/helper'

src/lib/browser.ts

@@ -0,0 +1,66 @@
+import {
+  ErrorMsg,
+} from './config'
+import { fromUint8Array } from './from_buffer'
+import {
+  parseDecodeInputBase64,
+  parseEncodeInputString,
+  parseTextDecoder,
+  parseTextEncoder,
+} from './helper'
+import { TextDecoderFn, TextEncoderFn } from './model'
+import { toUint8Array } from './to_buffer'
+
+
+export function browserEncode(
+  input: string | number | bigint,
+  textEncoder?: TextEncoderFn,
+): string {
+
+  const str: string = parseEncodeInputString(input)
+  const Encoder = parseTextEncoder(textEncoder)
+  const u8arr = new Encoder().encode(str)
+  const ret = fromBuffer(u8arr)
+
+  return ret
+}
+
+
+/** Encode to base64, source from ArrayBuffer or Uint8Array */
+export function fromBuffer(buf: ArrayBuffer | Uint8Array): string {
+  let input: Uint8Array
+
+  if (! buf) {
+    throw new TypeError(ErrorMsg.fromArrayBufferInvalidParam)
+  }
+  else if (ArrayBuffer.isView(buf)) {
+    input = buf
+  }
+  else {
+    input = new Uint8Array(buf)
+  }
+
+  return fromUint8Array(input)
+}
+
+
+export function browserDecode(
+  base64: string,
+  outputEncoding: string = 'utf-8',
+  textDecoder?: TextDecoderFn,
+): string {
+
+  const Decoder = parseTextDecoder(textDecoder)
+  const u8arr = toBuffer(base64)
+  const ret = new Decoder(outputEncoding).decode(u8arr)
+
+  return ret
+}
+
+
+export function toBuffer(base64: string): Uint8Array {
+  const str = parseDecodeInputBase64(base64)
+  const u8arr = toUint8Array(str)
+
+  return u8arr
+}

src/lib/config.ts

@@ -0,0 +1,27 @@
+
+export const baseChars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
+export const lookup: string[] = [...baseChars]
+export const revLookup: number[] = []
+
+for (let i = 0, len = lookup.length; i < len; ++i) {
+  revLookup[lookup[i].charCodeAt(0)] = i
+}
+
+// Support decoding URL-safe base64 strings, as Node.js does.
+// See: https://en.wikipedia.org/wiki/Base64#URL_applications
+revLookup['-'.charCodeAt(0)] = 62
+revLookup['_'.charCodeAt(0)] = 63
+
+export const ErrorMsg = {
+  fromArrayBufferInvalidParam: 'Invalid input, should be ArrayBuffer or Uint8Array',
+  base64Invalidlength: 'Invalid string. Length must be a multiple of 4',
+  notString: 'Invalid value of parameter, should be string',
+  encodeInvalidParam: 'Invalid value of parameter of encode(), should be string|number|bigint',
+  notValidB64String: 'Valid base64 string only contains /^[a-zA-Z0-9+/_-]+={0,2}$/',
+  textEncoderUndefined: 'TextEncoder undefined!',
+  textDecoderUndefined: 'TextDecoder undefined!',
+}
+
+export const defaultConfig = {
+  forceBrowser: false,
+}

src/lib/from_buffer.ts

@@ -0,0 +1,67 @@
+// rewrite from https://github.com/beatgammit/base64-js
+import { lookup } from './config'
+
+
+export function fromUint8Array(input: Uint8Array): string {
+  /* tslint:disable: no-bitwise */
+  const len = input.length
+  const extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes
+  const len2 = len - extraBytes
+  const maxChunkLength = 12000 // must be multiple of 3
+  const parts: string[] = new Array(
+    Math.ceil(len2 / maxChunkLength) + (extraBytes ? 1 : 0),
+  )
+  let curChunk = 0
+
+  // go through the array every three bytes, we'll deal with trailing stuff later
+  for (let i = 0, nextI = 0; i < len2; i = nextI) {
+    nextI = i + maxChunkLength
+    parts[curChunk] = encodeChunk(input, i, Math.min(nextI, len2))
+    curChunk += 1
+  }
+
+  // pad the end with zeros, but make sure to not forget the extra bytes
+  if (extraBytes === 1) {
+    const tmp = input[len2] & 0xFF
+    parts[curChunk] = lookup[tmp >> 2] + lookup[tmp << 4 & 0x3F] + '=='
+  }
+  else if (extraBytes === 2) {
+    const tmp = (input[len2] & 0xFF) << 8 | (input[len2 + 1] & 0xFF)
+    parts[curChunk] = lookup[tmp >> 10] +
+      lookup[tmp >> 4 & 0x3F] +
+      lookup[tmp << 2 & 0x3F] +
+      '='
+  }
+
+  /* tslint:enable: no-bitwise */
+  return parts.join('')
+}
+
+
+function encodeChunk(input: Uint8Array, start: number, end: number): string {
+  /* tslint:disable: no-bitwise */
+  if (start > end) {
+    throw new Error('parameters of start should less then end')
+  }
+  const ret: string[] = new Array((end - start) / 3)
+  for (let i = start, curTriplet = 0; i < end; i += 3) {
+    ret[curTriplet++] = tripletToBase64(
+      (input[i] & 0xFF) << 16 |
+      (input[i + 1] & 0xFF) << 8 |
+      (input[i + 2] & 0xFF),
+    )
+  }
+  /* tslint:enable: no-bitwise */
+  return ret.join('')
+}
+
+function tripletToBase64(pos: number): string {
+  /* tslint:disable: no-bitwise */
+  const ret = lookup[pos >> 18 & 0x3F] +
+    lookup[pos >> 12 & 0x3F] +
+    lookup[pos >> 6 & 0x3F] +
+    lookup[pos & 0x3F]
+
+  /* tslint:enable: no-bitwise */
+  return ret
+}

src/lib/helper.ts

@@ -0,0 +1,72 @@
+import { ErrorMsg } from './config'
+import { TextDecoderFn, TextEncoderFn } from './model'
+
+
+export function parseEncodeInputString(input: string | number | bigint): string {
+  const ret: string | null = typeof input === 'string'
+    ? input
+    // tslint:disable-next-line: valid-typeof
+    : (typeof input === 'number' || typeof input === 'bigint' ? input.toString() : null)
+
+  if (ret === null) {
+    throw new TypeError(ErrorMsg.encodeInvalidParam)
+  }
+
+  return ret
+}
+
+
+export function parseDecodeInputBase64(base64: string): string {
+  if (typeof base64 !== 'string') {
+    throw new TypeError(ErrorMsg.notString)
+  }
+  else if (!validB64Chars(base64)) {
+    throw new TypeError(ErrorMsg.notValidB64String)
+  }
+
+  return base64
+}
+
+
+export function parseTextEncoder(textEncoder?: TextEncoderFn): TextEncoderFn {
+  const Encoder = typeof textEncoder === 'function'
+    ? textEncoder
+    : (typeof TextEncoder === 'function' ? TextEncoder : null)
+
+  validateEncoder(Encoder)
+  return <TextEncoderFn> Encoder
+}
+
+
+export function parseTextDecoder(textDecoder?: TextDecoderFn): TextDecoderFn {
+  const Decoder = typeof textDecoder === 'function'
+    ? textDecoder
+    : (typeof TextDecoder === 'function' ? TextDecoder : null)
+
+  validateEncoder(Decoder)
+  return <TextDecoderFn> Decoder
+}
+
+
+/** Throw error if input be null */
+export function validateEncoder(input: any): void {
+  if (input === null) {
+    throw new TypeError(ErrorMsg.textEncoderUndefined)
+  }
+}
+
+
+/** Whether string contains valid base64 characters */
+export function validB64Chars(input: string): boolean {
+  const valid = /^[a-zA-Z0-9+/_-]+={0,2}$/.test(input)
+  return valid
+}
+
+
+export function isBrowser(): boolean {
+  // Buffer exists under karma testing
+  const ret = typeof Buffer === 'function' && typeof window === 'undefined'
+    ? false
+    : true
+  return ret
+}

src/lib/index.ts

@@ -0,0 +1,34 @@
+import {
+  browserDecode,
+  browserEncode,
+} from './browser'
+import { defaultConfig } from './config'
+import { isBrowser } from './helper'
+import { TextDecoderFn, TextEncoderFn } from './model'
+import { NodeDecode, NodeEncode } from './nodejs'
+
+
+export function b64encode(
+  input: string | number | bigint,
+  textEncoder?: TextEncoderFn,
+): string {
+
+  const ret = defaultConfig.forceBrowser || isBrowser()
+    ? browserEncode(input, textEncoder)
+    : NodeEncode(input)
+  return ret
+}
+
+
+/** Encode to base64, source from string */
+export function b64decode(
+  base64: string,
+  outputEncoding: string = 'utf-8',
+  textDecoder?: TextDecoderFn,
+): string {
+
+  const ret = defaultConfig.forceBrowser || isBrowser()
+    ? browserDecode(base64, outputEncoding, textDecoder)
+    : NodeDecode(base64, outputEncoding)
+  return ret
+}

src/lib/model.ts

@@ -0,0 +1,13 @@
+import {
+  TextDecoder as NodeTextDecoder,
+  TextEncoder as NodeTextEncoder,
+} from 'util'
+
+export type BrowserTextEncoderType = typeof TextEncoder
+export type BrowserTextDecoderType = typeof TextDecoder
+
+export type NodeTextEncoderType = typeof NodeTextEncoder
+export type NodeTextDecoderType = typeof NodeTextDecoder
+
+export type TextEncoderFn = BrowserTextEncoderType | NodeTextEncoderType
+export type TextDecoderFn = BrowserTextDecoderType | NodeTextDecoderType

src/lib/nodejs.ts

@@ -0,0 +1,45 @@
+import { ErrorMsg } from './config'
+import {
+  parseDecodeInputBase64, parseEncodeInputString,
+} from './helper'
+
+
+export function NodeEncode(
+  input: string | number | bigint,
+): string {
+
+  const str = parseEncodeInputString(input)
+  const ret = Buffer.from(str).toString('base64')
+
+  return ret
+}
+
+export function NodeDecode(
+  base64: string,
+  outputEncoding: string = 'utf-8',
+): string {
+
+  const str = parseDecodeInputBase64(base64)
+  const ret = Buffer.from(str, 'base64').toString(outputEncoding)
+
+  return ret
+}
+
+
+/** Encode to base64, source from ArrayBuffer or Uint8Array */
+export function fromBuffer(buf: ArrayBuffer | Uint8Array): string {
+  let inst: Buffer
+
+  if (! buf) {
+    throw new TypeError(ErrorMsg.fromArrayBufferInvalidParam)
+  }
+  else if (ArrayBuffer.isView(buf)) {
+    inst = Buffer.from(buf)
+  }
+  else {
+    inst = Buffer.from(buf)
+  }
+
+  const ret = inst.toString('base64')
+  return ret
+}