@lumjs/encode 2.0.0 → 2.1.0

package/CHANGELOG.md

@@ -6,6 +6,25 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.1.0]
+### Changed
+- The `base64` library now supports the `Uint8Array.fromBase64` static method,
+  and the corresponding `toBase64()` instance method. As those are rather new
+  APIs and aren't supported by every JS runtime yet, it will check for them and
+  use them if found, and fall back to the prior implementation otherwise.
+- Updated this changelog, as I forgot to after 2.0 was released last year.
+
+## [2.0.0] - 2024-08-14
+### Changed
+- A major overhaul, removing the dependency on `crypto-js` library.
+- Rewrote `base64` library to use `atob`, `btoa`, `TextEncoder`, and `TextDecoder`.
+- Rewrote `hash` library using the modern `SubtleCrypto` APIs.
+- Moved `urlize()` and `deurlize()` functions into `base64` library.
+### Removed
+- The `crypto` sub-module which was designed as a wrapper for `crypto-js`.
+- The `safe64` library has been moved into a standalone [safe64-data] package.
+- Dependencies on `php-serialize` and `ubjson` which were only used by `safe64`.
+
 ## [1.2.0] - 2023-01-06
 ### Changed
 - Bumped `@lumjs/core` to `1.8.0`.
@@ -23,7 +42,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Added
 - Initial release.
 
-[Unreleased]: https://github.com/supernovus/lum.encode.js/compare/v1.2.0...HEAD
+[Unreleased]: https://github.com/supernovus/lum.encode.js/compare/v2.1.0...HEAD
+[2.1.0]: https://github.com/supernovus/lum.encode.js/compare/v2.0.0...v2.1.0
+[2.0.0]: https://github.com/supernovus/lum.encode.js/compare/v1.2.0...v2.0.0
 [1.2.0]: https://github.com/supernovus/lum.encode.js/compare/v1.1.0...v1.2.0
 [1.1.0]: https://github.com/supernovus/lum.encode.js/compare/v1.0.0...v1.1.0
 [1.0.0]: https://github.com/supernovus/lum.encode.js/releases/tag/v1.0.0
+[safe64-data]: https://github.com/supernovus/lum.safe64-data.js
+

package/lib/base64.js

@@ -1,11 +1,15 @@
 
-const {S,B,isObj} = require('@lumjs/core/types');
+const {S,B,F,isObj} = require('@lumjs/core/types');
 
 const D_MIME = 'application/octet-stream';
 const D_ENC  = 'utf-8';
 const P_DATA = 'data:';
 const P_B64  = ';base64,';
 const R_PRE  = /^data\:(.*?);base64,/;
+const B_64U  = 'base64url';
+
+const UI8_FB64  = (typeof Uint8Array.fromBase64 === F);
+const URL_CHARS = /_-/;
 
 /**
  * Base64 functions.
@@ -63,12 +67,22 @@ function deurlize(string)
  * 
  * This is a low-level function with no options.
  * See `decodeText()` for a more full-featured function.
+ *
+ * This now checks to see if `Uint8Array.fromBase64()` exists,
+ * and if it does, will use it. Otherwise it uses the original
+ * encoding algorithm.
  * 
  * @param {string} base64 - Base64 encoded-string
+ * @param {object} [options] Passed to fromBase64() if it exists
  * @returns {Uint8Array}
  */
-function toBytes(base64)
+function toBytes(base64, options={})
 {
+  if (UI8_FB64)
+  {
+    return Uint8Array.fromBase64(base64, options);
+  }
+
   const binString = atob(base64);
   return Uint8Array.from(binString, (m) => m.codePointAt(0));
 }
@@ -78,12 +92,22 @@ function toBytes(base64)
  * 
  * This is a low-level function with no options.
  * See `encodeText()` for a more full-featured function.
+ *
+ * This now checks to see if `bytes.toBase64()` exists,
+ * and if it does, will use it. Otherwise it uses the original
+ * decoding algorithm.
  * 
  * @param {Uint8Array} bytes - Byte array to convert
+ * @param {object} [options] Passed to toBase64() if it exists
  * @returns {string}
  */
-function fromBytes(bytes)
+function fromBytes(bytes, options={})
 {
+  if (typeof bytes.toBase64 === F)
+  {
+    return bytes.toBase64(options);
+  }
+
   const binString = Array.from(bytes, (byte) =>
     String.fromCodePoint(byte),
   ).join("");
@@ -115,8 +139,23 @@ function encodeText(data, options={})
   }
 
   const encoder = new TextEncoder();
-  const base64 = fromBytes(encoder.encode(data));
-  return options.url ? urlize(base64, options) : base64;
+  data = encoder.encode(data);
+  const toB64 = (typeof data.toBase64 === F);
+
+  if (toB64 && options.url)
+  {
+    if (typeof options.alphabet !== S)
+    {
+      options.alphabet = B_64U;
+    }
+    if (!options.useTildes && typeof options.omitPadding !== B)
+    {
+      options.omitPadding = true;
+    }
+  }
+
+  const base64 = fromBytes(data, options);
+  return (options.url && !toB64) ? urlize(base64, options) : base64;
 }
 
 /**
@@ -149,12 +188,25 @@ function decodeText(base64, options={})
 
   if (options.url !== false)
   { // Unless explicitly disabled, use deurlize() first.
-    base64 = deurlize(base64);
+    if (UI8_FB64)
+    {
+      if (typeof options.alphabet !== S)
+      {
+        if (URL_CHARS.test(base64))
+        {
+          options.alphabet = B_64U;
+        }
+      }
+    }
+    else
+    { 
+      base64 = deurlize(base64);
+    }
   }
 
   const encoding = options.encoding ?? D_ENC;
   const decoder = new TextDecoder(encoding, options);
-  return decoder.decode(toBytes(base64), options);
+  return decoder.decode(toBytes(base64, options), options);
 }
 
 /**
@@ -373,4 +425,6 @@ module.exports =
   toDataUrl, fromDataUrl,
   encodeData, decodeData,
   encode, decode,
+  NATIVE_BASE64: UI8_FB64,
 }
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lumjs/encode",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "main": "lib/index.js",
   "exports":
   {