react-native-firebase-compiled/es5/modules/firestore/utils/serialize.js

A well tested, feature rich Firebase implementation for React Native, supporting iOS & Android. Individual module support for Admob, Analytics, Auth, Crash Reporting, Cloud Firestore, Database, Dynamic Links, Functions, Messaging (FCM), Remote Config, Sto

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.parseNativeMap = exports.buildTypeMap = exports.buildNativeArray = exports.buildNativeMap = void 0;

var _DocumentReference = _interopRequireDefault(require("../DocumentReference"));

var _Blob = _interopRequireDefault(require("../Blob"));

var _FieldPath = require("../FieldPath");

var _FieldValue = require("../FieldValue");

var _GeoPoint = _interopRequireDefault(require("../GeoPoint"));

var _Path = _interopRequireDefault(require("../Path"));

var _utils = require("../../../utils");

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/*
 * Functions that build up the data needed to represent
 * the different types available within Firestore
 * for transmission to the native side
 */
const buildNativeMap = data => {
  const nativeData = {};

  if (data) {
    Object.keys(data).forEach(key => {
      const typeMap = buildTypeMap(data[key]);

      if (typeMap) {
        nativeData[key] = typeMap;
      }
    });
  }

  return nativeData;
};

exports.buildNativeMap = buildNativeMap;

const buildNativeArray = array => {
  const nativeArray = [];

  if (array) {
    array.forEach(value => {
      const typeMap = buildTypeMap(value);

      if (typeMap) {
        nativeArray.push(typeMap);
      }
    });
  }

  return nativeArray;
};

exports.buildNativeArray = buildNativeArray;

const buildTypeMap = value => {
  const type = (0, _utils.typeOf)(value);

  if (value === null || value === undefined || Number.isNaN(value)) {
    return {
      type: 'null',
      value: null
    };
  }

  if (value === _FieldValue.DELETE_FIELD_VALUE) {
    return {
      type: 'fieldvalue',
      value: 'delete'
    };
  }

  if (value === _FieldValue.SERVER_TIMESTAMP_FIELD_VALUE) {
    return {
      type: 'fieldvalue',
      value: 'timestamp'
    };
  }

  if (value === _FieldPath.DOCUMENT_ID) {
    return {
      type: 'documentid',
      value: null
    };
  }

  if (type === 'boolean' || type === 'number' || type === 'string') {
    return {
      type,
      value
    };
  }

  if (type === 'array') {
    return {
      type,
      value: buildNativeArray(value)
    };
  }

  if (type === 'object') {
    if (value instanceof _DocumentReference.default) {
      return {
        type: 'reference',
        value: value.path
      };
    }

    if (value instanceof _GeoPoint.default) {
      return {
        type: 'geopoint',
        value: {
          latitude: value.latitude,
          longitude: value.longitude
        }
      };
    }

    if (value instanceof Date) {
      return {
        type: 'date',
        value: value.getTime()
      };
    }

    if (value instanceof _Blob.default) {
      return {
        type: 'blob',
        value: value.toBase64()
      };
    }

    return {
      type: 'object',
      value: buildNativeMap(value)
    };
  }

  console.warn(`Unknown data type received ${type}`);
  return null;
};
/*
 * Functions that parse the received from the native
 * side and converts to the correct Firestore JS types
 */


exports.buildTypeMap = buildTypeMap;

const parseNativeMap = (firestore, nativeData) => {
  let data;

  if (nativeData) {
    data = {};
    Object.keys(nativeData).forEach(key => {
      data[key] = parseTypeMap(firestore, nativeData[key]);
    });
  }

  return data;
};

exports.parseNativeMap = parseNativeMap;

const parseNativeArray = (firestore, nativeArray) => {
  const array = [];

  if (nativeArray) {
    nativeArray.forEach(typeMap => {
      array.push(parseTypeMap(firestore, typeMap));
    });
  }

  return array;
};

const parseTypeMap = (firestore, typeMap) => {
  const type = typeMap.type,
        value = typeMap.value;

  if (type === 'null') {
    return null;
  }

  if (type === 'boolean' || type === 'number' || type === 'string') {
    return value;
  }

  if (type === 'array') {
    return parseNativeArray(firestore, value);
  }

  if (type === 'object') {
    return parseNativeMap(firestore, value);
  }

  if (type === 'reference') {
    return new _DocumentReference.default(firestore, _Path.default.fromName(value));
  }

  if (type === 'geopoint') {
    return new _GeoPoint.default(value.latitude, value.longitude);
  }

  if (type === 'date') {
    return new Date(value);
  }

  if (type === 'blob') {
    return _Blob.default.fromBase64String(value);
  }

  console.warn(`Unknown data type received ${type}`);
  return value;
};