How to use the @xviz/parser.parseXVIZData function in @xviz/parser

tape('parseXVIZData timeslice', t => {
  resetXVIZConfigAndSettings();
  setXVIZConfig({currentMajorVersion: 2});

  // NOTE: no explicit type for this message yet.
  let result = parseXVIZData({...TestTimesliceMessageV2}, {v2Type: 'state_update'});
  t.equals(result.type, XVIZ_MESSAGE_TYPE.TIMESLICE, 'Message type set for timeslice');
  t.equal(result.updateType, 'COMPLETE', 'XVIZ update type is parsed');
  t.equals(
    result.timestamp,
    TestTimesliceMessageV2.updates[0].poses['/vehicle_pose'].timestamp,
    'Message timestamp set from vehicle_pose'
  );

  // Incremental update
  result = parseXVIZData(
    {...TestTimesliceMessageV2, update_type: 'INCREMENTAL'},
    {v2Type: 'state_update'}
  );
  t.equals(result.type, XVIZ_MESSAGE_TYPE.TIMESLICE, 'Message type set for timeslice');
  t.equal(result.updateType, 'INCREMENTAL', 'XVIZ update type is parsed');

tape('parseXVIZData timeslice without parsing metadata (v1)', t => {
  // NOTE: this is the the teleassist case where they don't have metadata
  // before they start sending log data
  resetXVIZConfigAndSettings();
  setXVIZConfig({PRIMARY_POSE_STREAM: '/vehicle_pose'});
  setXVIZConfig({currentMajorVersion: 1});

  // NOTE: no explicit type for this message yet.
  const metaMessage = parseXVIZData({...TestTimesliceMessageV1});
  t.equals(metaMessage.type, XVIZ_MESSAGE_TYPE.TIMESLICE, 'Message type set for timeslice');
  t.equals(
    metaMessage.timestamp,
    TestTimesliceMessageV1.vehicle_pose.time,
    'Message timestamp set from timeslice'
  );
  t.ok(
    metaMessage.streams['/test/stream'].pointCloud,
    'v1 pointCloud is parsed even if metadata was not seen'
  );
  t.is(
    metaMessage.streams['/test/stream'].features[0].type,
    'points3d',
    'pointCloud exposed in features'
  );
  t.deepEquals(metaMessage.streams['/test/stream'].pointCloud.ids, [1234], 'v1 ids are populated');

{...TestTimesliceMessageV2, update_type: 'INCREMENTAL'},
    {v2Type: 'state_update'}
  );
  t.equals(result.type, XVIZ_MESSAGE_TYPE.TIMESLICE, 'Message type set for timeslice');
  t.equal(result.updateType, 'INCREMENTAL', 'XVIZ update type is parsed');

  // Deprecated 'snapshot' update type
  result = parseXVIZData(
    {...TestTimesliceMessageV2, update_type: 'SNAPSHOT'},
    {v2Type: 'state_update'}
  );
  t.equals(result.type, XVIZ_MESSAGE_TYPE.TIMESLICE, 'Message type set for timeslice');
  t.equal(result.updateType, 'INCREMENTAL', 'XVIZ update type is parsed');

  // Unknown update type
  result = parseXVIZData({...TestTimesliceMessageV2, update_type: ''}, {v2Type: 'state_update'});
  t.equals(
    result.type,
    XVIZ_MESSAGE_TYPE.INCOMPLETE,
    'Should not parse timeslice of unsupported update type'
  );

  t.end();
});

tape('parseXVIZData preProcessPrimitive type change', t => {
  let calledPreProcess = false;
  resetXVIZConfigAndSettings();
  setXVIZConfig({currentMajorVersion: 1});
  setXVIZConfig({
    PRIMARY_POSE_STREAM: '/vehicle_pose',
    preProcessPrimitive: ({primitive, streamName, time}) => {
      calledPreProcess = true;
      primitive.type = 'circle2d';
    }
  });

  // NOTE: no explicit type for this message yet.
  const metaMessage = parseXVIZData({...TestTimesliceMessageV1});

  t.ok(calledPreProcess, 'Called preProcessPrimitive callback');
  t.equals(
    metaMessage.streams['/test/stream'].pointCloud,
    null,
    'There are no pointClouds in parsed object'
  );

  t.end();
});

tape('parseXVIZData timeslice', t => {
  resetXVIZConfigAndSettings();
  setXVIZConfig({currentMajorVersion: 2});

  // NOTE: no explicit type for this message yet.
  let result = parseXVIZData({...TestTimesliceMessageV2}, {v2Type: 'state_update'});
  t.equals(result.type, XVIZ_MESSAGE_TYPE.TIMESLICE, 'Message type set for timeslice');
  t.equal(result.updateType, 'COMPLETE', 'XVIZ update type is parsed');
  t.equals(
    result.timestamp,
    TestTimesliceMessageV2.updates[0].poses['/vehicle_pose'].timestamp,
    'Message timestamp set from vehicle_pose'
  );

  // Incremental update
  result = parseXVIZData(
    {...TestTimesliceMessageV2, update_type: 'INCREMENTAL'},
    {v2Type: 'state_update'}
  );
  t.equals(result.type, XVIZ_MESSAGE_TYPE.TIMESLICE, 'Message type set for timeslice');
  t.equal(result.updateType, 'INCREMENTAL', 'XVIZ update type is parsed');

  // Deprecated 'snapshot' update type
  result = parseXVIZData(
    {...TestTimesliceMessageV2, update_type: 'SNAPSHOT'},
    {v2Type: 'state_update'}
  );
  t.equals(result.type, XVIZ_MESSAGE_TYPE.TIMESLICE, 'Message type set for timeslice');
  t.equal(result.updateType, 'INCREMENTAL', 'XVIZ update type is parsed');

  // Unknown update type
  result = parseXVIZData({...TestTimesliceMessageV2, update_type: ''}, {v2Type: 'state_update'});

tape('parseXVIZData metadata with full log time only', t => {
  resetXVIZConfigAndSettings();

  const metaMessage = parseXVIZData(metadataWithLogStartEnd, {v2Type: 'metadata'});

  t.equals(metaMessage.type, XVIZ_MESSAGE_TYPE.METADATA, 'Metadata type set');
  t.equals(
    getXVIZConfig().currentMajorVersion,
    2,
    'Metadata currentMajorVersion set after parsing'
  );

  t.equals(
    metaMessage.logStartTime,
    metadataWithLogStartEnd.log_info.log_start_time,
    'Metadata logStartTime set'
  );
  t.equals(
    metaMessage.logEndTime,
    metadataWithLogStartEnd.log_info.log_end_time,

    () => parseXVIZData(TestMetadataMessageV2, {v2Type: 'metadata'}),
    /XVIZ version 2 is not supported/,

tape('parseXVIZData state_update, PERSISTENT', t => {
  resetXVIZConfigAndSettings();
  setXVIZConfig({currentMajorVersion: 2, ALLOW_MISSING_PRIMARY_POSE: true});

  const persistentMsg = {...TestTimesliceMessageV2};
  persistentMsg.update_type = 'PERSISTENT';

  const result = parseXVIZData(persistentMsg, {v2Type: 'state_update'});
  t.equals(result.type, XVIZ_MESSAGE_TYPE.TIMESLICE, 'Message type set for timeslice');
  t.equal(result.updateType, 'PERSISTENT', 'XVIZ update type is parsed');
  t.equals(result.timestamp, TestTimesliceMessageV2.updates[0].timestamp, 'Message timestamp set');

  const feature = result.streams['/test/stream'].features[0];
  t.equal(feature.type, 'point', 'feature has type point');
  t.deepEquals(Array.from(feature.points), [1000, 1000, 200], 'feature has type point');

  t.end();
});

...TestTimesliceMessageV2,
      updates: [
        {
          poses: {
            '/vehicle_pose': {
              map_origin: {longitude: 11.2, latitude: 33.4, altitude: 55.6}
            }
          }
        }
      ]
    },
    {v2Type: 'state_update'}
  );
  t.equals(metaMessage.type, XVIZ_MESSAGE_TYPE.INCOMPLETE, 'Missing updates is incomplete');

  metaMessage = parseXVIZData(
    {
      ...TestTimesliceMessageV2,
      updates: [
        {
          timestamp: null
        }
      ]
    },
    {v2Type: 'state_update'}
  );
  t.equals(metaMessage.type, XVIZ_MESSAGE_TYPE.INCOMPLETE, 'Missing timestamp is incomplete');

  t.end();
});

tape('parseXVIZData metadata v1', t => {
  resetXVIZConfigAndSettings();
  setXVIZConfig({supportedVersions: [1]});

  const metaMessage = parseXVIZData(TestMetadataMessageV1);

  t.equals(metaMessage.type, XVIZ_MESSAGE_TYPE.METADATA, 'Metadata type set');
  t.equals(
    getXVIZConfig().currentMajorVersion,
    1,
    'Metadata currentMajorVersion set after parsing'
  );

  t.equals(
    metaMessage.eventStartTime,
    TestMetadataMessageV2.log_info.start_time,
    'Metadata eventStartTime set'
  );
  t.equals(
    metaMessage.eventEndTime,
    TestMetadataMessageV2.log_info.end_time,