wao 0.41.3 → 0.41.5

package/hbsig/dist/cjs/erl_json.js

@@ -0,0 +1,326 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.erl_json_from = erl_json_from;
+exports.erl_json_to = erl_json_to;
+exports.normalize = normalize;
+function _slicedToArray(r, e) { return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(r) { if (Array.isArray(r)) return r; }
+function _toConsumableArray(r) { return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }
+function _arrayWithoutHoles(r) { if (Array.isArray(r)) return _arrayLikeToArray(r); }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+/**
+ * Codec for converting between JS objects with Erlang types and annotated JSON
+ * Only handles types that HyperBEAM supports
+ */
+
+/**
+ * Convert annotated JSON to JS object with Erlang types
+ * @param {Object} json - Annotated JSON object
+ * @returns {*} - JS object with Buffer for binaries, Symbol for atoms
+ */
+function erl_json_from(json) {
+  return convertFromAnnotatedJSON(json);
+}
+
+/**
+ * Convert JS object with Erlang types to annotated JSON
+ * @param {*} jsObj - JS object with Erlang types
+ * @returns {Object} - Annotated JSON object
+ */
+function erl_json_to(jsObj) {
+  return convertToAnnotatedJSON(jsObj);
+}
+
+/**
+ * Normalize JS values to match what comes back from Erlang through erl_str_from
+ * This function is deterministic and matches the behavior of the Erlang round-trip
+ * @param {*} obj - JS object to normalize
+ * @param {boolean} binaryMode - true for binary mode, false for string mode (default)
+ * @returns {*} - Normalized JS object
+ */
+function normalize(obj) {
+  var binaryMode = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+  if (obj === null) return null;
+  if (obj === undefined) return undefined;
+
+  // Handle symbols - convert to their special cases or match erl_str_from behavior
+  if (_typeof(obj) === "symbol") {
+    var key = Symbol.keyFor(obj);
+    var name = key || obj.description || obj.toString().slice(7, -1);
+
+    // Special symbols that become primitives
+    if (name === "null") return null;
+    if (name === "true") return true;
+    if (name === "false") return false;
+
+    // Note: Symbol('undefined') stays as Symbol.for('undefined')
+    // It does NOT become JavaScript undefined
+    // This matches what erl_str_from actually returns
+
+    // For all symbols (including 'undefined'), convert to global symbol
+    // This is because non-global symbols can't round-trip through JSON
+    // Symbol('ok') -> '%ok%' -> Symbol.for('ok')
+    return Symbol["for"](name);
+  }
+
+  // Strings
+  if (typeof obj === "string") {
+    // Special case: "::" becomes empty buffer through Erlang
+    if (obj === "::") {
+      return Buffer.alloc(0);
+    }
+    if (binaryMode) {
+      // In binary mode, convert strings to buffers
+      // Use binary/latin1 encoding only if all chars are <= 255 (preserves raw bytes)
+      // Use UTF-8 for strings with chars > 255 (proper multi-byte encoding)
+      var needsUtf8 = _toConsumableArray(obj).some(function (ch) {
+        return ch.codePointAt(0) > 255;
+      });
+      return Buffer.from(obj, needsUtf8 ? "utf8" : "binary");
+    } else {
+      // In string mode, strings stay as strings
+      return obj;
+    }
+  }
+
+  // Other primitives pass through
+  if (typeof obj === "number" || typeof obj === "boolean") {
+    return obj;
+  }
+
+  // Buffers pass through
+  if (obj instanceof Buffer || obj instanceof Uint8Array) {
+    return Buffer.from(obj);
+  }
+
+  // Arrays - normalize each element
+  if (Array.isArray(obj)) {
+    return obj.map(function (item) {
+      // undefined in arrays becomes null (JSON behavior)
+      if (item === undefined) {
+        return null;
+      }
+      return normalize(item, binaryMode);
+    });
+  }
+
+  // Objects - normalize each value and remove undefined values
+  if (_typeof(obj) === "object" && obj !== null) {
+    var result = {};
+    for (var _i = 0, _Object$entries = Object.entries(obj); _i < _Object$entries.length; _i++) {
+      var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
+        k = _Object$entries$_i[0],
+        v = _Object$entries$_i[1];
+      var normalized = normalize(v, binaryMode);
+      // Skip undefined values in objects
+      if (normalized !== undefined) {
+        result[k] = normalized;
+      }
+    }
+    return result;
+  }
+  return obj;
+}
+
+// Convert from annotated JSON to JS with Erlang types
+function convertFromAnnotatedJSON(json) {
+  // Handle null/undefined
+  if (json === null) {
+    return null;
+  }
+  if (json === undefined) {
+    return undefined;
+  }
+
+  // Handle booleans
+  if (json === true || json === false) {
+    return json;
+  }
+
+  // Handle numbers and strings
+  if (typeof json === "number") {
+    return json;
+  }
+  if (typeof json === "string") {
+    // Check for binary structured field format :base64:
+    if (json.startsWith(":") && json.endsWith(":") && json.length >= 2) {
+      try {
+        // Handle empty binary special case
+        if (json === "::") {
+          return Buffer.alloc(0);
+        }
+        // Simple base64 decode for structured field binaries
+        var base64 = json.slice(1, -1);
+        return Buffer.from(base64, "base64");
+      } catch (e) {
+        // Not valid base64, return as-is
+        return json;
+      }
+    }
+    // Check for token structured field format %token%
+    if (json.startsWith("%") && json.endsWith("%") && json.length >= 2) {
+      // Handle empty token special case
+      if (json === "%%") {
+        return Symbol["for"]("");
+      }
+      // Extract token and convert to symbol
+      var token = json.slice(1, -1);
+      return Symbol["for"](token);
+    }
+    // Handle empty string from empty binary conversion
+    if (json === "") {
+      // In context, this might be an empty binary, but we can't be sure
+      // so we return it as-is
+      return json;
+    }
+    return json;
+  }
+
+  // Handle arrays
+  if (Array.isArray(json)) {
+    return json.map(function (item) {
+      return convertFromAnnotatedJSON(item);
+    });
+  }
+
+  // Handle objects
+  if (json && _typeof(json) === "object") {
+    var keys = Object.keys(json);
+
+    // Check for type annotations (single key objects)
+    if (keys.length === 1) {
+      var key = keys[0];
+      var value = json[key];
+      switch (key) {
+        case "$empty":
+          switch (value) {
+            case "binary":
+              return Buffer.alloc(0);
+            case "list":
+              return [];
+            case "map":
+              return {};
+            default:
+              return json;
+          }
+      }
+    }
+
+    // Regular object - convert recursively
+    var result = {};
+    for (var _i2 = 0, _Object$entries2 = Object.entries(json); _i2 < _Object$entries2.length; _i2++) {
+      var _Object$entries2$_i = _slicedToArray(_Object$entries2[_i2], 2),
+        k = _Object$entries2$_i[0],
+        v = _Object$entries2$_i[1];
+      result[k] = convertFromAnnotatedJSON(v);
+    }
+    return result;
+  }
+
+  // Fallback
+  return json;
+}
+
+// Convert from JS with Erlang types to annotated JSON
+function convertToAnnotatedJSON(obj) {
+  // Handle null - pass through as JSON null
+  if (obj === null) {
+    return null;
+  }
+
+  // Handle undefined - convert to null (JSON doesn't support undefined)
+  if (obj === undefined) {
+    return null;
+  }
+
+  // Handle booleans - pass through as JSON booleans
+  if (typeof obj === "boolean") {
+    return obj;
+  }
+
+  // Handle numbers - pass through
+  if (typeof obj === "number") {
+    return obj;
+  }
+
+  // Handle strings - pass through
+  if (typeof obj === "string") {
+    return obj;
+  }
+
+  // Handle symbols (atoms) - use token structured field format
+  if (_typeof(obj) === "symbol") {
+    // Try to get the key from the global symbol registry
+    var key = Symbol.keyFor(obj);
+    // If it's not a global symbol, use its description
+    var name = key || obj.description || obj.toString().slice(7, -1);
+
+    // Special atoms that become JSON values
+    if (name === "null") return null;
+    if (name === "true") return true;
+    if (name === "false") return false;
+
+    // Other atoms become token structured fields
+    return "%".concat(name, "%");
+  }
+
+  // Handle Buffers/Uint8Arrays (binaries)
+  if (obj instanceof Buffer || obj instanceof Uint8Array) {
+    if (obj.length === 0) {
+      return {
+        $empty: "binary"
+      };
+    }
+    // Use structured fields format for binaries
+    return ":".concat(Buffer.from(obj).toString("base64"), ":");
+  }
+
+  // Handle arrays
+  if (Array.isArray(obj)) {
+    if (obj.length === 0) {
+      return {
+        $empty: "list"
+      };
+    }
+    return obj.map(function (item) {
+      return convertToAnnotatedJSON(item);
+    });
+  }
+
+  // Handle objects
+  if (_typeof(obj) === "object" && obj !== null) {
+    var result = {};
+    var hasKeys = false;
+    for (var _i3 = 0, _Object$entries3 = Object.entries(obj); _i3 < _Object$entries3.length; _i3++) {
+      var _Object$entries3$_i = _slicedToArray(_Object$entries3[_i3], 2),
+        k = _Object$entries3$_i[0],
+        v = _Object$entries3$_i[1];
+      // Skip undefined values completely
+      if (v === undefined) {
+        continue;
+      }
+      hasKeys = true;
+      result[k] = convertToAnnotatedJSON(v);
+    }
+
+    // Return $empty annotation if no keys remain
+    if (!hasKeys) {
+      return {
+        $empty: "map"
+      };
+    }
+    return result;
+  }
+
+  // Fallback
+  return obj;
+}