Method devaluateImpl

src/serialize.ts:132–526

(value: unknown, parent: object | undefined, depth: number)

  private exports?: Array<ExportId>;

  private devaluateImpl(value: unknown, parent: object | undefined, depth: number): unknown {
    if (depth >= 64) {
      throw new Error(
          "Serialization exceeded maximum allowed depth. (Does the message contain cycles?)");
    }

    let kind = typeForRpc(value);
    switch (kind) {
      case "unsupported": {
        let msg;
        try {
          msg = `Cannot serialize value: ${value}`;
        } catch (err) {
          msg = "Cannot serialize value: (couldn't stringify value)";
        }
        throw new TypeError(msg);
      }

      case "primitive":
        if (typeof value === "number" && !isFinite(value)) {
          // At structuredClonable level, keep Infinity/NaN as native values
          if (this.encodingLevel === "structuredClonable") {
            return value;
          }
          if (value === Infinity) {
            return ["inf"];
          } else if (value === -Infinity) {
            return ["-inf"];
          } else {
            return ["nan"];
          }
        } else {
          // Supported directly by JSON.
          return value;
        }

      case "object": {
        let object = <Record<string, unknown>>value;
        let result: Record<string, unknown> = {};
        for (let key in object) {
          result[key] = this.devaluateImpl(object[key], object, depth + 1);
        }
        return result;
      }

      case "array": {
        let array = <Array<unknown>>value;
        let len = array.length;
        let result = new Array(len);
        for (let i = 0; i < len; i++) {
          result[i] = this.devaluateImpl(array[i], array, depth + 1);
        }
        // Wrap literal arrays in an outer one-element array, to "escape" them.
        return [result];
      }

      case "bigint":
        // At structuredClonable level, keep BigInt as native value